{"version":3,"file":"rdflib.min.js","mappings":"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","sources":["webpack://$rdf/webpack/universalModuleDefinition","webpack://$rdf/webpack/runtime/create fake namespace object","webpack://$rdf/webpack/runtime/load script","webpack://$rdf/./src/class-order.ts","webpack://$rdf/./src/log.js","webpack://$rdf/./src/named-node.ts","webpack://$rdf/./src/node-internal.ts","webpack://$rdf/./src/types.ts","webpack://$rdf/./src/uri.ts","webpack://$rdf/./src/utils-js.js","webpack://$rdf/./src/utils/termValue.ts","webpack://$rdf/./src/utils/terms.ts","webpack://$rdf/./node_modules/@frogcat/ttl2jsonld/ttl2jsonld.js","webpack://$rdf/./node_modules/assert/build/assert.js","webpack://$rdf/./node_modules/assert/build/internal/assert/assertion_error.js","webpack://$rdf/./node_modules/assert/build/internal/errors.js","webpack://$rdf/./node_modules/assert/build/internal/util/comparisons.js","webpack://$rdf/./node_modules/base64-js/index.js","webpack://$rdf/./node_modules/buffer/index.js","webpack://$rdf/./node_modules/call-bind/callBound.js","webpack://$rdf/./node_modules/call-bind/index.js","webpack://$rdf/./node_modules/console-browserify/index.js","webpack://$rdf/./node_modules/cross-fetch/dist/browser-ponyfill.js","webpack://$rdf/./node_modules/define-properties/index.js","webpack://$rdf/./node_modules/es6-object-assign/index.js","webpack://$rdf/./node_modules/for-each/index.js","webpack://$rdf/./node_modules/function-bind/implementation.js","webpack://$rdf/./node_modules/function-bind/index.js","webpack://$rdf/./node_modules/get-intrinsic/index.js","webpack://$rdf/./node_modules/gopd/index.js","webpack://$rdf/./node_modules/has-property-descriptors/index.js","webpack://$rdf/./node_modules/has-symbols/index.js","webpack://$rdf/./node_modules/has-symbols/shams.js","webpack://$rdf/./node_modules/has-tostringtag/shams.js","webpack://$rdf/./node_modules/has/src/index.js","webpack://$rdf/./node_modules/ieee754/index.js","webpack://$rdf/./node_modules/inherits/inherits_browser.js","webpack://$rdf/./node_modules/is-arguments/index.js","webpack://$rdf/./node_modules/is-callable/index.js","webpack://$rdf/./node_modules/is-generator-function/index.js","webpack://$rdf/./node_modules/is-nan/implementation.js","webpack://$rdf/./node_modules/is-nan/index.js","webpack://$rdf/./node_modules/is-nan/polyfill.js","webpack://$rdf/./node_modules/is-nan/shim.js","webpack://$rdf/./node_modules/is-typed-array/index.js","webpack://$rdf/./node_modules/object-is/implementation.js","webpack://$rdf/./node_modules/object-is/index.js","webpack://$rdf/./node_modules/object-is/polyfill.js","webpack://$rdf/./node_modules/object-is/shim.js","webpack://$rdf/./node_modules/object-keys/implementation.js","webpack://$rdf/./node_modules/object-keys/index.js","webpack://$rdf/./node_modules/object-keys/isArguments.js","webpack://$rdf/./node_modules/process/browser.js","webpack://$rdf/./node_modules/querystring/decode.js","webpack://$rdf/./node_modules/querystring/encode.js","webpack://$rdf/./node_modules/querystring/index.js","webpack://$rdf/./node_modules/queue-microtask/index.js","webpack://$rdf/./node_modules/solid-namespace/index.js","webpack://$rdf/./node_modules/url/node_modules/punycode/punycode.js","webpack://$rdf/./node_modules/url/url.js","webpack://$rdf/./node_modules/url/util.js","webpack://$rdf/./node_modules/util/support/isBufferBrowser.js","webpack://$rdf/./node_modules/util/support/types.js","webpack://$rdf/./node_modules/util/util.js","webpack://$rdf/./node_modules/which-typed-array/index.js","webpack://$rdf/external umd \"window\"","webpack://$rdf/./node_modules/@babel/runtime/helpers/regeneratorRuntime.js","webpack://$rdf/./node_modules/@babel/runtime/helpers/typeof.js","webpack://$rdf/./node_modules/@babel/runtime/regenerator/index.js","webpack://$rdf/./node_modules/available-typed-arrays/index.js","webpack://$rdf/./node_modules/@babel/runtime/helpers/esm/classCallCheck.js","webpack://$rdf/./node_modules/@babel/runtime/helpers/esm/createClass.js","webpack://$rdf/./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack://$rdf/./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","webpack://$rdf/./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack://$rdf/./node_modules/@babel/runtime/helpers/esm/inherits.js","webpack://$rdf/./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js","webpack://$rdf/./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","webpack://$rdf/./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","webpack://$rdf/./node_modules/@babel/runtime/helpers/esm/toPrimitive.js","webpack://$rdf/./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack://$rdf/webpack/bootstrap","webpack://$rdf/webpack/runtime/compat get default export","webpack://$rdf/webpack/runtime/define property getters","webpack://$rdf/webpack/runtime/ensure chunk","webpack://$rdf/webpack/runtime/get javascript chunk filename","webpack://$rdf/webpack/runtime/global","webpack://$rdf/webpack/runtime/harmony module decorator","webpack://$rdf/webpack/runtime/hasOwnProperty shorthand","webpack://$rdf/webpack/runtime/make namespace object","webpack://$rdf/webpack/runtime/node module decorator","webpack://$rdf/webpack/runtime/publicPath","webpack://$rdf/webpack/runtime/jsonp chunk loading","webpack://$rdf/./src/blank-node.ts","webpack://$rdf/./src/xsd-internal.js","webpack://$rdf/./src/literal.ts","webpack://$rdf/./src/collection.ts","webpack://$rdf/./src/empty.ts","webpack://$rdf/./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","webpack://$rdf/./src/utils/default-graph-uri.ts","webpack://$rdf/./src/default-graph.ts","webpack://$rdf/./src/statement.ts","webpack://$rdf/./src/variable.ts","webpack://$rdf/./src/factories/factory-types.ts","webpack://$rdf/./src/factories/canonical-data-factory.ts","webpack://$rdf/./src/namespace.ts","webpack://$rdf/./src/xsd.js","webpack://$rdf/./src/serializer.js","webpack://$rdf/./src/serialize.ts","webpack://$rdf/./src/utils.ts","webpack://$rdf/./src/formula.ts","webpack://$rdf/./src/node.ts","webpack://$rdf/./src/query.js","webpack://$rdf/./src/store.ts","webpack://$rdf/./src/lists.ts","webpack://$rdf/./src/n3parser.js","webpack://$rdf/./src/factories/extended-term-factory.ts","webpack://$rdf/./src/jsonldparser.js","webpack://$rdf/./node_modules/n3/src/IRIs.js","webpack://$rdf/./node_modules/n3/src/N3Lexer.js","webpack://$rdf/./node_modules/n3/src/N3DataFactory.js","webpack://$rdf/./node_modules/n3/src/N3Parser.js","webpack://$rdf/./src/rdfaparser.js","webpack://$rdf/./src/rdfxmlparser.js","webpack://$rdf/./src/patch-parser.js","webpack://$rdf/./src/parse.ts","webpack://$rdf/./src/fetcher.ts","webpack://$rdf/./src/jsonparser.js","webpack://$rdf/./src/query-to-sparql.js","webpack://$rdf/./src/sparql-to-query.js","webpack://$rdf/./src/update-manager.ts","webpack://$rdf/./src/factories/rdflib-data-factory.ts","webpack://$rdf/./src/updates-via.js","webpack://$rdf/./src/index.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"window\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"window\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"$rdf\"] = factory(require(\"window\"));\n\telse\n\t\troot[\"$rdf\"] = factory(root[\"window\"]);\n})(self, (__WEBPACK_EXTERNAL_MODULE__8392__) => {\nreturn ","var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","var inProgress = {};\nvar dataWebpackPrefix = \"$rdf:\";\n// loadScript function to load a script via script tag\n__webpack_require__.l = (url, done, key, chunkId) => {\n\tif(inProgress[url]) { inProgress[url].push(done); return; }\n\tvar script, needAttach;\n\tif(key !== undefined) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tfor(var i = 0; i < scripts.length; i++) {\n\t\t\tvar s = scripts[i];\n\t\t\tif(s.getAttribute(\"src\") == url || s.getAttribute(\"data-webpack\") == dataWebpackPrefix + key) { script = s; break; }\n\t\t}\n\t}\n\tif(!script) {\n\t\tneedAttach = true;\n\t\tscript = document.createElement('script');\n\n\t\tscript.charset = 'utf-8';\n\t\tscript.timeout = 120;\n\t\tif (__webpack_require__.nc) {\n\t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n\t\t}\n\t\tscript.setAttribute(\"data-webpack\", dataWebpackPrefix + key);\n\n\t\tscript.src = url;\n\t}\n\tinProgress[url] = [done];\n\tvar onScriptComplete = (prev, event) => {\n\t\t// avoid mem leaks in IE.\n\t\tscript.onerror = script.onload = null;\n\t\tclearTimeout(timeout);\n\t\tvar doneFns = inProgress[url];\n\t\tdelete inProgress[url];\n\t\tscript.parentNode && script.parentNode.removeChild(script);\n\t\tdoneFns && doneFns.forEach((fn) => (fn(event)));\n\t\tif(prev) return prev(event);\n\t}\n\tvar timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);\n\tscript.onerror = onScriptComplete.bind(null, script.onerror);\n\tscript.onload = onScriptComplete.bind(null, script.onload);\n\tneedAttach && document.head.appendChild(script);\n};","/**\n* Class orders\n*/\nconst ClassOrder: {\n  [id: string]: number;\n} = {\n  'Literal': 1,\n  'Collection': 3,\n  'Graph': 4,\n  'NamedNode': 5,\n  'BlankNode': 6,\n  'Variable': 7\n}\n\nexport default ClassOrder\n","/**\n * A Dummy log\n * @module log\n */\nconst log = {\n  debug (x) {},\n  warn (x) {},\n  info (x) {},\n  error (x) {},\n  success (x) {},\n  msg (x) {},\n}\nexport default log\n","import ClassOrder from './class-order'\nimport Node from './node-internal'\nimport { NamedNodeTermType } from './types'\nimport { termValue } from './utils/termValue'\nimport { NamedNode as TFNamedNode } from './tf-types'\nimport { isTerm } from './utils/terms'\n\n/**\n * A named (IRI) RDF node\n */\nexport default class NamedNode extends Node implements TFNamedNode {\n  termType: typeof NamedNodeTermType = NamedNodeTermType\n  classOrder = ClassOrder.NamedNode\n\n  /**\n   * Create a named (IRI) RDF Node\n   * @constructor\n   * @param iri - The IRI for this node\n   */\n  constructor (iri: string) {\n    super(termValue(iri))\n\n    if (!this.value) {\n      throw new Error('Missing IRI for NamedNode')\n    }\n\n    if (!this.value.includes(':')) {\n      throw new Error('NamedNode IRI \"' + iri + '\" must be absolute.')\n    }\n\n    if (this.value.includes(' ')) {\n      var message = 'Error: NamedNode IRI \"' + iri + '\" must not contain unencoded spaces.'\n      throw new Error(message)\n    }\n  }\n\n  /**\n   * Returns an $rdf node for the containing directory, ending in slash.\n   */\n  dir (): NamedNode | null {\n     var str = this.value.split('#')[0]\n     var p = str.slice(0, -1).lastIndexOf('/')\n     var q = str.indexOf('//')\n     if ((q >= 0 && p < q + 2) || p < 0) return null\n     return new NamedNode(str.slice(0, p + 1))\n   }\n\n  /**\n   * Returns an NN for the whole web site, ending in slash.\n   * Contrast with the \"origin\" which does NOT have a trailing slash\n   */\n  site (): NamedNode {\n     var str = this.value.split('#')[0]\n     var p = str.indexOf('//')\n     if (p < 0) throw new Error('This URI does not have a web site part (origin)')\n     var q = str.indexOf('/', p+2)\n     if (q < 0) {\n       return new NamedNode(str.slice(0) + '/')   // Add slash to a bare origin\n     } else {\n       return new NamedNode(str.slice(0, q + 1))\n     }\n   }\n\n  /**\n   * Creates the fetchable named node for the document.\n   * Removes everything from the # anchor tag.\n   */\n  doc (): NamedNode {\n    if (this.value.indexOf('#') < 0) {\n      return this\n    } else {\n      return new NamedNode(this.value.split('#')[0])\n    }\n  }\n\n  /**\n   * Returns the URI including <brackets>\n   */\n  toString (): string {\n    return '<' + this.value + '>'\n  }\n\n  /** The local identifier with the document */\n  id (): string {\n    return this.value.split('#')[1]\n  }\n\n  /** Alias for value, favored by Tim */\n  get uri (): string {\n    return this.value\n  }\n\n  set uri (uri: string) {\n    this.value = uri\n  }\n\n  /**\n   * Creates a named node from the specified input value\n   * @param value - An input value\n   */\n  static fromValue (value) {\n    if (typeof value === 'undefined' || value === null) {\n      return value\n    }\n    if (isTerm(value)) {\n      return value\n    }\n    return new NamedNode(value)\n  }\n}\n","import { ValueType, Bindings, FromValueReturns, TermType } from './types'\nimport { Term } from './tf-types'\n\n/**\n * The superclass of all RDF Statement objects, that is\n * NamedNode, Literal, BlankNode, etc.\n * Should not be instantiated directly.\n * Also called Term.\n * @link https://rdf.js.org/data-model-spec/#term-interface\n * @class Node\n */\nexport default abstract class Node {\n  // Specified in './node.ts' to prevent circular dependency\n  static fromValue: <T extends FromValueReturns>(value: ValueType) => T\n  // Specified in './node.ts' to prevent circular dependency\n  static toJS: (term: any) => Date | Number | string | boolean | object | Array<Date | Number | string | boolean | object>;\n\n  /** The type of node */\n  termType!: TermType;\n\n  /** The class order for this node */\n  classOrder!: number;\n\n  /** The node's value */\n  value: string;\n\n  protected constructor(value: string) {\n    this.value = value\n  }\n\n  /**\n   * Creates the substituted node for this one, according to the specified bindings\n   * @param bindings - Bindings of identifiers to nodes\n   */\n  substitute <T extends Node = Node>(bindings: Bindings): T {\n    return this as unknown as T\n  }\n\n  /**\n   * Compares this node with another\n   * @see {equals} to check if two nodes are equal\n   * @param other - The other node\n   */\n  compareTerm (other: Node): number {\n    if (this.classOrder < other.classOrder) {\n      return -1\n    }\n    if (this.classOrder > other.classOrder) {\n      return +1\n    }\n    if (this.value < other.value) {\n      return -1\n    }\n    if (this.value > other.value) {\n      return +1\n    }\n    return 0\n  }\n\n  /**\n   * Compares whether the two nodes are equal\n   * @param other The other node\n   */\n  equals (other: Term): boolean {\n    if (!other) {\n      return false\n    }\n    return (this.termType === other.termType) &&\n      (this.value === other.value)\n  }\n\n  /**\n   * Creates a hash for this node\n   * @deprecated use {rdfFactory.id} instead if possible\n   */\n  hashString (): string {\n    return this.toCanonical()\n  }\n\n  /**\n   * Compares whether this node is the same as the other one\n   * @param other - Another node\n   */\n  sameTerm(other: Node): boolean {\n    return this.equals(other)\n\n  }\n\n  /**\n   * Creates a canonical string representation of this node\n   */\n  toCanonical (): string {\n    return this.toNT()\n  }\n\n  /**\n   * Creates a n-triples string representation of this node\n   */\n  toNT (): string {\n    return this.toString()\n  }\n\n  /**\n   * Creates a n-quads string representation of this node\n   */\n  toNQ (): string {\n    return this.toNT();\n  }\n\n  /**\n   * Creates a string representation of this node\n   */\n  toString (): string {\n    throw new Error('Node.toString() is abstract - see the subclasses instead')\n  }\n}\n","import Node from './node-internal'\nimport RDFlibVariable from './variable'\nimport RDFlibBlankNode from './blank-node'\nimport Collection from './collection'\nimport RDFlibLiteral from './literal'\nimport RDFlibNamedNode from './named-node'\nimport RDFlibDefaultGraph from './default-graph'\nimport { DataFactory } from './factories/factory-types'\nimport IndexedFormula from './store'\nimport Fetcher from './fetcher'\nimport Statement from './statement'\nimport Empty from './empty'\nimport { NamedNode, Term, Quad_Subject, Quad_Predicate, Quad_Object, Quad_Graph } from './tf-types'\n\nexport const NamedNodeTermType = \"NamedNode\" as const\nexport const BlankNodeTermType = \"BlankNode\" as const\nexport const LiteralTermType = \"Literal\" as const\nexport const VariableTermType = \"Variable\" as const\nexport const DefaultGraphTermType = \"DefaultGraph\" as const\n// Non-RDF/JS types:\nexport const CollectionTermType = \"Collection\" as const\nexport const EmptyTermType = \"Empty\" as const\nexport const GraphTermType = \"Graph\" as const\n\nexport type TermType = typeof NamedNodeTermType\n  | typeof BlankNodeTermType\n  | typeof LiteralTermType\n  | typeof VariableTermType\n  | typeof DefaultGraphTermType\n  | typeof CollectionTermType\n  | typeof EmptyTermType\n  | typeof GraphTermType\n\nexport const HTMLContentType = \"text/html\" as const\nexport const JSONLDContentType = \"application/ld+json\" as const\nexport const N3ContentType = \"text/n3\" as const\nexport const N3LegacyContentType = \"application/n3\" as const\nexport const NQuadsAltContentType = \"application/nquads\" as const\nexport const NQuadsContentType = \"application/n-quads\" as const\nexport const NTriplesContentType = \"application/n-triples\" as const\nexport const RDFXMLContentType = \"application/rdf+xml\" as const\nexport const SPARQLUpdateContentType = \"application/sparql-update\" as const\nexport const SPARQLUpdateSingleMatchContentType = \"application/sparql-update-single-match\" as const\nexport const TurtleContentType = \"text/turtle\" as const\nexport const TurtleLegacyContentType = \"application/x-turtle\" as const\nexport const XHTMLContentType = \"application/xhtml+xml\" as const\n\n/**\n * A valid mime type header\n */\nexport type ContentType = typeof RDFXMLContentType\n  | typeof HTMLContentType\n  | typeof JSONLDContentType\n  | typeof N3ContentType\n  | typeof N3LegacyContentType\n  | typeof NQuadsAltContentType\n  | typeof NQuadsContentType\n  | typeof SPARQLUpdateContentType\n  | typeof SPARQLUpdateSingleMatchContentType\n  | typeof TurtleContentType\n  | typeof TurtleLegacyContentType\n  | typeof XHTMLContentType\n\n/** A type for values that serves as inputs */\nexport type ValueType = Term | Node | Date | string | number | boolean | undefined | null | Collection\n\n/**\n * In this project, there exist two types for the same kind of RDF concept.\n * We have RDF/JS spec types (standardized, generic), and RDFlib types (internal, specific).\n * When deciding which type to use in a function, it is preferable to accept generic inputs,\n * whenever possible, and provide strict outputs.\n * In some ways, the TF types in here are a bit more strict.\n * Variables are missing, and the statement requires specific types of terms (e.g. NamedNode instead of Term).\n */\n\n/** An RDF/JS Subject */\nexport type SubjectType = RDFlibBlankNode | RDFlibNamedNode | RDFlibVariable\n/** An RDF/JS Predicate */\nexport type PredicateType = RDFlibNamedNode | RDFlibVariable\n/** An RDF/JS Object */\nexport type ObjectType = RDFlibNamedNode | RDFlibLiteral | Collection | RDFlibBlankNode | RDFlibVariable | Empty\n/** An RDF/JS Graph */\nexport type GraphType = RDFlibDefaultGraph | RDFlibNamedNode | RDFlibVariable // | Formula\n\nexport interface Bindings {\n  [id: string]: Term;\n}\n\n/** All the types that a .fromValue() method might return */\nexport type FromValueReturns<C extends Node = any> = Term | undefined | null | Collection<C>\n\nexport interface IRDFlibDataFactory extends DataFactory<\n  RDFlibNamedNode | RDFlibBlankNode | RDFlibLiteral | Collection | Statement\n> {\n  fetcher: (store: IndexedFormula, options: any) => Fetcher\n  lit: (val: string, lang?: string, dt?: NamedNode) => RDFlibLiteral\n  graph: (features?, opts?) => IndexedFormula\n  st: (\n    subject: Quad_Subject,\n    predicate: Quad_Predicate,\n    object: Quad_Object,\n    graph?: Quad_Graph\n  ) => Statement\n}\n","/*\n * Implements URI-specific functions\n *\n * See RFC 2386\n *\n * See also:\n *   http://www.w3.org/2005/10/ajaw/uri.js\n *   http://www.w3.org/2000/10/swap/uripath.py\n *\n */\nvar alert = alert || console.log\n\nimport RDFlibNamedNode from './named-node'\n\n/**\n * Gets the document part of an URI\n * @param uri The URI\n */\nexport function docpart(uri: string): string {\n  var i: number\n  i = uri.indexOf('#')\n  if (i < 0) {\n    return uri\n  } else {\n    return uri.slice(0, i)\n  }\n}\n\n/**\n * Gets the document part of an URI as a named node\n * @param x - The URI\n */\nexport function document(x: string): RDFlibNamedNode {\n  return new RDFlibNamedNode(docpart(x))\n}\n\n/**\n * Gets the hostname in an URI\n * @param u The URI\n */\nexport function hostpart(u: string): string {\n  var m = /[^\\/]*\\/\\/([^\\/]*)\\//.exec(u)\n  if (m) {\n    return m[1]\n  } else {\n    return ''\n  }\n}\n\n/**\n * Joins an URI with a base\n * @param given - The relative part\n * @param base - The base URI\n */\nexport function join(given: string, base: string): string {\n  var baseColon, baseScheme, baseSingle\n  var colon, lastSlash, path\n  var baseHash = base.indexOf('#')\n  if (baseHash > 0) {\n    base = base.slice(0, baseHash)\n  }\n  if (given.length === 0) {\n    return base\n  }\n  if (given.indexOf('#') === 0) {\n    return base + given\n  }\n  colon = given.indexOf(':')\n  if (colon >= 0) {\n    return given\n  }\n  baseColon = base.indexOf(':')\n  if (base.length === 0) {\n    return given\n  }\n  if (baseColon < 0) {\n    alert('Invalid base: ' + base + ' in join with given: ' + given)\n    return given\n  }\n  baseScheme = base.slice(0, +baseColon + 1 || 9e9)\n  if (given.indexOf('//') === 0) {\n    return baseScheme + given\n  }\n  if (base.indexOf('//', baseColon) === baseColon + 1) {\n    baseSingle = base.indexOf('/', baseColon + 3)\n    if (baseSingle < 0) {\n      if (base.length - baseColon - 3 > 0) {\n        return base + '/' + given\n      } else {\n        return baseScheme + given\n      }\n    }\n  } else {\n    baseSingle = base.indexOf('/', baseColon + 1)\n    if (baseSingle < 0) {\n      if (base.length - baseColon - 1 > 0) {\n        return base + '/' + given\n      } else {\n        return baseScheme + given\n      }\n    }\n  }\n  if (given.indexOf('/') === 0) {\n    return base.slice(0, baseSingle) + given\n  }\n  path = base.slice(baseSingle)\n  lastSlash = path.lastIndexOf('/')\n  if (lastSlash < 0) {\n    return baseScheme + given\n  }\n  if (lastSlash >= 0 && lastSlash < path.length - 1) {\n    path = path.slice(0, +lastSlash + 1 || 9e9)\n  }\n  path += given\n  while (path.match(/[^\\/]*\\/\\.\\.\\//)) {\n    path = path.replace(/[^\\/]*\\/\\.\\.\\//, '')\n  }\n  path = path.replace(/\\.\\//g, '')\n  path = path.replace(/\\/\\.$/, '/')\n  return base.slice(0, baseSingle) + path\n}\n\n/**\n * Gets the protocol part of an URI\n * @param uri The URI\n */\nexport function protocol(uri: string): string | null {\n  const i = uri.indexOf(':')\n  if (i < 0) {\n    return null\n  } else {\n    return uri.slice(0, i)\n  }\n}\n\n/**\n * Gets a relative uri\n * @param base The base URI\n * @param uri The absolute URI\n */\nexport function refTo(base: string, uri: string): string {\n  var c: string,\n      i: number,\n      k: number,\n      l: number,\n      len: number,\n      len1: number,\n      n: number,\n      o: number,\n      p: number,\n      q: number,\n      ref: string,\n      ref1: number,\n      s: string\n  var commonHost = new RegExp('^[-_a-zA-Z0-9.]+:(//[^/]*)?/[^/]*$')\n  if (!base) {\n    return uri\n  }\n  if (base === uri) {\n    return ''\n  }\n  for (i = o = 0, len = uri.length; o < len; i = ++o) {\n    const c = uri[i]\n    if (c !== base[i]) {\n      break\n    }\n  }\n  if (base.slice(0, i).match(commonHost)) {\n    k = uri.indexOf('//')\n    if (k < 0) {\n      k = -2\n    }\n    l = uri.indexOf('/', k + 2)\n    if (uri[l + 1] !== '/' && base[l + 1] !== '/' && uri.slice(0, l) === base.slice(0, l)) {\n      return uri.slice(l)\n    }\n  }\n  if (uri[i] === '#' && base.length === i) {\n    return uri.slice(i)\n  }\n  while (i > 0 && uri[i - 1] !== '/') {\n    i--\n  }\n  if (i < 3) {\n    return uri\n  }\n  if (base.indexOf('//', i - 2) > 0 || uri.indexOf('//', i - 2) > 0) {\n    return uri\n  }\n  if (base.indexOf(':', i) > 0) {\n    return uri\n  }\n  n = 0\n  ref = base.slice(i)\n  for (p = 0, len1 = ref.length; p < len1; p++) {\n    c = ref[p]\n    if (c === '/') {\n      n++\n    }\n  }\n  if (n === 0 && i < uri.length && uri[i] === '#') {\n    return './' + uri.slice(i)\n  }\n  if (n === 0 && i === uri.length) {\n    return './'\n  }\n  s = ''\n  if (n > 0) {\n    for (q = 1, ref1 = n; ref1 >= 1 ? q <= ref1 : q >= ref1; ref1 >= 1 ? ++q : --q) {\n      s += '../'\n    }\n  }\n  return s + uri.slice(i)\n}\n","/**\n * Utility functions for $rdf\n * @module util\n */\nimport { docpart } from './uri'\nimport log from './log'\nimport * as uri from './uri'\nimport NamedNode from './named-node'\n\nconst string = { template: stringTemplate }\n\nexport { log, uri, string }\n\nexport function mediaTypeClass(mediaType){\n  mediaType = mediaType.split(';')[0].trim()  // remove media type parameters\n  return new NamedNode('http://www.w3.org/ns/iana/media-types/' + mediaType + '#Resource')\n}\n\nexport function linkRelationProperty(relation){\n  return new NamedNode('http://www.w3.org/ns/iana/link-relations/relation#' + relation.trim())\n}\n\n/**\n * Adds callback functionality to an object.\n * Callback functions are indexed by a 'hook' string.\n * They return true if they want to be called again.\n * @method callbackify\n * @param obj {Object}\n * @param callbacks {Array<string>}\n */\nexport function callbackify (obj, callbacks) {\n  obj.callbacks = {}\n  for (var x = callbacks.length - 1; x >= 0; x--) {\n    obj.callbacks[callbacks[x]] = []\n  }\n\n  obj.addHook = function (hook) {\n    if (!obj.callbacks[hook]) {\n      obj.callbacks[hook] = []\n    }\n  }\n\n  obj.addCallback = function (hook, func) {\n    obj.callbacks[hook].push(func)\n  }\n\n  obj.removeCallback = function (hook, funcName) {\n    for (var i = 0;i < obj.callbacks[hook].length;i++) {\n      if (obj.callbacks[hook][i].name === funcName) {\n        obj.callbacks[hook].splice(i, 1)\n        return true\n      }\n    }\n    return false\n  }\n\n  obj.insertCallback = function (hook, func) {\n    obj.callbacks[hook].unshift(func)\n  }\n\n  obj.fireCallbacks = function fireCallbacks (hook, args) {\n    var newCallbacks = []\n    var replaceCallbacks = []\n    var len = obj.callbacks[hook].length\n    var x\n    let callback\n\n    // log.info('!@$ Firing '+hook+' call back with length'+len)\n    for (x = len - 1; x >= 0; x--) {\n      // log.info('@@ Firing '+hook+' callback '+ obj.callbacks[hook][x])\n      callback = obj.callbacks[hook][x]\n      if (callback && callback.apply(obj, args)) {\n        newCallbacks.push(callback)\n      }\n    }\n\n    for (x = newCallbacks.length - 1; x >= 0; x--) {\n      replaceCallbacks.push(newCallbacks[x])\n    }\n\n    for (x = len; x < obj.callbacks[hook].length; x++) {\n      replaceCallbacks.push(obj.callbacks[hook][x])\n    }\n\n    obj.callbacks[hook] = replaceCallbacks\n  }\n}\n\n/**\n * Returns a DOM parser based on current runtime environment.\n */\nexport function DOMParserFactory () {\n  if (window.DOMParser) {\n    return new DOMParser()\n  } else if (window.ActiveXObject) {\n    return new ActiveXObject('Microsoft.XMLDOM')\n  } else {\n    return false\n  }\n}\n\n// From https://github.com/linkeddata/dokieli\nexport function domToString (node, options) {\n  options = options || {}\n  var selfClosing = []\n  if (options && options.selfClosing) {\n    options.selfClosing.split(' ').forEach(function (n) {\n      selfClosing[n] = true\n    })\n  }\n  var skipAttributes = []\n  if (options && options.skipAttributes) {\n    options.skipAttributes.split(' ').forEach(function (n) {\n      skipAttributes[n] = true\n    })\n  }\n  return dumpNode(node, options, selfClosing, skipAttributes)\n}\n\nexport function dumpNode (node, options, selfClosing, skipAttributes) {\n  var i\n  var out = ''\n  var noEsc = [ false ]\n  if (typeof node.nodeType === 'undefined') return out\n  if (node.nodeType === 1) {\n    if (node.hasAttribute('class') && (options && options.classWithChildText) && node.matches(options.classWithChildText.class)) {\n      out += node.querySelector(options.classWithChildText.element).textContent\n    } else if (!((options && options.skipNodeWithClass) && node.matches('.' + options.skipNodeWithClass))) {\n      var ename = node.nodeName.toLowerCase()\n      out += '<' + ename\n\n      var attrList = []\n      for (i = node.attributes.length - 1; i >= 0; i--) {\n        var atn = node.attributes[i]\n        if (skipAttributes && skipAttributes.length > 0 && skipAttributes[atn.name]) continue\n        if (/^\\d+$/.test(atn.name)) continue\n        if (atn.name === 'class' && (options && options.replaceClassItemWith) && (atn.value.split(' ').indexOf(options.replaceClassItemWith.source) > -1)) {\n          var re = new RegExp(options.replaceClassItemWith.source, 'g')\n          atn.value = atn.value.replace(re, options.replaceClassItemWith.target).trim()\n        }\n        if (!(atn.name === 'class' && (options && options.skipClassWithValue) && options.skipClassWithValue === atn.value)) {\n          attrList.push(atn.name + '=\\'' + atn.value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/'/g, '&quot;') + '\\'')\n        }\n      }\n      if (attrList.length > 0) {\n        if (options && options.sortAttributes) {\n          attrList.sort(function (a, b) {\n            return a.toLowerCase().localeCompare(b.toLowerCase())\n          })\n        }\n        out += ' ' + attrList.join(' ')\n      }\n      if (selfClosing && selfClosing.ename) {\n        out += ' />'\n      } else {\n        out += '>'\n        out += (ename === 'html') ? '\\n  ' : ''\n        noEsc.push(ename === 'style' || ename === 'script')\n        for (i = 0; i < node.childNodes.length; i++) out += dumpNode(node.childNodes[i])\n        noEsc.pop()\n        out += (ename === 'body') ? '</' + ename + '>' + '\\n' : '</' + ename + '>'\n      }\n    }\n  } else if (node.nodeType === 8) {\n    // FIXME: If comments are not tabbed in source, a new line is not prepended\n    out += '<!--' + node.nodeValue + '-->'\n  } else if (node.nodeType === 3 || node.nodeType === 4) {\n    // XXX: Remove new lines which were added after DOM ready\n    var nl = node.nodeValue.replace(/\\n+$/, '')\n    out += noEsc[noEsc.length - 1] ? nl : nl.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')\n  } else {\n    console.log('Warning; Cannot handle serialising nodes of type: ' + node.nodeType)\n    console.log(node)\n  }\n  return out\n}\n\nexport function dtstamp () {\n  var now = new Date()\n  var year = now.getYear() + 1900\n  var month = now.getMonth() + 1\n  var day = now.getDate()\n  var hour = now.getUTCHours()\n  var minute = now.getUTCMinutes()\n  var second = now.getSeconds()\n  if (month < 10) month = '0' + month\n  if (day < 10) day = '0' + day\n  if (hour < 10) hour = '0' + hour\n  if (minute < 10) minute = '0' + minute\n  if (second < 10) second = '0' + second\n  return year + '-' + month + '-' + day + 'T' +\n    hour + ':' + minute + ':' + second + 'Z'\n}\n\n/**\n * Compares statements (heavy comparison for repeatable canonical ordering)\n */\nexport function heavyCompare (x, y, g, uriMap) {\n  var nonBlank = function (x) {\n    return (x.termType === 'BlankNode') ? null : x\n  }\n  var signature = function (x) {\n    var lis = g.statementsMatching(x).map(function (st) {\n      return ('' + nonBlank(st.subject) + ' ' + nonBlank(st.predicate) +\n        ' ' + nonBlank(st.object))\n    }).concat(g.statementsMatching(undefined, undefined, x).map(function (st) {\n      return ('' + nonBlank(st.subject) + ' ' + nonBlank(st.predicate) +\n        ' ' + nonBlank(st.object))\n    }))\n    lis.sort()\n    return lis.join('\\n')\n  }\n  const comparison = Object.prototype.hasOwnProperty.call(g, \"compareTerms\")\n    ? g.compareTerms(x, y)\n    : x.compareTerm(y)\n\n  if ((x.termType === 'BlankNode') && (y.termType === 'BlankNode')) {\n    if (comparison === 0) return 0 // Same\n    if (signature(x) > signature(y)) return +1\n    if (signature(x) < signature(y)) return -1\n    return comparison  // Too bad -- this order not canonical.\n    // throw \"different bnodes indistinquishable for sorting\"\n  } else {\n    if (uriMap && x.uri && y.uri){\n      return (uriMap[x.uri] || x.uri).localeCompare(uriMap[y.uri] || y.uri)\n    }\n    return comparison\n  }\n}\n\nexport function heavyCompareSPO (x, y, g, uriMap) {\n  return heavyCompare(x.subject, y.subject, g, uriMap) ||\n    heavyCompare(x.predicate, y.predicate, g, uriMap) ||\n    heavyCompare(x.object, y.object, g, uriMap)\n}\n\n/**\n * Defines a simple debugging function\n * @method output\n * @param o {String}\n */\nexport function output (o) {\n  var k = document.createElement('div')\n  k.textContent = o\n  document.body.appendChild(k)\n}\n\nimport { DOMParser } from '@xmldom/xmldom'\n\n/**\n * Returns a DOM from parsed XML.\n */\nexport function parseXML (str, options) {\n  var dparser\n  options = options || {}\n  if (typeof module !== 'undefined' && module && module.exports) { // Node.js\n    var dom = new DOMParser().parseFromString(str, options.contentType || 'application/xhtml+xml')\n    return dom\n  } else {\n    if (typeof window !== 'undefined' && window.DOMParser) {\n      dparser = new window.DOMParser() // seems to actually work\n    } else {\n      dparser = new DOMParser() // Doc says this works\n    }\n  }\n  return dparser.parseFromString(str, 'application/xml')\n}\n\n/**\n * Removes all statements equal to x from a\n */\nexport function RDFArrayRemove (a, x) {\n  for (var i = 0; i < a.length; i++) {\n    // TODO: This used to be the following, which didnt always work..why\n    // if(a[i] === x)\n    if (a[i].subject.equals(x.subject) &&\n      a[i].predicate.equals(x.predicate) &&\n      a[i].object.equals(x.object) &&\n      a[i].why.equals(x.why)) {\n      a.splice(i, 1)\n      return\n    }\n  }\n  throw new Error('RDFArrayRemove: Array did not contain ' + x + ' ' + x.why)\n}\n\nexport function string_startswith (str, pref) { // missing library routines\n  return (str.slice(0, pref.length) === pref)\n}\n\n/**\n * C++, python style %s -> subs\n */\nfunction stringTemplate (base, subs) {\n  var baseA = base.split('%s')\n  var result = ''\n  for (var i = 0;i < subs.length;i++) {\n    subs[i] += ''\n    result += baseA[i] + subs[i]\n  }\n  return result + baseA.slice(subs.length).join()\n}\n\n\n// Stack dump on errors - to pass errors back\n\nexport function stackString (e) {\n  var str = '' + e + '\\n'\n  if (!e.stack) {\n    return str + 'No stack available.\\n'\n  }\n  var lines = e.stack.toString().split('\\n')\n  var toprint = []\n  for (var i = 0; i < lines.length; i++) {\n    var line = lines[i]\n    if (line.indexOf('ecmaunit.js') > -1) {\n      // remove useless bit of traceback\n      break\n    }\n    if (line.charAt(0) == '(') {\n      line = 'function' + line\n    }\n    var chunks = line.split('@')\n    toprint.push(chunks)\n  }\n  // toprint.reverse();  No - I prefer the latest at the top by the error message -tbl\n\n  for (var i = 0; i < toprint.length; i++) {\n    str += '  ' + toprint[i][1] + '\\n    ' + toprint[i][0]\n  }\n  return str\n}\n","import { Term } from '../tf-types'\n\n/** Retrieve the value of a term, or self if already a string. */\nexport function termValue (node: Term | string): string {\n  if (typeof node === 'string') {\n    return node\n  }\n\n  return node.value\n}\n","import {\n  ObjectType, CollectionTermType, NamedNodeTermType, VariableTermType, BlankNodeTermType, LiteralTermType, GraphTermType, DefaultGraphTermType,\n} from '../types'\nimport Collection from '../collection'\nimport IndexedFormula from '../store'\nimport Statement from '../statement'\nimport {\n  BlankNode,\n  Quad_Graph,\n  Literal,\n  NamedNode,\n  Quad_Object,\n  Quad_Predicate,\n  Quad,\n  Quad_Subject,\n  Term,\n  Variable,\n} from '../tf-types'\n\n/** TypeGuard for RDFLib Statements */\nexport function isStatement(obj): obj is Statement {\n  return typeof obj === 'object' && obj !== null && 'subject' in obj\n}\n\n/** TypeGuard for RDFlib Stores */\nexport function isStore(obj): obj is IndexedFormula {\n  return typeof obj === 'object' && obj !== null && 'statements' in obj\n}\n\n/** TypeGuard for RDFLib Collections */\nexport function isCollection(obj: any): obj is Collection<any> {\n  return isTerm(obj)\n    && (obj as Term).termType === CollectionTermType\n}\n\n/** TypeGuard for valid RDFlib Object types, also allows Collections, Graphs */\nexport function isRDFlibObject(obj: any): obj is ObjectType {\n  return obj && Object.prototype.hasOwnProperty.call(obj, 'termType') && (\n    obj.termType === NamedNodeTermType ||\n    obj.termType === VariableTermType ||\n    obj.termType === BlankNodeTermType ||\n    obj.termType === CollectionTermType ||\n    obj.termType === LiteralTermType ||\n    obj.termType === GraphTermType\n  )\n}\n\n/** TypeGuard for valid RDFlib Subject types, same as Object as RDFLib symmetrical.\n*/\nexport function isRDFlibSubject(obj: any): obj is ObjectType {\n  return obj && Object.prototype.hasOwnProperty.call(obj, 'termType') && (\n    obj.termType === NamedNodeTermType ||\n    obj.termType === VariableTermType ||\n    obj.termType === BlankNodeTermType ||\n    obj.termType === CollectionTermType ||\n    obj.termType === LiteralTermType ||\n    obj.termType === GraphTermType\n  )\n}\n\n/** TypeGuard for valid RDF/JS spec Predicate types */\nexport function isRDFlibPredicate(obj: any): obj is Quad_Predicate {\n  return isTerm(obj) && (\n    obj.termType === NamedNodeTermType ||\n    obj.termType === BlankNodeTermType ||\n    obj.termType === VariableTermType\n  )\n}\n\n/** TypeGuard for RDFLib Variables */\nexport function isVariable(obj: any): obj is Variable {\n  return isTerm(obj)\n    && (obj as Term).termType === VariableTermType\n}\n\n/** TypeGuard for RDF/JS spec Terms */\nexport function isTerm(obj: any): obj is Term {\n  return typeof obj === 'object'\n    && obj !== null\n    && 'termType' in obj\n}\n\n/** TypeGuard for RDF/JS spec Literals */\nexport function isLiteral(value: any): value is Literal {\n  return (value as Term).termType === LiteralTermType\n}\n\n/** TypeGuard for RDF/JS spec Quads */\nexport function isQuad(obj: any): obj is Quad<any, any, any, any> {\n  return typeof obj === \"object\" && obj !== null && (\n    'subject' in obj\n    && 'predicate' in obj\n    && 'object' in obj\n  )\n}\n\n/** TypeGuard for RDF/JS spec NamedNodes */\nexport function isNamedNode(obj: any): obj is NamedNode {\n  return isTerm(obj) && obj.termType === 'NamedNode'\n}\n\n/** TypeGuard for RDF/JS spec BlankNodes */\nexport function isBlankNode(obj: any): obj is BlankNode {\n  return isTerm(obj) && 'termType' in obj && obj.termType === 'BlankNode'\n}\n\n/** TypeGuard for valid RDF/JS spec Subject types */\nexport function isSubject(obj: any): obj is Quad_Subject {\n  return isTerm(obj) && (\n    obj.termType === NamedNodeTermType ||\n    obj.termType === VariableTermType ||\n    obj.termType === BlankNodeTermType\n  )\n}\n\n/** TypeGuard for valid RDF/JS spec Predicate types */\nexport function isPredicate(obj: any): obj is Quad_Predicate {\n  return isTerm(obj) && (\n    obj.termType === NamedNodeTermType ||\n    obj.termType === VariableTermType\n  )\n}\n\n/** TypeGuard for valid RDF/JS spec Object types */\nexport function isRDFObject(obj: any): obj is Quad_Object {\n  return isTerm(obj) && (\n    obj.termType === NamedNodeTermType ||\n    obj.termType === VariableTermType ||\n    obj.termType === BlankNodeTermType ||\n    obj.termType === LiteralTermType\n  )\n}\n\n/** TypeGuard for valid RDF/JS Graph types */\nexport function isGraph(obj: any): obj is Quad_Graph {\n  return isTerm(obj) && (\n    obj.termType === NamedNodeTermType ||\n    obj.termType === VariableTermType ||\n    obj.termType === BlankNodeTermType ||\n    obj.termType === DefaultGraphTermType\n  )\n}\n","/*\n * Generated by PEG.js 0.10.0.\n *\n * http://pegjs.org/\n */\n(function(root, factory) {\n  if (typeof define === \"function\" && define.amd) {\n    define([], factory);\n  } else if (typeof module === \"object\" && module.exports) {\n    module.exports = factory();\n  } else {\n    root.ttl2jsonld = factory();\n  }\n})(this, function() {\n  \"use strict\";\n\n  function peg$subclass(child, parent) {\n    function ctor() { this.constructor = child; }\n    ctor.prototype = parent.prototype;\n    child.prototype = new ctor();\n  }\n\n  function peg$SyntaxError(message, expected, found, location) {\n    this.message  = message;\n    this.expected = expected;\n    this.found    = found;\n    this.location = location;\n    this.name     = \"SyntaxError\";\n\n    if (typeof Error.captureStackTrace === \"function\") {\n      Error.captureStackTrace(this, peg$SyntaxError);\n    }\n  }\n\n  peg$subclass(peg$SyntaxError, Error);\n\n  peg$SyntaxError.buildMessage = function(expected, found) {\n    var DESCRIBE_EXPECTATION_FNS = {\n          literal: function(expectation) {\n            return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n          },\n\n          \"class\": function(expectation) {\n            var escapedParts = \"\",\n                i;\n\n            for (i = 0; i < expectation.parts.length; i++) {\n              escapedParts += expectation.parts[i] instanceof Array\n                ? classEscape(expectation.parts[i][0]) + \"-\" + classEscape(expectation.parts[i][1])\n                : classEscape(expectation.parts[i]);\n            }\n\n            return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts + \"]\";\n          },\n\n          any: function(expectation) {\n            return \"any character\";\n          },\n\n          end: function(expectation) {\n            return \"end of input\";\n          },\n\n          other: function(expectation) {\n            return expectation.description;\n          }\n        };\n\n    function hex(ch) {\n      return ch.charCodeAt(0).toString(16).toUpperCase();\n    }\n\n    function literalEscape(s) {\n      return s\n        .replace(/\\\\/g, '\\\\\\\\')\n        .replace(/\"/g,  '\\\\\"')\n        .replace(/\\0/g, '\\\\0')\n        .replace(/\\t/g, '\\\\t')\n        .replace(/\\n/g, '\\\\n')\n        .replace(/\\r/g, '\\\\r')\n        .replace(/[\\x00-\\x0F]/g,          function(ch) { return '\\\\x0' + hex(ch); })\n        .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return '\\\\x'  + hex(ch); });\n    }\n\n    function classEscape(s) {\n      return s\n        .replace(/\\\\/g, '\\\\\\\\')\n        .replace(/\\]/g, '\\\\]')\n        .replace(/\\^/g, '\\\\^')\n        .replace(/-/g,  '\\\\-')\n        .replace(/\\0/g, '\\\\0')\n        .replace(/\\t/g, '\\\\t')\n        .replace(/\\n/g, '\\\\n')\n        .replace(/\\r/g, '\\\\r')\n        .replace(/[\\x00-\\x0F]/g,          function(ch) { return '\\\\x0' + hex(ch); })\n        .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return '\\\\x'  + hex(ch); });\n    }\n\n    function describeExpectation(expectation) {\n      return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n    }\n\n    function describeExpected(expected) {\n      var descriptions = new Array(expected.length),\n          i, j;\n\n      for (i = 0; i < expected.length; i++) {\n        descriptions[i] = describeExpectation(expected[i]);\n      }\n\n      descriptions.sort();\n\n      if (descriptions.length > 0) {\n        for (i = 1, j = 1; i < descriptions.length; i++) {\n          if (descriptions[i - 1] !== descriptions[i]) {\n            descriptions[j] = descriptions[i];\n            j++;\n          }\n        }\n        descriptions.length = j;\n      }\n\n      switch (descriptions.length) {\n        case 1:\n          return descriptions[0];\n\n        case 2:\n          return descriptions[0] + \" or \" + descriptions[1];\n\n        default:\n          return descriptions.slice(0, -1).join(\", \")\n            + \", or \"\n            + descriptions[descriptions.length - 1];\n      }\n    }\n\n    function describeFound(found) {\n      return found ? \"\\\"\" + literalEscape(found) + \"\\\"\" : \"end of input\";\n    }\n\n    return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n  };\n\n  function peg$parse(input, options) {\n    options = options !== void 0 ? options : {};\n\n    var peg$FAILED = {},\n\n        peg$startRuleFunctions = { turtleDoc: peg$parseturtleDoc },\n        peg$startRuleFunction  = peg$parseturtleDoc,\n\n        peg$c0 = function(statements) {\n          var jsonld = context.toJSON();\n          jsonld[\"@graph\"] = [];\n          statements.filter(a=>Array.isArray(a)).forEach(a=>{\n            a.forEach(b=>{\n              jsonld[\"@graph\"].push(b);\n            });\n          });\n\n          if(jsonld[\"@graph\"].length===1){\n            Object.assign(jsonld,jsonld[\"@graph\"][0]);\n            delete jsonld[\"@graph\"];\n          }\n\n          return jsonld;\n        },\n        peg$c1 = \".\",\n        peg$c2 = peg$literalExpectation(\".\", false),\n        peg$c3 = function(a) {return a;},\n        peg$c4 = \"#\",\n        peg$c5 = peg$literalExpectation(\"#\", false),\n        peg$c6 = /^[^\\n]/,\n        peg$c7 = peg$classExpectation([\"\\n\"], true, false),\n        peg$c8 = \"\\n\",\n        peg$c9 = peg$literalExpectation(\"\\n\", false),\n        peg$c10 = function(a) {return a.join(\"\");},\n        peg$c11 = \"@prefix\",\n        peg$c12 = peg$literalExpectation(\"@prefix\", false),\n        peg$c13 = function(a, b) {\n          context.addPrefix(a===\"\" ? \"0\" : a,b);\n          return {};\n        },\n        peg$c14 = \"@base\",\n        peg$c15 = peg$literalExpectation(\"@base\", false),\n        peg$c16 = function(a) {\n          context.addBase(a);\n          return {};\n        },\n        peg$c17 = /^[Bb]/,\n        peg$c18 = peg$classExpectation([\"B\", \"b\"], false, false),\n        peg$c19 = /^[Aa]/,\n        peg$c20 = peg$classExpectation([\"A\", \"a\"], false, false),\n        peg$c21 = /^[Ss]/,\n        peg$c22 = peg$classExpectation([\"S\", \"s\"], false, false),\n        peg$c23 = /^[Ee]/,\n        peg$c24 = peg$classExpectation([\"E\", \"e\"], false, false),\n        peg$c25 = /^[Pp]/,\n        peg$c26 = peg$classExpectation([\"P\", \"p\"], false, false),\n        peg$c27 = /^[Rr]/,\n        peg$c28 = peg$classExpectation([\"R\", \"r\"], false, false),\n        peg$c29 = /^[Ff]/,\n        peg$c30 = peg$classExpectation([\"F\", \"f\"], false, false),\n        peg$c31 = /^[Ii]/,\n        peg$c32 = peg$classExpectation([\"I\", \"i\"], false, false),\n        peg$c33 = /^[Xx]/,\n        peg$c34 = peg$classExpectation([\"X\", \"x\"], false, false),\n        peg$c35 = function(s, p) {\n          var x = {};\n          if(typeof s==='string' && s!=='[]') x[\"@id\"] = s;\n          else if(typeof s==='object') Object.assign(x,s);\n          if(p) Object.assign(x,p);\n          return [x];\n        },\n        peg$c36 = function(s, p) {\n          var x = {};\n          if(s) Object.assign(x,s);\n          if(p) Object.assign(x,p);\n          return [x];\n        },\n        peg$c37 = \";\",\n        peg$c38 = peg$literalExpectation(\";\", false),\n        peg$c39 = function(a, b, e, f) {var x={};x[e]=f;return x;},\n        peg$c40 = function(a, b, d) {return d;},\n        peg$c41 = function(a, b, c) {\n          var x = {};\n          c.unshift(createObject(a,b));\n          c.forEach(t=>{\n            if(!t) return;\n            Object.keys(t).forEach(key=>{\n              t[key].forEach(val=>{\n                if(key===\"@type\" && val[\"@id\"]!==undefined) val = val[\"@id\"];\n                if(x[key]===undefined) x[key] = val;\n                else if(Array.isArray(x[key])) x[key].push(val);\n                else x[key] = [x[key],val];\n              });\n            });\n          });\n          return x;\n        },\n        peg$c42 = \",\",\n        peg$c43 = peg$literalExpectation(\",\", false),\n        peg$c44 = function(a, c) {return c;},\n        peg$c45 = function(a, b) {\n          b.unshift(a);\n          return b;\n        },\n        peg$c46 = \"a\",\n        peg$c47 = peg$literalExpectation(\"a\", false),\n        peg$c48 = function() {return '@type';},\n        peg$c49 = function(a) {return expandList(a,true);},\n        peg$c50 = function(a) {return expandList(a,false);},\n        peg$c51 = function(a) {return a===\"[]\" ? {} : {\"@id\":a};},\n        peg$c52 = function(a) {return {\"@id\":a};},\n        peg$c53 = \"[\",\n        peg$c54 = peg$literalExpectation(\"[\", false),\n        peg$c55 = \"]\",\n        peg$c56 = peg$literalExpectation(\"]\", false),\n        peg$c57 = \"(\",\n        peg$c58 = peg$literalExpectation(\"(\", false),\n        peg$c59 = \")\",\n        peg$c60 = peg$literalExpectation(\")\", false),\n        peg$c61 = function(a) {return {\"@list\":a};},\n        peg$c62 = function(a, b) {return {\"@value\":a,\"@language\":b};},\n        peg$c63 = \"^^\",\n        peg$c64 = peg$literalExpectation(\"^^\", false),\n        peg$c65 = function(a, b) {\n            if(b===\"http://www.w3.org/2001/XMLSchema#boolean\" && a===\"true\") return true;\n            if(b===\"http://www.w3.org/2001/XMLSchema#boolean\" && a===\"false\") return false;\n            if(b===\"http://www.w3.org/2001/XMLSchema#integer\") return parseInt(a);\n            if(b===\"http://www.w3.org/2001/XMLSchema#double\") return parseFloat(a);\n\n            const uri = context.resolve(b,true);\n            if(uri){\n              const prefix = b.split(\":\")[0];\n              if(uri===\"http://www.w3.org/2001/XMLSchema#boolean\" && a===\"true\"){\n                context.decrement(prefix);\n                return true;\n              }\n              if(uri===\"http://www.w3.org/2001/XMLSchema#boolean\" && a===\"false\"){\n                context.decrement(prefix);\n                return false;\n              }\n              if(uri===\"http://www.w3.org/2001/XMLSchema#integer\"){\n                context.decrement(prefix);\n                return parseInt(a);\n              }\n              if(uri===\"http://www.w3.org/2001/XMLSchema#double\"){\n                context.decrement(prefix);\n                return parseFloat(a);\n              }\n            }\n            return {\"@value\":a,\"@type\":b};\n          },\n        peg$c66 = \"true\",\n        peg$c67 = peg$literalExpectation(\"true\", false),\n        peg$c68 = function() {return true;},\n        peg$c69 = \"false\",\n        peg$c70 = peg$literalExpectation(\"false\", false),\n        peg$c71 = function() {return false;},\n        peg$c72 = function(a) {return a+\":\";},\n        peg$c73 = \"<\",\n        peg$c74 = peg$literalExpectation(\"<\", false),\n        peg$c75 = /^[^\\0- <>\"{}|\\^`\\\\]/,\n        peg$c76 = peg$classExpectation([[\"\\0\", \" \"], \"<\", \">\", \"\\\"\", \"{\", \"}\", \"|\", \"^\", \"`\", \"\\\\\"], true, false),\n        peg$c77 = \">\",\n        peg$c78 = peg$literalExpectation(\">\", false),\n        peg$c79 = function(a) {\n          const decoded = a.map(s=> {\n            if(0x10000 <= s.codePointAt(0) && s.codePointAt(0) <= 0xeffff) return 'a';\n            if(s.length===1) return s;\n            if(s.length===6) return String.fromCharCode(\"0x\"+s.substring(2));\n            if(s.length===10) return String.fromCodePoint(\"0x\"+s.substring(2));\n            return s;\n          }).join(\"\");\n          if(decoded.match(/^[^\\u0000-\\u0020<>\"{}|^`\\\\]*$/)){\n            var join = a.join(\"\");\n            try{\n              return context.resolve(join);\n            }catch(e){\n              error(\"Invalid IRIREF \"+join);\n            }\n          }\n          else error(\"Invalid IRIREF \"+a.join(\"\")+\" / \"+decoded);\n        },\n        peg$c80 = \":\",\n        peg$c81 = peg$literalExpectation(\":\", false),\n        peg$c82 = function(a) {\n          a = a || \"0\";\n          if(context.hasPrefix(a)===false)\n            error(\"undefined prefix \"+a);\n          return a;\n        },\n        peg$c83 = function(a) {return (a||\"\");},\n        peg$c84 = function(a, b) {\n          context.increment(a);\n          return context.resolve(a+\":\"+b);\n        },\n        peg$c85 = \"_:\",\n        peg$c86 = peg$literalExpectation(\"_:\", false),\n        peg$c87 = /^[0-9]/,\n        peg$c88 = peg$classExpectation([[\"0\", \"9\"]], false, false),\n        peg$c89 = \"@\",\n        peg$c90 = peg$literalExpectation(\"@\", false),\n        peg$c91 = /^[a-zA-Z]/,\n        peg$c92 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"]], false, false),\n        peg$c93 = \"-\",\n        peg$c94 = peg$literalExpectation(\"-\", false),\n        peg$c95 = /^[a-zA-Z0-9]/,\n        peg$c96 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"], [\"0\", \"9\"]], false, false),\n        peg$c97 = function(a, s) {return '-'+s.join(\"\");},\n        peg$c98 = function(a, b) {return a.join(\"\")+b.join(\"\");},\n        peg$c99 = /^[+\\-]/,\n        peg$c100 = peg$classExpectation([\"+\", \"-\"], false, false),\n        peg$c101 = function(a) {\n          if(a.match(/^[0+][0-9]+$/))\n            return {\n              \"@value\" : a,\n              \"@type\" : \"http://www.w3.org/2001/XMLSchema#integer\"\n            };\n          return parseInt(a);\n        },\n        peg$c102 = function(a) {\n          return {\n            \"@value\" : a,\n            \"@type\" : \"http://www.w3.org/2001/XMLSchema#decimal\"\n          }\n        },\n        peg$c103 = function(a) {\n          return {\n            \"@value\" : a,\n            \"@type\" : \"http://www.w3.org/2001/XMLSchema#double\"\n          };\n        },\n        peg$c104 = /^[eE]/,\n        peg$c105 = peg$classExpectation([\"e\", \"E\"], false, false),\n        peg$c106 = \"\\\"\",\n        peg$c107 = peg$literalExpectation(\"\\\"\", false),\n        peg$c108 = /^[^\"\\\\\\n\\r]/,\n        peg$c109 = peg$classExpectation([\"\\\"\", \"\\\\\", \"\\n\", \"\\r\"], true, false),\n        peg$c110 = \"'\",\n        peg$c111 = peg$literalExpectation(\"'\", false),\n        peg$c112 = /^[^'\\\\\\n\\r]/,\n        peg$c113 = peg$classExpectation([\"'\", \"\\\\\", \"\\n\", \"\\r\"], true, false),\n        peg$c114 = \"'''\",\n        peg$c115 = peg$literalExpectation(\"'''\", false),\n        peg$c116 = /^[^'\\\\]/,\n        peg$c117 = peg$classExpectation([\"'\", \"\\\\\"], true, false),\n        peg$c118 = \"''\",\n        peg$c119 = peg$literalExpectation(\"''\", false),\n        peg$c120 = function(head, a) {return \"''\"+a.join(\"\");},\n        peg$c121 = function(head, a) {return \"'\" +a.join(\"\");},\n        peg$c122 = function(head, body) {return head.join(\"\")+body.join(\"\");},\n        peg$c123 = \"\\\"\\\"\\\"\",\n        peg$c124 = peg$literalExpectation(\"\\\"\\\"\\\"\", false),\n        peg$c125 = /^[^\"\\\\]/,\n        peg$c126 = peg$classExpectation([\"\\\"\", \"\\\\\"], true, false),\n        peg$c127 = \"\\\"\\\"\",\n        peg$c128 = peg$literalExpectation(\"\\\"\\\"\", false),\n        peg$c129 = function(head, a) {return '\"\"'+a.join(\"\");},\n        peg$c130 = function(head, a) {return '\"' +a.join(\"\");},\n        peg$c131 = \"\\\\U\",\n        peg$c132 = peg$literalExpectation(\"\\\\U\", false),\n        peg$c133 = function(hex) {\n            return String.fromCodePoint(parseInt(hex.join(\"\"),16));\n          },\n        peg$c134 = \"\\\\u\",\n        peg$c135 = peg$literalExpectation(\"\\\\u\", false),\n        peg$c136 = function(hex) {\n            return String.fromCharCode(parseInt(hex.join(\"\"),16));\n          },\n        peg$c137 = \"\\\\t\",\n        peg$c138 = peg$literalExpectation(\"\\\\t\", false),\n        peg$c139 = function() {return '\\t';},\n        peg$c140 = \"\\\\b\",\n        peg$c141 = peg$literalExpectation(\"\\\\b\", false),\n        peg$c142 = function() {return '\\b';},\n        peg$c143 = \"\\\\n\",\n        peg$c144 = peg$literalExpectation(\"\\\\n\", false),\n        peg$c145 = function() {return '\\n';},\n        peg$c146 = \"\\\\r\",\n        peg$c147 = peg$literalExpectation(\"\\\\r\", false),\n        peg$c148 = function() {return '\\r';},\n        peg$c149 = \"\\\\f\",\n        peg$c150 = peg$literalExpectation(\"\\\\f\", false),\n        peg$c151 = function() {return '\\f';},\n        peg$c152 = \"\\\\\\\"\",\n        peg$c153 = peg$literalExpectation(\"\\\\\\\"\", false),\n        peg$c154 = function() {return '\"';},\n        peg$c155 = \"\\\\'\",\n        peg$c156 = peg$literalExpectation(\"\\\\'\", false),\n        peg$c157 = function() {return \"'\";},\n        peg$c158 = \"\\\\\\\\\",\n        peg$c159 = peg$literalExpectation(\"\\\\\\\\\", false),\n        peg$c160 = function() {return '\\\\';},\n        peg$c161 = /^[ \\t\\r\\n]/,\n        peg$c162 = peg$classExpectation([\" \", \"\\t\", \"\\r\", \"\\n\"], false, false),\n        peg$c163 = function() {return \"[]\";},\n        peg$c164 = /^[\\uD800-\\uDBFF]/,\n        peg$c165 = peg$classExpectation([[\"\\uD800\", \"\\uDBFF\"]], false, false),\n        peg$c166 = /^[\\uDC00-\\uDFFF]/,\n        peg$c167 = peg$classExpectation([[\"\\uDC00\", \"\\uDFFF\"]], false, false),\n        peg$c168 = function(a, b) {return a+b;},\n        peg$c169 = /^[A-Za-z\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD]/,\n        peg$c170 = peg$classExpectation([[\"A\", \"Z\"], [\"a\", \"z\"], [\"\\xC0\", \"\\xD6\"], [\"\\xD8\", \"\\xF6\"], [\"\\xF8\", \"\\u02FF\"], [\"\\u0370\", \"\\u037D\"], [\"\\u037F\", \"\\u1FFF\"], [\"\\u200C\", \"\\u200D\"], [\"\\u2070\", \"\\u218F\"], [\"\\u2C00\", \"\\u2FEF\"], [\"\\u3001\", \"\\uD7FF\"], [\"\\uF900\", \"\\uFDCF\"], [\"\\uFDF0\", \"\\uFFFD\"]], false, false),\n        peg$c171 = \"_\",\n        peg$c172 = peg$literalExpectation(\"_\", false),\n        peg$c173 = \"\\xB7\",\n        peg$c174 = peg$literalExpectation(\"\\xB7\", false),\n        peg$c175 = /^[\\u0300-\\u036F]/,\n        peg$c176 = peg$classExpectation([[\"\\u0300\", \"\\u036F\"]], false, false),\n        peg$c177 = /^[\\u203F-\\u2040]/,\n        peg$c178 = peg$classExpectation([[\"\\u203F\", \"\\u2040\"]], false, false),\n        peg$c179 = function(head, body, a, b) {return a.join(\"\")+b.join(\"\");},\n        peg$c180 = function(head, body, tail) {return head+body.join(\"\")+tail.join(\"\");},\n        peg$c181 = \"%\",\n        peg$c182 = peg$literalExpectation(\"%\", false),\n        peg$c183 = /^[0-9A-Fa-f]/,\n        peg$c184 = peg$classExpectation([[\"0\", \"9\"], [\"A\", \"F\"], [\"a\", \"f\"]], false, false),\n        peg$c185 = \"\\\\\",\n        peg$c186 = peg$literalExpectation(\"\\\\\", false),\n        peg$c187 = /^[_~.!$&'()*+,;=\\/?#@%\\-]/,\n        peg$c188 = peg$classExpectation([\"_\", \"~\", \".\", \"!\", \"$\", \"&\", \"'\", \"(\", \")\", \"*\", \"+\", \",\", \";\", \"=\", \"/\", \"?\", \"#\", \"@\", \"%\", \"-\"], false, false),\n\n        peg$currPos          = 0,\n        peg$savedPos         = 0,\n        peg$posDetailsCache  = [{ line: 1, column: 1 }],\n        peg$maxFailPos       = 0,\n        peg$maxFailExpected  = [],\n        peg$silentFails      = 0,\n\n        peg$result;\n\n    if (\"startRule\" in options) {\n      if (!(options.startRule in peg$startRuleFunctions)) {\n        throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n      }\n\n      peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n    }\n\n    function text() {\n      return input.substring(peg$savedPos, peg$currPos);\n    }\n\n    function location() {\n      return peg$computeLocation(peg$savedPos, peg$currPos);\n    }\n\n    function expected(description, location) {\n      location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos)\n\n      throw peg$buildStructuredError(\n        [peg$otherExpectation(description)],\n        input.substring(peg$savedPos, peg$currPos),\n        location\n      );\n    }\n\n    function error(message, location) {\n      location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos)\n\n      throw peg$buildSimpleError(message, location);\n    }\n\n    function peg$literalExpectation(text, ignoreCase) {\n      return { type: \"literal\", text: text, ignoreCase: ignoreCase };\n    }\n\n    function peg$classExpectation(parts, inverted, ignoreCase) {\n      return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n    }\n\n    function peg$anyExpectation() {\n      return { type: \"any\" };\n    }\n\n    function peg$endExpectation() {\n      return { type: \"end\" };\n    }\n\n    function peg$otherExpectation(description) {\n      return { type: \"other\", description: description };\n    }\n\n    function peg$computePosDetails(pos) {\n      var details = peg$posDetailsCache[pos], p;\n\n      if (details) {\n        return details;\n      } else {\n        p = pos - 1;\n        while (!peg$posDetailsCache[p]) {\n          p--;\n        }\n\n        details = peg$posDetailsCache[p];\n        details = {\n          line:   details.line,\n          column: details.column\n        };\n\n        while (p < pos) {\n          if (input.charCodeAt(p) === 10) {\n            details.line++;\n            details.column = 1;\n          } else {\n            details.column++;\n          }\n\n          p++;\n        }\n\n        peg$posDetailsCache[pos] = details;\n        return details;\n      }\n    }\n\n    function peg$computeLocation(startPos, endPos) {\n      var startPosDetails = peg$computePosDetails(startPos),\n          endPosDetails   = peg$computePosDetails(endPos);\n\n      return {\n        start: {\n          offset: startPos,\n          line:   startPosDetails.line,\n          column: startPosDetails.column\n        },\n        end: {\n          offset: endPos,\n          line:   endPosDetails.line,\n          column: endPosDetails.column\n        }\n      };\n    }\n\n    function peg$fail(expected) {\n      if (peg$currPos < peg$maxFailPos) { return; }\n\n      if (peg$currPos > peg$maxFailPos) {\n        peg$maxFailPos = peg$currPos;\n        peg$maxFailExpected = [];\n      }\n\n      peg$maxFailExpected.push(expected);\n    }\n\n    function peg$buildSimpleError(message, location) {\n      return new peg$SyntaxError(message, null, null, location);\n    }\n\n    function peg$buildStructuredError(expected, found, location) {\n      return new peg$SyntaxError(\n        peg$SyntaxError.buildMessage(expected, found),\n        expected,\n        found,\n        location\n      );\n    }\n\n    function peg$parseturtleDoc() {\n      var s0, s1, s2, s3;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parsestatement();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parsestatement();\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$parseIGNORE();\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$parseIGNORE();\n        }\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c0(s1);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parsestatement() {\n      var s0, s1, s2, s3;\n\n      s0 = peg$parsedirective();\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = peg$parsetriples();\n        if (s1 !== peg$FAILED) {\n          s2 = [];\n          s3 = peg$parseIGNORE();\n          while (s3 !== peg$FAILED) {\n            s2.push(s3);\n            s3 = peg$parseIGNORE();\n          }\n          if (s2 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 46) {\n              s3 = peg$c1;\n              peg$currPos++;\n            } else {\n              s3 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c2); }\n            }\n            if (s3 !== peg$FAILED) {\n              peg$savedPos = s0;\n              s1 = peg$c3(s1);\n              s0 = s1;\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseCOMMENT() {\n      var s0, s1, s2, s3;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 35) {\n        s1 = peg$c4;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c5); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        if (peg$c6.test(input.charAt(peg$currPos))) {\n          s3 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c7); }\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          if (peg$c6.test(input.charAt(peg$currPos))) {\n            s3 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c7); }\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 10) {\n            s3 = peg$c8;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c9); }\n          }\n          if (s3 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c10(s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parseIGNORE() {\n      var s0;\n\n      s0 = peg$parseWS();\n      if (s0 === peg$FAILED) {\n        s0 = peg$parseCOMMENT();\n      }\n\n      return s0;\n    }\n\n    function peg$parsedirective() {\n      var s0;\n\n      s0 = peg$parseprefixID();\n      if (s0 === peg$FAILED) {\n        s0 = peg$parsebase();\n        if (s0 === peg$FAILED) {\n          s0 = peg$parsesparqlPrefix();\n          if (s0 === peg$FAILED) {\n            s0 = peg$parsesparqlBase();\n          }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseprefixID() {\n      var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseIGNORE();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseIGNORE();\n      }\n      if (s1 !== peg$FAILED) {\n        if (input.substr(peg$currPos, 7) === peg$c11) {\n          s2 = peg$c11;\n          peg$currPos += 7;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c12); }\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = [];\n          s4 = peg$parseIGNORE();\n          while (s4 !== peg$FAILED) {\n            s3.push(s4);\n            s4 = peg$parseIGNORE();\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parsePNAME_NS_NO_CHECK();\n            if (s4 !== peg$FAILED) {\n              s5 = [];\n              s6 = peg$parseIGNORE();\n              while (s6 !== peg$FAILED) {\n                s5.push(s6);\n                s6 = peg$parseIGNORE();\n              }\n              if (s5 !== peg$FAILED) {\n                s6 = peg$parseIRIREF();\n                if (s6 !== peg$FAILED) {\n                  s7 = [];\n                  s8 = peg$parseIGNORE();\n                  while (s8 !== peg$FAILED) {\n                    s7.push(s8);\n                    s8 = peg$parseIGNORE();\n                  }\n                  if (s7 !== peg$FAILED) {\n                    if (input.charCodeAt(peg$currPos) === 46) {\n                      s8 = peg$c1;\n                      peg$currPos++;\n                    } else {\n                      s8 = peg$FAILED;\n                      if (peg$silentFails === 0) { peg$fail(peg$c2); }\n                    }\n                    if (s8 !== peg$FAILED) {\n                      peg$savedPos = s0;\n                      s1 = peg$c13(s4, s6);\n                      s0 = s1;\n                    } else {\n                      peg$currPos = s0;\n                      s0 = peg$FAILED;\n                    }\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parsebase() {\n      var s0, s1, s2, s3, s4, s5, s6;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseIGNORE();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseIGNORE();\n      }\n      if (s1 !== peg$FAILED) {\n        if (input.substr(peg$currPos, 5) === peg$c14) {\n          s2 = peg$c14;\n          peg$currPos += 5;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c15); }\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = [];\n          s4 = peg$parseIGNORE();\n          while (s4 !== peg$FAILED) {\n            s3.push(s4);\n            s4 = peg$parseIGNORE();\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parseIRIREF();\n            if (s4 !== peg$FAILED) {\n              s5 = [];\n              s6 = peg$parseIGNORE();\n              while (s6 !== peg$FAILED) {\n                s5.push(s6);\n                s6 = peg$parseIGNORE();\n              }\n              if (s5 !== peg$FAILED) {\n                if (input.charCodeAt(peg$currPos) === 46) {\n                  s6 = peg$c1;\n                  peg$currPos++;\n                } else {\n                  s6 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c2); }\n                }\n                if (s6 !== peg$FAILED) {\n                  peg$savedPos = s0;\n                  s1 = peg$c16(s4);\n                  s0 = s1;\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parsesparqlBase() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseIGNORE();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseIGNORE();\n      }\n      if (s1 !== peg$FAILED) {\n        if (peg$c17.test(input.charAt(peg$currPos))) {\n          s2 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c18); }\n        }\n        if (s2 !== peg$FAILED) {\n          if (peg$c19.test(input.charAt(peg$currPos))) {\n            s3 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c20); }\n          }\n          if (s3 !== peg$FAILED) {\n            if (peg$c21.test(input.charAt(peg$currPos))) {\n              s4 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s4 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c22); }\n            }\n            if (s4 !== peg$FAILED) {\n              if (peg$c23.test(input.charAt(peg$currPos))) {\n                s5 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c24); }\n              }\n              if (s5 !== peg$FAILED) {\n                s6 = [];\n                s7 = peg$parseIGNORE();\n                while (s7 !== peg$FAILED) {\n                  s6.push(s7);\n                  s7 = peg$parseIGNORE();\n                }\n                if (s6 !== peg$FAILED) {\n                  s7 = peg$parseIRIREF();\n                  if (s7 !== peg$FAILED) {\n                    peg$savedPos = s0;\n                    s1 = peg$c16(s7);\n                    s0 = s1;\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parsesparqlPrefix() {\n      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseIGNORE();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseIGNORE();\n      }\n      if (s1 !== peg$FAILED) {\n        if (peg$c25.test(input.charAt(peg$currPos))) {\n          s2 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c26); }\n        }\n        if (s2 !== peg$FAILED) {\n          if (peg$c27.test(input.charAt(peg$currPos))) {\n            s3 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c28); }\n          }\n          if (s3 !== peg$FAILED) {\n            if (peg$c23.test(input.charAt(peg$currPos))) {\n              s4 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s4 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c24); }\n            }\n            if (s4 !== peg$FAILED) {\n              if (peg$c29.test(input.charAt(peg$currPos))) {\n                s5 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c30); }\n              }\n              if (s5 !== peg$FAILED) {\n                if (peg$c31.test(input.charAt(peg$currPos))) {\n                  s6 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s6 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c32); }\n                }\n                if (s6 !== peg$FAILED) {\n                  if (peg$c33.test(input.charAt(peg$currPos))) {\n                    s7 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                  } else {\n                    s7 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c34); }\n                  }\n                  if (s7 !== peg$FAILED) {\n                    s8 = [];\n                    s9 = peg$parseIGNORE();\n                    while (s9 !== peg$FAILED) {\n                      s8.push(s9);\n                      s9 = peg$parseIGNORE();\n                    }\n                    if (s8 !== peg$FAILED) {\n                      s9 = peg$parsePNAME_NS_NO_CHECK();\n                      if (s9 !== peg$FAILED) {\n                        s10 = [];\n                        s11 = peg$parseIGNORE();\n                        while (s11 !== peg$FAILED) {\n                          s10.push(s11);\n                          s11 = peg$parseIGNORE();\n                        }\n                        if (s10 !== peg$FAILED) {\n                          s11 = peg$parseIRIREF();\n                          if (s11 !== peg$FAILED) {\n                            peg$savedPos = s0;\n                            s1 = peg$c13(s9, s11);\n                            s0 = s1;\n                          } else {\n                            peg$currPos = s0;\n                            s0 = peg$FAILED;\n                          }\n                        } else {\n                          peg$currPos = s0;\n                          s0 = peg$FAILED;\n                        }\n                      } else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                      }\n                    } else {\n                      peg$currPos = s0;\n                      s0 = peg$FAILED;\n                    }\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parsetriples() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = peg$parsesubject();\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parsepredicateObjectList();\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c35(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = peg$parseblankNodePropertyList();\n        if (s1 !== peg$FAILED) {\n          s2 = peg$parsepredicateObjectList();\n          if (s2 === peg$FAILED) {\n            s2 = null;\n          }\n          if (s2 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c36(s1, s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parsepredicateObjectList() {\n      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n\n      s0 = peg$currPos;\n      s1 = peg$parseverb();\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseobjectList();\n        if (s2 !== peg$FAILED) {\n          s3 = [];\n          s4 = peg$currPos;\n          s5 = [];\n          s6 = peg$parseIGNORE();\n          while (s6 !== peg$FAILED) {\n            s5.push(s6);\n            s6 = peg$parseIGNORE();\n          }\n          if (s5 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 59) {\n              s6 = peg$c37;\n              peg$currPos++;\n            } else {\n              s6 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c38); }\n            }\n            if (s6 !== peg$FAILED) {\n              s7 = peg$currPos;\n              s8 = peg$parseverb();\n              if (s8 !== peg$FAILED) {\n                s9 = peg$parseobjectList();\n                if (s9 !== peg$FAILED) {\n                  peg$savedPos = s7;\n                  s8 = peg$c39(s1, s2, s8, s9);\n                  s7 = s8;\n                } else {\n                  peg$currPos = s7;\n                  s7 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s7;\n                s7 = peg$FAILED;\n              }\n              if (s7 === peg$FAILED) {\n                s7 = null;\n              }\n              if (s7 !== peg$FAILED) {\n                peg$savedPos = s4;\n                s5 = peg$c40(s1, s2, s7);\n                s4 = s5;\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s4;\n            s4 = peg$FAILED;\n          }\n          while (s4 !== peg$FAILED) {\n            s3.push(s4);\n            s4 = peg$currPos;\n            s5 = [];\n            s6 = peg$parseIGNORE();\n            while (s6 !== peg$FAILED) {\n              s5.push(s6);\n              s6 = peg$parseIGNORE();\n            }\n            if (s5 !== peg$FAILED) {\n              if (input.charCodeAt(peg$currPos) === 59) {\n                s6 = peg$c37;\n                peg$currPos++;\n              } else {\n                s6 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c38); }\n              }\n              if (s6 !== peg$FAILED) {\n                s7 = peg$currPos;\n                s8 = peg$parseverb();\n                if (s8 !== peg$FAILED) {\n                  s9 = peg$parseobjectList();\n                  if (s9 !== peg$FAILED) {\n                    peg$savedPos = s7;\n                    s8 = peg$c39(s1, s2, s8, s9);\n                    s7 = s8;\n                  } else {\n                    peg$currPos = s7;\n                    s7 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s7;\n                  s7 = peg$FAILED;\n                }\n                if (s7 === peg$FAILED) {\n                  s7 = null;\n                }\n                if (s7 !== peg$FAILED) {\n                  peg$savedPos = s4;\n                  s5 = peg$c40(s1, s2, s7);\n                  s4 = s5;\n                } else {\n                  peg$currPos = s4;\n                  s4 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          }\n          if (s3 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c41(s1, s2, s3);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parseobjectList() {\n      var s0, s1, s2, s3, s4, s5, s6;\n\n      s0 = peg$currPos;\n      s1 = peg$parseobject();\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = [];\n        s5 = peg$parseIGNORE();\n        while (s5 !== peg$FAILED) {\n          s4.push(s5);\n          s5 = peg$parseIGNORE();\n        }\n        if (s4 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 44) {\n            s5 = peg$c42;\n            peg$currPos++;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c43); }\n          }\n          if (s5 !== peg$FAILED) {\n            s6 = peg$parseobject();\n            if (s6 !== peg$FAILED) {\n              peg$savedPos = s3;\n              s4 = peg$c44(s1, s6);\n              s3 = s4;\n            } else {\n              peg$currPos = s3;\n              s3 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$FAILED;\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = [];\n          s5 = peg$parseIGNORE();\n          while (s5 !== peg$FAILED) {\n            s4.push(s5);\n            s5 = peg$parseIGNORE();\n          }\n          if (s4 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 44) {\n              s5 = peg$c42;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c43); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parseobject();\n              if (s6 !== peg$FAILED) {\n                peg$savedPos = s3;\n                s4 = peg$c44(s1, s6);\n                s3 = s4;\n              } else {\n                peg$currPos = s3;\n                s3 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$FAILED;\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c45(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parseverb() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = peg$parsepredicate();\n      if (s1 !== peg$FAILED) {\n        peg$savedPos = s0;\n        s1 = peg$c3(s1);\n      }\n      s0 = s1;\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = [];\n        s2 = peg$parseIGNORE();\n        while (s2 !== peg$FAILED) {\n          s1.push(s2);\n          s2 = peg$parseIGNORE();\n        }\n        if (s1 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 97) {\n            s2 = peg$c46;\n            peg$currPos++;\n          } else {\n            s2 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c47); }\n          }\n          if (s2 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c48();\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parsesubject() {\n      var s0, s1;\n\n      s0 = peg$currPos;\n      s1 = peg$parsecollection();\n      if (s1 !== peg$FAILED) {\n        peg$savedPos = s0;\n        s1 = peg$c49(s1);\n      }\n      s0 = s1;\n      if (s0 === peg$FAILED) {\n        s0 = peg$parseBlankNode();\n        if (s0 === peg$FAILED) {\n          s0 = peg$parseiri();\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parsepredicate() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseIGNORE();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseIGNORE();\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseiri();\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c3(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parseobject() {\n      var s0, s1;\n\n      s0 = peg$parseliteral();\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = peg$parsecollection();\n        if (s1 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c50(s1);\n        }\n        s0 = s1;\n        if (s0 === peg$FAILED) {\n          s0 = peg$currPos;\n          s1 = peg$parseBlankNode();\n          if (s1 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c51(s1);\n          }\n          s0 = s1;\n          if (s0 === peg$FAILED) {\n            s0 = peg$currPos;\n            s1 = peg$parseblankNodePropertyList();\n            if (s1 !== peg$FAILED) {\n              peg$savedPos = s0;\n              s1 = peg$c3(s1);\n            }\n            s0 = s1;\n            if (s0 === peg$FAILED) {\n              s0 = peg$currPos;\n              s1 = peg$parseiri();\n              if (s1 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c52(s1);\n              }\n              s0 = s1;\n            }\n          }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseliteral() {\n      var s0;\n\n      s0 = peg$parseRDFLiteral();\n      if (s0 === peg$FAILED) {\n        s0 = peg$parseNumericLiteral();\n        if (s0 === peg$FAILED) {\n          s0 = peg$parseBooleanLiteral();\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseblankNodePropertyList() {\n      var s0, s1, s2, s3, s4, s5;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseIGNORE();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseIGNORE();\n      }\n      if (s1 !== peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 91) {\n          s2 = peg$c53;\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c54); }\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parsepredicateObjectList();\n          if (s3 !== peg$FAILED) {\n            s4 = [];\n            s5 = peg$parseIGNORE();\n            while (s5 !== peg$FAILED) {\n              s4.push(s5);\n              s5 = peg$parseIGNORE();\n            }\n            if (s4 !== peg$FAILED) {\n              if (input.charCodeAt(peg$currPos) === 93) {\n                s5 = peg$c55;\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c56); }\n              }\n              if (s5 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c3(s3);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parsecollection() {\n      var s0, s1, s2, s3, s4, s5;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseIGNORE();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseIGNORE();\n      }\n      if (s1 !== peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 40) {\n          s2 = peg$c57;\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c58); }\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = [];\n          s4 = peg$parseobject();\n          while (s4 !== peg$FAILED) {\n            s3.push(s4);\n            s4 = peg$parseobject();\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = [];\n            s5 = peg$parseIGNORE();\n            while (s5 !== peg$FAILED) {\n              s4.push(s5);\n              s5 = peg$parseIGNORE();\n            }\n            if (s4 !== peg$FAILED) {\n              if (input.charCodeAt(peg$currPos) === 41) {\n                s5 = peg$c59;\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c60); }\n              }\n              if (s5 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c61(s3);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parseNumericLiteral() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseIGNORE();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseIGNORE();\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseDOUBLE();\n        if (s2 === peg$FAILED) {\n          s2 = peg$parseDECIMAL();\n          if (s2 === peg$FAILED) {\n            s2 = peg$parseINTEGER();\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c3(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parseRDFLiteral() {\n      var s0, s1, s2, s3, s4, s5, s6;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseIGNORE();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseIGNORE();\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseString();\n        if (s2 !== peg$FAILED) {\n          s3 = [];\n          s4 = peg$parseIGNORE();\n          while (s4 !== peg$FAILED) {\n            s3.push(s4);\n            s4 = peg$parseIGNORE();\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parseLANGTAG();\n            if (s4 !== peg$FAILED) {\n              peg$savedPos = s0;\n              s1 = peg$c62(s2, s4);\n              s0 = s1;\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = [];\n        s2 = peg$parseIGNORE();\n        while (s2 !== peg$FAILED) {\n          s1.push(s2);\n          s2 = peg$parseIGNORE();\n        }\n        if (s1 !== peg$FAILED) {\n          s2 = peg$parseString();\n          if (s2 !== peg$FAILED) {\n            s3 = [];\n            s4 = peg$parseIGNORE();\n            while (s4 !== peg$FAILED) {\n              s3.push(s4);\n              s4 = peg$parseIGNORE();\n            }\n            if (s3 !== peg$FAILED) {\n              if (input.substr(peg$currPos, 2) === peg$c63) {\n                s4 = peg$c63;\n                peg$currPos += 2;\n              } else {\n                s4 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c64); }\n              }\n              if (s4 !== peg$FAILED) {\n                s5 = [];\n                s6 = peg$parseIGNORE();\n                while (s6 !== peg$FAILED) {\n                  s5.push(s6);\n                  s6 = peg$parseIGNORE();\n                }\n                if (s5 !== peg$FAILED) {\n                  s6 = peg$parseiri();\n                  if (s6 !== peg$FAILED) {\n                    peg$savedPos = s0;\n                    s1 = peg$c65(s2, s6);\n                    s0 = s1;\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n        if (s0 === peg$FAILED) {\n          s0 = peg$currPos;\n          s1 = [];\n          s2 = peg$parseIGNORE();\n          while (s2 !== peg$FAILED) {\n            s1.push(s2);\n            s2 = peg$parseIGNORE();\n          }\n          if (s1 !== peg$FAILED) {\n            s2 = peg$parseString();\n            if (s2 !== peg$FAILED) {\n              peg$savedPos = s0;\n              s1 = peg$c3(s2);\n              s0 = s1;\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseBooleanLiteral() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseIGNORE();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseIGNORE();\n      }\n      if (s1 !== peg$FAILED) {\n        if (input.substr(peg$currPos, 4) === peg$c66) {\n          s2 = peg$c66;\n          peg$currPos += 4;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c67); }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c68();\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = [];\n        s2 = peg$parseIGNORE();\n        while (s2 !== peg$FAILED) {\n          s1.push(s2);\n          s2 = peg$parseIGNORE();\n        }\n        if (s1 !== peg$FAILED) {\n          if (input.substr(peg$currPos, 5) === peg$c69) {\n            s2 = peg$c69;\n            peg$currPos += 5;\n          } else {\n            s2 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c70); }\n          }\n          if (s2 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c71();\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseString() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseIGNORE();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseIGNORE();\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseSTRING_LITERAL_LONG_SINGLE_QUOTE();\n        if (s2 === peg$FAILED) {\n          s2 = peg$parseSTRING_LITERAL_LONG_QUOTE();\n          if (s2 === peg$FAILED) {\n            s2 = peg$parseSTRING_LITERAL_SINGLE_QUOTE();\n            if (s2 === peg$FAILED) {\n              s2 = peg$parseSTRING_LITERAL_QUOTE();\n            }\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c3(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parseiri() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseIGNORE();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseIGNORE();\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseIRIREF();\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c3(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = [];\n        s2 = peg$parseIGNORE();\n        while (s2 !== peg$FAILED) {\n          s1.push(s2);\n          s2 = peg$parseIGNORE();\n        }\n        if (s1 !== peg$FAILED) {\n          s2 = peg$parsePrefixedName();\n          if (s2 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c3(s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parsePrefixedName() {\n      var s0, s1;\n\n      s0 = peg$parsePNAME_LN();\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = peg$parsePNAME_NS();\n        if (s1 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c72(s1);\n        }\n        s0 = s1;\n      }\n\n      return s0;\n    }\n\n    function peg$parseBlankNode() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseIGNORE();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseIGNORE();\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseBLANK_NODE_LABEL();\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c3(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = [];\n        s2 = peg$parseIGNORE();\n        while (s2 !== peg$FAILED) {\n          s1.push(s2);\n          s2 = peg$parseIGNORE();\n        }\n        if (s1 !== peg$FAILED) {\n          s2 = peg$parseANON();\n          if (s2 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c3(s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseIRIREF() {\n      var s0, s1, s2, s3;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 60) {\n        s1 = peg$c73;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c74); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        if (peg$c75.test(input.charAt(peg$currPos))) {\n          s3 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c76); }\n        }\n        if (s3 === peg$FAILED) {\n          s3 = peg$parseUCHAR();\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          if (peg$c75.test(input.charAt(peg$currPos))) {\n            s3 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c76); }\n          }\n          if (s3 === peg$FAILED) {\n            s3 = peg$parseUCHAR();\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 62) {\n            s3 = peg$c77;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c78); }\n          }\n          if (s3 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c79(s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parsePNAME_NS() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = peg$parsePN_PREFIX();\n      if (s1 === peg$FAILED) {\n        s1 = null;\n      }\n      if (s1 !== peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 58) {\n          s2 = peg$c80;\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c81); }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c82(s1);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parsePNAME_NS_NO_CHECK() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = peg$parsePN_PREFIX();\n      if (s1 === peg$FAILED) {\n        s1 = null;\n      }\n      if (s1 !== peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 58) {\n          s2 = peg$c80;\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c81); }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c83(s1);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parsePNAME_LN() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = peg$parsePNAME_NS();\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parsePN_LOCAL();\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c84(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parseBLANK_NODE_LABEL() {\n      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n\n      s0 = peg$currPos;\n      s1 = peg$currPos;\n      if (input.substr(peg$currPos, 2) === peg$c85) {\n        s2 = peg$c85;\n        peg$currPos += 2;\n      } else {\n        s2 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c86); }\n      }\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parsePN_CHARS_U();\n        if (s3 === peg$FAILED) {\n          if (peg$c87.test(input.charAt(peg$currPos))) {\n            s3 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c88); }\n          }\n        }\n        if (s3 !== peg$FAILED) {\n          s4 = [];\n          s5 = peg$parsePN_CHARS();\n          while (s5 !== peg$FAILED) {\n            s4.push(s5);\n            s5 = peg$parsePN_CHARS();\n          }\n          if (s4 !== peg$FAILED) {\n            s5 = [];\n            s6 = peg$currPos;\n            s7 = [];\n            if (input.charCodeAt(peg$currPos) === 46) {\n              s8 = peg$c1;\n              peg$currPos++;\n            } else {\n              s8 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c2); }\n            }\n            if (s8 !== peg$FAILED) {\n              while (s8 !== peg$FAILED) {\n                s7.push(s8);\n                if (input.charCodeAt(peg$currPos) === 46) {\n                  s8 = peg$c1;\n                  peg$currPos++;\n                } else {\n                  s8 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c2); }\n                }\n              }\n            } else {\n              s7 = peg$FAILED;\n            }\n            if (s7 !== peg$FAILED) {\n              s8 = [];\n              s9 = peg$parsePN_CHARS();\n              if (s9 !== peg$FAILED) {\n                while (s9 !== peg$FAILED) {\n                  s8.push(s9);\n                  s9 = peg$parsePN_CHARS();\n                }\n              } else {\n                s8 = peg$FAILED;\n              }\n              if (s8 !== peg$FAILED) {\n                s7 = [s7, s8];\n                s6 = s7;\n              } else {\n                peg$currPos = s6;\n                s6 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s6;\n              s6 = peg$FAILED;\n            }\n            while (s6 !== peg$FAILED) {\n              s5.push(s6);\n              s6 = peg$currPos;\n              s7 = [];\n              if (input.charCodeAt(peg$currPos) === 46) {\n                s8 = peg$c1;\n                peg$currPos++;\n              } else {\n                s8 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c2); }\n              }\n              if (s8 !== peg$FAILED) {\n                while (s8 !== peg$FAILED) {\n                  s7.push(s8);\n                  if (input.charCodeAt(peg$currPos) === 46) {\n                    s8 = peg$c1;\n                    peg$currPos++;\n                  } else {\n                    s8 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c2); }\n                  }\n                }\n              } else {\n                s7 = peg$FAILED;\n              }\n              if (s7 !== peg$FAILED) {\n                s8 = [];\n                s9 = peg$parsePN_CHARS();\n                if (s9 !== peg$FAILED) {\n                  while (s9 !== peg$FAILED) {\n                    s8.push(s9);\n                    s9 = peg$parsePN_CHARS();\n                  }\n                } else {\n                  s8 = peg$FAILED;\n                }\n                if (s8 !== peg$FAILED) {\n                  s7 = [s7, s8];\n                  s6 = s7;\n                } else {\n                  peg$currPos = s6;\n                  s6 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s6;\n                s6 = peg$FAILED;\n              }\n            }\n            if (s5 !== peg$FAILED) {\n              s2 = [s2, s3, s4, s5];\n              s1 = s2;\n            } else {\n              peg$currPos = s1;\n              s1 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s1;\n            s1 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s1;\n          s1 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s1;\n        s1 = peg$FAILED;\n      }\n      if (s1 !== peg$FAILED) {\n        s0 = input.substring(s0, peg$currPos);\n      } else {\n        s0 = s1;\n      }\n\n      return s0;\n    }\n\n    function peg$parseLANGTAG() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 64) {\n        s1 = peg$c89;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c90); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        if (peg$c91.test(input.charAt(peg$currPos))) {\n          s3 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c92); }\n        }\n        if (s3 !== peg$FAILED) {\n          while (s3 !== peg$FAILED) {\n            s2.push(s3);\n            if (peg$c91.test(input.charAt(peg$currPos))) {\n              s3 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s3 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c92); }\n            }\n          }\n        } else {\n          s2 = peg$FAILED;\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = [];\n          s4 = peg$currPos;\n          if (input.charCodeAt(peg$currPos) === 45) {\n            s5 = peg$c93;\n            peg$currPos++;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c94); }\n          }\n          if (s5 !== peg$FAILED) {\n            s6 = [];\n            if (peg$c95.test(input.charAt(peg$currPos))) {\n              s7 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s7 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c96); }\n            }\n            if (s7 !== peg$FAILED) {\n              while (s7 !== peg$FAILED) {\n                s6.push(s7);\n                if (peg$c95.test(input.charAt(peg$currPos))) {\n                  s7 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s7 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c96); }\n                }\n              }\n            } else {\n              s6 = peg$FAILED;\n            }\n            if (s6 !== peg$FAILED) {\n              peg$savedPos = s4;\n              s5 = peg$c97(s2, s6);\n              s4 = s5;\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s4;\n            s4 = peg$FAILED;\n          }\n          while (s4 !== peg$FAILED) {\n            s3.push(s4);\n            s4 = peg$currPos;\n            if (input.charCodeAt(peg$currPos) === 45) {\n              s5 = peg$c93;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c94); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = [];\n              if (peg$c95.test(input.charAt(peg$currPos))) {\n                s7 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s7 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c96); }\n              }\n              if (s7 !== peg$FAILED) {\n                while (s7 !== peg$FAILED) {\n                  s6.push(s7);\n                  if (peg$c95.test(input.charAt(peg$currPos))) {\n                    s7 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                  } else {\n                    s7 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c96); }\n                  }\n                }\n              } else {\n                s6 = peg$FAILED;\n              }\n              if (s6 !== peg$FAILED) {\n                peg$savedPos = s4;\n                s5 = peg$c97(s2, s6);\n                s4 = s5;\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          }\n          if (s3 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c98(s2, s3);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parseINTEGER() {\n      var s0, s1, s2, s3, s4, s5;\n\n      s0 = peg$currPos;\n      s1 = peg$currPos;\n      s2 = peg$currPos;\n      if (peg$c99.test(input.charAt(peg$currPos))) {\n        s3 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s3 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c100); }\n      }\n      if (s3 === peg$FAILED) {\n        s3 = null;\n      }\n      if (s3 !== peg$FAILED) {\n        s4 = [];\n        if (peg$c87.test(input.charAt(peg$currPos))) {\n          s5 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s5 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c88); }\n        }\n        if (s5 !== peg$FAILED) {\n          while (s5 !== peg$FAILED) {\n            s4.push(s5);\n            if (peg$c87.test(input.charAt(peg$currPos))) {\n              s5 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c88); }\n            }\n          }\n        } else {\n          s4 = peg$FAILED;\n        }\n        if (s4 !== peg$FAILED) {\n          s3 = [s3, s4];\n          s2 = s3;\n        } else {\n          peg$currPos = s2;\n          s2 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s2;\n        s2 = peg$FAILED;\n      }\n      if (s2 !== peg$FAILED) {\n        s1 = input.substring(s1, peg$currPos);\n      } else {\n        s1 = s2;\n      }\n      if (s1 !== peg$FAILED) {\n        peg$savedPos = s0;\n        s1 = peg$c101(s1);\n      }\n      s0 = s1;\n\n      return s0;\n    }\n\n    function peg$parseDECIMAL() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      s1 = peg$currPos;\n      s2 = peg$currPos;\n      if (peg$c99.test(input.charAt(peg$currPos))) {\n        s3 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s3 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c100); }\n      }\n      if (s3 === peg$FAILED) {\n        s3 = null;\n      }\n      if (s3 !== peg$FAILED) {\n        s4 = [];\n        if (peg$c87.test(input.charAt(peg$currPos))) {\n          s5 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s5 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c88); }\n        }\n        while (s5 !== peg$FAILED) {\n          s4.push(s5);\n          if (peg$c87.test(input.charAt(peg$currPos))) {\n            s5 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c88); }\n          }\n        }\n        if (s4 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 46) {\n            s5 = peg$c1;\n            peg$currPos++;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c2); }\n          }\n          if (s5 !== peg$FAILED) {\n            s6 = [];\n            if (peg$c87.test(input.charAt(peg$currPos))) {\n              s7 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s7 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c88); }\n            }\n            if (s7 !== peg$FAILED) {\n              while (s7 !== peg$FAILED) {\n                s6.push(s7);\n                if (peg$c87.test(input.charAt(peg$currPos))) {\n                  s7 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s7 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c88); }\n                }\n              }\n            } else {\n              s6 = peg$FAILED;\n            }\n            if (s6 !== peg$FAILED) {\n              s3 = [s3, s4, s5, s6];\n              s2 = s3;\n            } else {\n              peg$currPos = s2;\n              s2 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s2;\n            s2 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s2;\n          s2 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s2;\n        s2 = peg$FAILED;\n      }\n      if (s2 !== peg$FAILED) {\n        s1 = input.substring(s1, peg$currPos);\n      } else {\n        s1 = s2;\n      }\n      if (s1 !== peg$FAILED) {\n        peg$savedPos = s0;\n        s1 = peg$c102(s1);\n      }\n      s0 = s1;\n\n      return s0;\n    }\n\n    function peg$parseDOUBLE() {\n      var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n\n      s0 = peg$currPos;\n      s1 = peg$currPos;\n      s2 = peg$currPos;\n      if (peg$c99.test(input.charAt(peg$currPos))) {\n        s3 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s3 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c100); }\n      }\n      if (s3 === peg$FAILED) {\n        s3 = null;\n      }\n      if (s3 !== peg$FAILED) {\n        s4 = peg$currPos;\n        s5 = [];\n        if (peg$c87.test(input.charAt(peg$currPos))) {\n          s6 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s6 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c88); }\n        }\n        if (s6 !== peg$FAILED) {\n          while (s6 !== peg$FAILED) {\n            s5.push(s6);\n            if (peg$c87.test(input.charAt(peg$currPos))) {\n              s6 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s6 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c88); }\n            }\n          }\n        } else {\n          s5 = peg$FAILED;\n        }\n        if (s5 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 46) {\n            s6 = peg$c1;\n            peg$currPos++;\n          } else {\n            s6 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c2); }\n          }\n          if (s6 !== peg$FAILED) {\n            s7 = [];\n            if (peg$c87.test(input.charAt(peg$currPos))) {\n              s8 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s8 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c88); }\n            }\n            while (s8 !== peg$FAILED) {\n              s7.push(s8);\n              if (peg$c87.test(input.charAt(peg$currPos))) {\n                s8 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s8 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c88); }\n              }\n            }\n            if (s7 !== peg$FAILED) {\n              s8 = peg$parseEXPONENT();\n              if (s8 !== peg$FAILED) {\n                s5 = [s5, s6, s7, s8];\n                s4 = s5;\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s4;\n            s4 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s4;\n          s4 = peg$FAILED;\n        }\n        if (s4 === peg$FAILED) {\n          s4 = peg$currPos;\n          if (input.charCodeAt(peg$currPos) === 46) {\n            s5 = peg$c1;\n            peg$currPos++;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c2); }\n          }\n          if (s5 !== peg$FAILED) {\n            s6 = [];\n            if (peg$c87.test(input.charAt(peg$currPos))) {\n              s7 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s7 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c88); }\n            }\n            if (s7 !== peg$FAILED) {\n              while (s7 !== peg$FAILED) {\n                s6.push(s7);\n                if (peg$c87.test(input.charAt(peg$currPos))) {\n                  s7 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s7 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c88); }\n                }\n              }\n            } else {\n              s6 = peg$FAILED;\n            }\n            if (s6 !== peg$FAILED) {\n              s7 = peg$parseEXPONENT();\n              if (s7 !== peg$FAILED) {\n                s5 = [s5, s6, s7];\n                s4 = s5;\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s4;\n            s4 = peg$FAILED;\n          }\n          if (s4 === peg$FAILED) {\n            s4 = peg$currPos;\n            s5 = [];\n            if (peg$c87.test(input.charAt(peg$currPos))) {\n              s6 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s6 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c88); }\n            }\n            if (s6 !== peg$FAILED) {\n              while (s6 !== peg$FAILED) {\n                s5.push(s6);\n                if (peg$c87.test(input.charAt(peg$currPos))) {\n                  s6 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s6 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c88); }\n                }\n              }\n            } else {\n              s5 = peg$FAILED;\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parseEXPONENT();\n              if (s6 !== peg$FAILED) {\n                s5 = [s5, s6];\n                s4 = s5;\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          }\n        }\n        if (s4 !== peg$FAILED) {\n          s3 = [s3, s4];\n          s2 = s3;\n        } else {\n          peg$currPos = s2;\n          s2 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s2;\n        s2 = peg$FAILED;\n      }\n      if (s2 !== peg$FAILED) {\n        s1 = input.substring(s1, peg$currPos);\n      } else {\n        s1 = s2;\n      }\n      if (s1 !== peg$FAILED) {\n        peg$savedPos = s0;\n        s1 = peg$c103(s1);\n      }\n      s0 = s1;\n\n      return s0;\n    }\n\n    function peg$parseEXPONENT() {\n      var s0, s1, s2, s3, s4, s5;\n\n      s0 = peg$currPos;\n      s1 = peg$currPos;\n      if (peg$c104.test(input.charAt(peg$currPos))) {\n        s2 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s2 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c105); }\n      }\n      if (s2 !== peg$FAILED) {\n        if (peg$c99.test(input.charAt(peg$currPos))) {\n          s3 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c100); }\n        }\n        if (s3 === peg$FAILED) {\n          s3 = null;\n        }\n        if (s3 !== peg$FAILED) {\n          s4 = [];\n          if (peg$c87.test(input.charAt(peg$currPos))) {\n            s5 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c88); }\n          }\n          if (s5 !== peg$FAILED) {\n            while (s5 !== peg$FAILED) {\n              s4.push(s5);\n              if (peg$c87.test(input.charAt(peg$currPos))) {\n                s5 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c88); }\n              }\n            }\n          } else {\n            s4 = peg$FAILED;\n          }\n          if (s4 !== peg$FAILED) {\n            s2 = [s2, s3, s4];\n            s1 = s2;\n          } else {\n            peg$currPos = s1;\n            s1 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s1;\n          s1 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s1;\n        s1 = peg$FAILED;\n      }\n      if (s1 !== peg$FAILED) {\n        s0 = input.substring(s0, peg$currPos);\n      } else {\n        s0 = s1;\n      }\n\n      return s0;\n    }\n\n    function peg$parseSTRING_LITERAL_QUOTE() {\n      var s0, s1, s2, s3;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 34) {\n        s1 = peg$c106;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c107); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        if (peg$c108.test(input.charAt(peg$currPos))) {\n          s3 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c109); }\n        }\n        if (s3 === peg$FAILED) {\n          s3 = peg$parseECHAR();\n          if (s3 === peg$FAILED) {\n            s3 = peg$parseUCHAR();\n          }\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          if (peg$c108.test(input.charAt(peg$currPos))) {\n            s3 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c109); }\n          }\n          if (s3 === peg$FAILED) {\n            s3 = peg$parseECHAR();\n            if (s3 === peg$FAILED) {\n              s3 = peg$parseUCHAR();\n            }\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 34) {\n            s3 = peg$c106;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c107); }\n          }\n          if (s3 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c10(s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parseSTRING_LITERAL_SINGLE_QUOTE() {\n      var s0, s1, s2, s3;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 39) {\n        s1 = peg$c110;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c111); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        if (peg$c112.test(input.charAt(peg$currPos))) {\n          s3 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c113); }\n        }\n        if (s3 === peg$FAILED) {\n          s3 = peg$parseECHAR();\n          if (s3 === peg$FAILED) {\n            s3 = peg$parseUCHAR();\n          }\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          if (peg$c112.test(input.charAt(peg$currPos))) {\n            s3 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c113); }\n          }\n          if (s3 === peg$FAILED) {\n            s3 = peg$parseECHAR();\n            if (s3 === peg$FAILED) {\n              s3 = peg$parseUCHAR();\n            }\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 39) {\n            s3 = peg$c110;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c111); }\n          }\n          if (s3 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c10(s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parseSTRING_LITERAL_LONG_SINGLE_QUOTE() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 3) === peg$c114) {\n        s1 = peg$c114;\n        peg$currPos += 3;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c115); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        if (peg$c116.test(input.charAt(peg$currPos))) {\n          s3 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c117); }\n        }\n        if (s3 === peg$FAILED) {\n          s3 = peg$parseECHAR();\n          if (s3 === peg$FAILED) {\n            s3 = peg$parseUCHAR();\n          }\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          if (peg$c116.test(input.charAt(peg$currPos))) {\n            s3 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c117); }\n          }\n          if (s3 === peg$FAILED) {\n            s3 = peg$parseECHAR();\n            if (s3 === peg$FAILED) {\n              s3 = peg$parseUCHAR();\n            }\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = [];\n          s4 = peg$currPos;\n          if (input.substr(peg$currPos, 2) === peg$c118) {\n            s5 = peg$c118;\n            peg$currPos += 2;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c119); }\n          }\n          if (s5 !== peg$FAILED) {\n            s6 = [];\n            if (peg$c116.test(input.charAt(peg$currPos))) {\n              s7 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s7 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c117); }\n            }\n            if (s7 === peg$FAILED) {\n              s7 = peg$parseECHAR();\n              if (s7 === peg$FAILED) {\n                s7 = peg$parseUCHAR();\n              }\n            }\n            if (s7 !== peg$FAILED) {\n              while (s7 !== peg$FAILED) {\n                s6.push(s7);\n                if (peg$c116.test(input.charAt(peg$currPos))) {\n                  s7 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s7 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c117); }\n                }\n                if (s7 === peg$FAILED) {\n                  s7 = peg$parseECHAR();\n                  if (s7 === peg$FAILED) {\n                    s7 = peg$parseUCHAR();\n                  }\n                }\n              }\n            } else {\n              s6 = peg$FAILED;\n            }\n            if (s6 !== peg$FAILED) {\n              peg$savedPos = s4;\n              s5 = peg$c120(s2, s6);\n              s4 = s5;\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s4;\n            s4 = peg$FAILED;\n          }\n          if (s4 === peg$FAILED) {\n            s4 = peg$currPos;\n            if (input.charCodeAt(peg$currPos) === 39) {\n              s5 = peg$c110;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c111); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = [];\n              if (peg$c116.test(input.charAt(peg$currPos))) {\n                s7 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s7 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c117); }\n              }\n              if (s7 === peg$FAILED) {\n                s7 = peg$parseECHAR();\n                if (s7 === peg$FAILED) {\n                  s7 = peg$parseUCHAR();\n                }\n              }\n              if (s7 !== peg$FAILED) {\n                while (s7 !== peg$FAILED) {\n                  s6.push(s7);\n                  if (peg$c116.test(input.charAt(peg$currPos))) {\n                    s7 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                  } else {\n                    s7 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c117); }\n                  }\n                  if (s7 === peg$FAILED) {\n                    s7 = peg$parseECHAR();\n                    if (s7 === peg$FAILED) {\n                      s7 = peg$parseUCHAR();\n                    }\n                  }\n                }\n              } else {\n                s6 = peg$FAILED;\n              }\n              if (s6 !== peg$FAILED) {\n                peg$savedPos = s4;\n                s5 = peg$c121(s2, s6);\n                s4 = s5;\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          }\n          while (s4 !== peg$FAILED) {\n            s3.push(s4);\n            s4 = peg$currPos;\n            if (input.substr(peg$currPos, 2) === peg$c118) {\n              s5 = peg$c118;\n              peg$currPos += 2;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c119); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = [];\n              if (peg$c116.test(input.charAt(peg$currPos))) {\n                s7 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s7 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c117); }\n              }\n              if (s7 === peg$FAILED) {\n                s7 = peg$parseECHAR();\n                if (s7 === peg$FAILED) {\n                  s7 = peg$parseUCHAR();\n                }\n              }\n              if (s7 !== peg$FAILED) {\n                while (s7 !== peg$FAILED) {\n                  s6.push(s7);\n                  if (peg$c116.test(input.charAt(peg$currPos))) {\n                    s7 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                  } else {\n                    s7 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c117); }\n                  }\n                  if (s7 === peg$FAILED) {\n                    s7 = peg$parseECHAR();\n                    if (s7 === peg$FAILED) {\n                      s7 = peg$parseUCHAR();\n                    }\n                  }\n                }\n              } else {\n                s6 = peg$FAILED;\n              }\n              if (s6 !== peg$FAILED) {\n                peg$savedPos = s4;\n                s5 = peg$c120(s2, s6);\n                s4 = s5;\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n            if (s4 === peg$FAILED) {\n              s4 = peg$currPos;\n              if (input.charCodeAt(peg$currPos) === 39) {\n                s5 = peg$c110;\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c111); }\n              }\n              if (s5 !== peg$FAILED) {\n                s6 = [];\n                if (peg$c116.test(input.charAt(peg$currPos))) {\n                  s7 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s7 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c117); }\n                }\n                if (s7 === peg$FAILED) {\n                  s7 = peg$parseECHAR();\n                  if (s7 === peg$FAILED) {\n                    s7 = peg$parseUCHAR();\n                  }\n                }\n                if (s7 !== peg$FAILED) {\n                  while (s7 !== peg$FAILED) {\n                    s6.push(s7);\n                    if (peg$c116.test(input.charAt(peg$currPos))) {\n                      s7 = input.charAt(peg$currPos);\n                      peg$currPos++;\n                    } else {\n                      s7 = peg$FAILED;\n                      if (peg$silentFails === 0) { peg$fail(peg$c117); }\n                    }\n                    if (s7 === peg$FAILED) {\n                      s7 = peg$parseECHAR();\n                      if (s7 === peg$FAILED) {\n                        s7 = peg$parseUCHAR();\n                      }\n                    }\n                  }\n                } else {\n                  s6 = peg$FAILED;\n                }\n                if (s6 !== peg$FAILED) {\n                  peg$savedPos = s4;\n                  s5 = peg$c121(s2, s6);\n                  s4 = s5;\n                } else {\n                  peg$currPos = s4;\n                  s4 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            }\n          }\n          if (s3 !== peg$FAILED) {\n            if (input.substr(peg$currPos, 3) === peg$c114) {\n              s4 = peg$c114;\n              peg$currPos += 3;\n            } else {\n              s4 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c115); }\n            }\n            if (s4 !== peg$FAILED) {\n              peg$savedPos = s0;\n              s1 = peg$c122(s2, s3);\n              s0 = s1;\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parseSTRING_LITERAL_LONG_QUOTE() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 3) === peg$c123) {\n        s1 = peg$c123;\n        peg$currPos += 3;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c124); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        if (peg$c125.test(input.charAt(peg$currPos))) {\n          s3 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c126); }\n        }\n        if (s3 === peg$FAILED) {\n          s3 = peg$parseECHAR();\n          if (s3 === peg$FAILED) {\n            s3 = peg$parseUCHAR();\n          }\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          if (peg$c125.test(input.charAt(peg$currPos))) {\n            s3 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c126); }\n          }\n          if (s3 === peg$FAILED) {\n            s3 = peg$parseECHAR();\n            if (s3 === peg$FAILED) {\n              s3 = peg$parseUCHAR();\n            }\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = [];\n          s4 = peg$currPos;\n          if (input.substr(peg$currPos, 2) === peg$c127) {\n            s5 = peg$c127;\n            peg$currPos += 2;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c128); }\n          }\n          if (s5 !== peg$FAILED) {\n            s6 = [];\n            if (peg$c125.test(input.charAt(peg$currPos))) {\n              s7 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s7 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c126); }\n            }\n            if (s7 === peg$FAILED) {\n              s7 = peg$parseECHAR();\n              if (s7 === peg$FAILED) {\n                s7 = peg$parseUCHAR();\n              }\n            }\n            if (s7 !== peg$FAILED) {\n              while (s7 !== peg$FAILED) {\n                s6.push(s7);\n                if (peg$c125.test(input.charAt(peg$currPos))) {\n                  s7 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s7 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c126); }\n                }\n                if (s7 === peg$FAILED) {\n                  s7 = peg$parseECHAR();\n                  if (s7 === peg$FAILED) {\n                    s7 = peg$parseUCHAR();\n                  }\n                }\n              }\n            } else {\n              s6 = peg$FAILED;\n            }\n            if (s6 !== peg$FAILED) {\n              peg$savedPos = s4;\n              s5 = peg$c129(s2, s6);\n              s4 = s5;\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s4;\n            s4 = peg$FAILED;\n          }\n          if (s4 === peg$FAILED) {\n            s4 = peg$currPos;\n            if (input.charCodeAt(peg$currPos) === 34) {\n              s5 = peg$c106;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c107); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = [];\n              if (peg$c125.test(input.charAt(peg$currPos))) {\n                s7 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s7 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c126); }\n              }\n              if (s7 === peg$FAILED) {\n                s7 = peg$parseECHAR();\n                if (s7 === peg$FAILED) {\n                  s7 = peg$parseUCHAR();\n                }\n              }\n              if (s7 !== peg$FAILED) {\n                while (s7 !== peg$FAILED) {\n                  s6.push(s7);\n                  if (peg$c125.test(input.charAt(peg$currPos))) {\n                    s7 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                  } else {\n                    s7 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c126); }\n                  }\n                  if (s7 === peg$FAILED) {\n                    s7 = peg$parseECHAR();\n                    if (s7 === peg$FAILED) {\n                      s7 = peg$parseUCHAR();\n                    }\n                  }\n                }\n              } else {\n                s6 = peg$FAILED;\n              }\n              if (s6 !== peg$FAILED) {\n                peg$savedPos = s4;\n                s5 = peg$c130(s2, s6);\n                s4 = s5;\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          }\n          while (s4 !== peg$FAILED) {\n            s3.push(s4);\n            s4 = peg$currPos;\n            if (input.substr(peg$currPos, 2) === peg$c127) {\n              s5 = peg$c127;\n              peg$currPos += 2;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c128); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = [];\n              if (peg$c125.test(input.charAt(peg$currPos))) {\n                s7 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s7 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c126); }\n              }\n              if (s7 === peg$FAILED) {\n                s7 = peg$parseECHAR();\n                if (s7 === peg$FAILED) {\n                  s7 = peg$parseUCHAR();\n                }\n              }\n              if (s7 !== peg$FAILED) {\n                while (s7 !== peg$FAILED) {\n                  s6.push(s7);\n                  if (peg$c125.test(input.charAt(peg$currPos))) {\n                    s7 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                  } else {\n                    s7 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c126); }\n                  }\n                  if (s7 === peg$FAILED) {\n                    s7 = peg$parseECHAR();\n                    if (s7 === peg$FAILED) {\n                      s7 = peg$parseUCHAR();\n                    }\n                  }\n                }\n              } else {\n                s6 = peg$FAILED;\n              }\n              if (s6 !== peg$FAILED) {\n                peg$savedPos = s4;\n                s5 = peg$c129(s2, s6);\n                s4 = s5;\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n            if (s4 === peg$FAILED) {\n              s4 = peg$currPos;\n              if (input.charCodeAt(peg$currPos) === 34) {\n                s5 = peg$c106;\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c107); }\n              }\n              if (s5 !== peg$FAILED) {\n                s6 = [];\n                if (peg$c125.test(input.charAt(peg$currPos))) {\n                  s7 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s7 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c126); }\n                }\n                if (s7 === peg$FAILED) {\n                  s7 = peg$parseECHAR();\n                  if (s7 === peg$FAILED) {\n                    s7 = peg$parseUCHAR();\n                  }\n                }\n                if (s7 !== peg$FAILED) {\n                  while (s7 !== peg$FAILED) {\n                    s6.push(s7);\n                    if (peg$c125.test(input.charAt(peg$currPos))) {\n                      s7 = input.charAt(peg$currPos);\n                      peg$currPos++;\n                    } else {\n                      s7 = peg$FAILED;\n                      if (peg$silentFails === 0) { peg$fail(peg$c126); }\n                    }\n                    if (s7 === peg$FAILED) {\n                      s7 = peg$parseECHAR();\n                      if (s7 === peg$FAILED) {\n                        s7 = peg$parseUCHAR();\n                      }\n                    }\n                  }\n                } else {\n                  s6 = peg$FAILED;\n                }\n                if (s6 !== peg$FAILED) {\n                  peg$savedPos = s4;\n                  s5 = peg$c130(s2, s6);\n                  s4 = s5;\n                } else {\n                  peg$currPos = s4;\n                  s4 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            }\n          }\n          if (s3 !== peg$FAILED) {\n            if (input.substr(peg$currPos, 3) === peg$c123) {\n              s4 = peg$c123;\n              peg$currPos += 3;\n            } else {\n              s4 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c124); }\n            }\n            if (s4 !== peg$FAILED) {\n              peg$savedPos = s0;\n              s1 = peg$c122(s2, s3);\n              s0 = s1;\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parseUCHAR() {\n      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;\n\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 2) === peg$c131) {\n        s1 = peg$c131;\n        peg$currPos += 2;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c132); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$currPos;\n        s3 = peg$parseHEX();\n        if (s3 !== peg$FAILED) {\n          s4 = peg$parseHEX();\n          if (s4 !== peg$FAILED) {\n            s5 = peg$parseHEX();\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parseHEX();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseHEX();\n                if (s7 !== peg$FAILED) {\n                  s8 = peg$parseHEX();\n                  if (s8 !== peg$FAILED) {\n                    s9 = peg$parseHEX();\n                    if (s9 !== peg$FAILED) {\n                      s10 = peg$parseHEX();\n                      if (s10 !== peg$FAILED) {\n                        s3 = [s3, s4, s5, s6, s7, s8, s9, s10];\n                        s2 = s3;\n                      } else {\n                        peg$currPos = s2;\n                        s2 = peg$FAILED;\n                      }\n                    } else {\n                      peg$currPos = s2;\n                      s2 = peg$FAILED;\n                    }\n                  } else {\n                    peg$currPos = s2;\n                    s2 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s2;\n                  s2 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s2;\n                s2 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s2;\n              s2 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s2;\n            s2 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s2;\n          s2 = peg$FAILED;\n        }\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c133(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        if (input.substr(peg$currPos, 2) === peg$c134) {\n          s1 = peg$c134;\n          peg$currPos += 2;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c135); }\n        }\n        if (s1 !== peg$FAILED) {\n          s2 = peg$currPos;\n          s3 = peg$parseHEX();\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parseHEX();\n            if (s4 !== peg$FAILED) {\n              s5 = peg$parseHEX();\n              if (s5 !== peg$FAILED) {\n                s6 = peg$parseHEX();\n                if (s6 !== peg$FAILED) {\n                  s3 = [s3, s4, s5, s6];\n                  s2 = s3;\n                } else {\n                  peg$currPos = s2;\n                  s2 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s2;\n                s2 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s2;\n              s2 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s2;\n            s2 = peg$FAILED;\n          }\n          if (s2 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c136(s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseECHAR() {\n      var s0, s1;\n\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 2) === peg$c137) {\n        s1 = peg$c137;\n        peg$currPos += 2;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c138); }\n      }\n      if (s1 !== peg$FAILED) {\n        peg$savedPos = s0;\n        s1 = peg$c139();\n      }\n      s0 = s1;\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        if (input.substr(peg$currPos, 2) === peg$c140) {\n          s1 = peg$c140;\n          peg$currPos += 2;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c141); }\n        }\n        if (s1 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c142();\n        }\n        s0 = s1;\n        if (s0 === peg$FAILED) {\n          s0 = peg$currPos;\n          if (input.substr(peg$currPos, 2) === peg$c143) {\n            s1 = peg$c143;\n            peg$currPos += 2;\n          } else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c144); }\n          }\n          if (s1 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c145();\n          }\n          s0 = s1;\n          if (s0 === peg$FAILED) {\n            s0 = peg$currPos;\n            if (input.substr(peg$currPos, 2) === peg$c146) {\n              s1 = peg$c146;\n              peg$currPos += 2;\n            } else {\n              s1 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c147); }\n            }\n            if (s1 !== peg$FAILED) {\n              peg$savedPos = s0;\n              s1 = peg$c148();\n            }\n            s0 = s1;\n            if (s0 === peg$FAILED) {\n              s0 = peg$currPos;\n              if (input.substr(peg$currPos, 2) === peg$c149) {\n                s1 = peg$c149;\n                peg$currPos += 2;\n              } else {\n                s1 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c150); }\n              }\n              if (s1 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c151();\n              }\n              s0 = s1;\n              if (s0 === peg$FAILED) {\n                s0 = peg$currPos;\n                if (input.substr(peg$currPos, 2) === peg$c152) {\n                  s1 = peg$c152;\n                  peg$currPos += 2;\n                } else {\n                  s1 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c153); }\n                }\n                if (s1 !== peg$FAILED) {\n                  peg$savedPos = s0;\n                  s1 = peg$c154();\n                }\n                s0 = s1;\n                if (s0 === peg$FAILED) {\n                  s0 = peg$currPos;\n                  if (input.substr(peg$currPos, 2) === peg$c155) {\n                    s1 = peg$c155;\n                    peg$currPos += 2;\n                  } else {\n                    s1 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c156); }\n                  }\n                  if (s1 !== peg$FAILED) {\n                    peg$savedPos = s0;\n                    s1 = peg$c157();\n                  }\n                  s0 = s1;\n                  if (s0 === peg$FAILED) {\n                    s0 = peg$currPos;\n                    if (input.substr(peg$currPos, 2) === peg$c158) {\n                      s1 = peg$c158;\n                      peg$currPos += 2;\n                    } else {\n                      s1 = peg$FAILED;\n                      if (peg$silentFails === 0) { peg$fail(peg$c159); }\n                    }\n                    if (s1 !== peg$FAILED) {\n                      peg$savedPos = s0;\n                      s1 = peg$c160();\n                    }\n                    s0 = s1;\n                  }\n                }\n              }\n            }\n          }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseWS() {\n      var s0;\n\n      if (peg$c161.test(input.charAt(peg$currPos))) {\n        s0 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s0 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c162); }\n      }\n\n      return s0;\n    }\n\n    function peg$parseANON() {\n      var s0, s1, s2, s3;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 91) {\n        s1 = peg$c53;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c54); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$parseIGNORE();\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$parseIGNORE();\n        }\n        if (s2 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 93) {\n            s3 = peg$c55;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c56); }\n          }\n          if (s3 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c163();\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parsePN_CHARS_BASE() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      if (peg$c164.test(input.charAt(peg$currPos))) {\n        s1 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c165); }\n      }\n      if (s1 !== peg$FAILED) {\n        if (peg$c166.test(input.charAt(peg$currPos))) {\n          s2 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c167); }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c168(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n      if (s0 === peg$FAILED) {\n        if (peg$c169.test(input.charAt(peg$currPos))) {\n          s0 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s0 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c170); }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parsePN_CHARS_U() {\n      var s0;\n\n      s0 = peg$parsePN_CHARS_BASE();\n      if (s0 === peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 95) {\n          s0 = peg$c171;\n          peg$currPos++;\n        } else {\n          s0 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c172); }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parsePN_CHARS() {\n      var s0;\n\n      s0 = peg$parsePN_CHARS_U();\n      if (s0 === peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 45) {\n          s0 = peg$c93;\n          peg$currPos++;\n        } else {\n          s0 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c94); }\n        }\n        if (s0 === peg$FAILED) {\n          if (peg$c87.test(input.charAt(peg$currPos))) {\n            s0 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s0 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c88); }\n          }\n          if (s0 === peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 183) {\n              s0 = peg$c173;\n              peg$currPos++;\n            } else {\n              s0 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c174); }\n            }\n            if (s0 === peg$FAILED) {\n              if (peg$c175.test(input.charAt(peg$currPos))) {\n                s0 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s0 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c176); }\n              }\n              if (s0 === peg$FAILED) {\n                if (peg$c177.test(input.charAt(peg$currPos))) {\n                  s0 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s0 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c178); }\n                }\n              }\n            }\n          }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parsePN_PREFIX() {\n      var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n\n      s0 = peg$currPos;\n      s1 = peg$currPos;\n      s2 = peg$parsePN_CHARS_BASE();\n      if (s2 !== peg$FAILED) {\n        s3 = [];\n        s4 = peg$parsePN_CHARS();\n        while (s4 !== peg$FAILED) {\n          s3.push(s4);\n          s4 = peg$parsePN_CHARS();\n        }\n        if (s3 !== peg$FAILED) {\n          s4 = [];\n          s5 = peg$currPos;\n          s6 = [];\n          if (input.charCodeAt(peg$currPos) === 46) {\n            s7 = peg$c1;\n            peg$currPos++;\n          } else {\n            s7 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c2); }\n          }\n          if (s7 !== peg$FAILED) {\n            while (s7 !== peg$FAILED) {\n              s6.push(s7);\n              if (input.charCodeAt(peg$currPos) === 46) {\n                s7 = peg$c1;\n                peg$currPos++;\n              } else {\n                s7 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c2); }\n              }\n            }\n          } else {\n            s6 = peg$FAILED;\n          }\n          if (s6 !== peg$FAILED) {\n            s7 = [];\n            s8 = peg$parsePN_CHARS();\n            if (s8 !== peg$FAILED) {\n              while (s8 !== peg$FAILED) {\n                s7.push(s8);\n                s8 = peg$parsePN_CHARS();\n              }\n            } else {\n              s7 = peg$FAILED;\n            }\n            if (s7 !== peg$FAILED) {\n              s6 = [s6, s7];\n              s5 = s6;\n            } else {\n              peg$currPos = s5;\n              s5 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s5;\n            s5 = peg$FAILED;\n          }\n          while (s5 !== peg$FAILED) {\n            s4.push(s5);\n            s5 = peg$currPos;\n            s6 = [];\n            if (input.charCodeAt(peg$currPos) === 46) {\n              s7 = peg$c1;\n              peg$currPos++;\n            } else {\n              s7 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c2); }\n            }\n            if (s7 !== peg$FAILED) {\n              while (s7 !== peg$FAILED) {\n                s6.push(s7);\n                if (input.charCodeAt(peg$currPos) === 46) {\n                  s7 = peg$c1;\n                  peg$currPos++;\n                } else {\n                  s7 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c2); }\n                }\n              }\n            } else {\n              s6 = peg$FAILED;\n            }\n            if (s6 !== peg$FAILED) {\n              s7 = [];\n              s8 = peg$parsePN_CHARS();\n              if (s8 !== peg$FAILED) {\n                while (s8 !== peg$FAILED) {\n                  s7.push(s8);\n                  s8 = peg$parsePN_CHARS();\n                }\n              } else {\n                s7 = peg$FAILED;\n              }\n              if (s7 !== peg$FAILED) {\n                s6 = [s6, s7];\n                s5 = s6;\n              } else {\n                peg$currPos = s5;\n                s5 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s5;\n              s5 = peg$FAILED;\n            }\n          }\n          if (s4 !== peg$FAILED) {\n            s2 = [s2, s3, s4];\n            s1 = s2;\n          } else {\n            peg$currPos = s1;\n            s1 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s1;\n          s1 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s1;\n        s1 = peg$FAILED;\n      }\n      if (s1 !== peg$FAILED) {\n        s0 = input.substring(s0, peg$currPos);\n      } else {\n        s0 = s1;\n      }\n\n      return s0;\n    }\n\n    function peg$parsePN_LOCAL() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      s1 = peg$parsePN_CHARS_U();\n      if (s1 === peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 58) {\n          s1 = peg$c80;\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c81); }\n        }\n        if (s1 === peg$FAILED) {\n          if (peg$c87.test(input.charAt(peg$currPos))) {\n            s1 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c88); }\n          }\n          if (s1 === peg$FAILED) {\n            s1 = peg$parsePLX();\n          }\n        }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$parsePN_CHARS();\n        if (s3 === peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 58) {\n            s3 = peg$c80;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c81); }\n          }\n          if (s3 === peg$FAILED) {\n            s3 = peg$parsePLX();\n          }\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$parsePN_CHARS();\n          if (s3 === peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 58) {\n              s3 = peg$c80;\n              peg$currPos++;\n            } else {\n              s3 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c81); }\n            }\n            if (s3 === peg$FAILED) {\n              s3 = peg$parsePLX();\n            }\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = [];\n          s4 = peg$currPos;\n          s5 = [];\n          if (input.charCodeAt(peg$currPos) === 46) {\n            s6 = peg$c1;\n            peg$currPos++;\n          } else {\n            s6 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c2); }\n          }\n          if (s6 !== peg$FAILED) {\n            while (s6 !== peg$FAILED) {\n              s5.push(s6);\n              if (input.charCodeAt(peg$currPos) === 46) {\n                s6 = peg$c1;\n                peg$currPos++;\n              } else {\n                s6 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c2); }\n              }\n            }\n          } else {\n            s5 = peg$FAILED;\n          }\n          if (s5 !== peg$FAILED) {\n            s6 = [];\n            s7 = peg$parsePN_CHARS();\n            if (s7 === peg$FAILED) {\n              if (input.charCodeAt(peg$currPos) === 58) {\n                s7 = peg$c80;\n                peg$currPos++;\n              } else {\n                s7 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c81); }\n              }\n              if (s7 === peg$FAILED) {\n                s7 = peg$parsePLX();\n              }\n            }\n            if (s7 !== peg$FAILED) {\n              while (s7 !== peg$FAILED) {\n                s6.push(s7);\n                s7 = peg$parsePN_CHARS();\n                if (s7 === peg$FAILED) {\n                  if (input.charCodeAt(peg$currPos) === 58) {\n                    s7 = peg$c80;\n                    peg$currPos++;\n                  } else {\n                    s7 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c81); }\n                  }\n                  if (s7 === peg$FAILED) {\n                    s7 = peg$parsePLX();\n                  }\n                }\n              }\n            } else {\n              s6 = peg$FAILED;\n            }\n            if (s6 !== peg$FAILED) {\n              peg$savedPos = s4;\n              s5 = peg$c179(s1, s2, s5, s6);\n              s4 = s5;\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s4;\n            s4 = peg$FAILED;\n          }\n          while (s4 !== peg$FAILED) {\n            s3.push(s4);\n            s4 = peg$currPos;\n            s5 = [];\n            if (input.charCodeAt(peg$currPos) === 46) {\n              s6 = peg$c1;\n              peg$currPos++;\n            } else {\n              s6 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c2); }\n            }\n            if (s6 !== peg$FAILED) {\n              while (s6 !== peg$FAILED) {\n                s5.push(s6);\n                if (input.charCodeAt(peg$currPos) === 46) {\n                  s6 = peg$c1;\n                  peg$currPos++;\n                } else {\n                  s6 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c2); }\n                }\n              }\n            } else {\n              s5 = peg$FAILED;\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = [];\n              s7 = peg$parsePN_CHARS();\n              if (s7 === peg$FAILED) {\n                if (input.charCodeAt(peg$currPos) === 58) {\n                  s7 = peg$c80;\n                  peg$currPos++;\n                } else {\n                  s7 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c81); }\n                }\n                if (s7 === peg$FAILED) {\n                  s7 = peg$parsePLX();\n                }\n              }\n              if (s7 !== peg$FAILED) {\n                while (s7 !== peg$FAILED) {\n                  s6.push(s7);\n                  s7 = peg$parsePN_CHARS();\n                  if (s7 === peg$FAILED) {\n                    if (input.charCodeAt(peg$currPos) === 58) {\n                      s7 = peg$c80;\n                      peg$currPos++;\n                    } else {\n                      s7 = peg$FAILED;\n                      if (peg$silentFails === 0) { peg$fail(peg$c81); }\n                    }\n                    if (s7 === peg$FAILED) {\n                      s7 = peg$parsePLX();\n                    }\n                  }\n                }\n              } else {\n                s6 = peg$FAILED;\n              }\n              if (s6 !== peg$FAILED) {\n                peg$savedPos = s4;\n                s5 = peg$c179(s1, s2, s5, s6);\n                s4 = s5;\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          }\n          if (s3 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c180(s1, s2, s3);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n    function peg$parsePLX() {\n      var s0;\n\n      s0 = peg$parsePERCENT();\n      if (s0 === peg$FAILED) {\n        s0 = peg$parsePN_LOCAL_ESC();\n      }\n\n      return s0;\n    }\n\n    function peg$parsePERCENT() {\n      var s0, s1, s2, s3, s4;\n\n      s0 = peg$currPos;\n      s1 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 37) {\n        s2 = peg$c181;\n        peg$currPos++;\n      } else {\n        s2 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c182); }\n      }\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parseHEX();\n        if (s3 !== peg$FAILED) {\n          s4 = peg$parseHEX();\n          if (s4 !== peg$FAILED) {\n            s2 = [s2, s3, s4];\n            s1 = s2;\n          } else {\n            peg$currPos = s1;\n            s1 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s1;\n          s1 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s1;\n        s1 = peg$FAILED;\n      }\n      if (s1 !== peg$FAILED) {\n        s0 = input.substring(s0, peg$currPos);\n      } else {\n        s0 = s1;\n      }\n\n      return s0;\n    }\n\n    function peg$parseHEX() {\n      var s0;\n\n      if (peg$c183.test(input.charAt(peg$currPos))) {\n        s0 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s0 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c184); }\n      }\n\n      return s0;\n    }\n\n    function peg$parsePN_LOCAL_ESC() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 92) {\n        s1 = peg$c185;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c186); }\n      }\n      if (s1 !== peg$FAILED) {\n        if (peg$c187.test(input.charAt(peg$currPos))) {\n          s2 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c188); }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c3(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n\n      return s0;\n    }\n\n\n      var isBrowser=new Function(\"try {return this===window;}catch(e){ return false;}\");\n      var URL = isBrowser() ? window.URL : require(\"url\").URL;\n      var isIRI = function(a){return a.match(/^[a-z](.*?):(.+?)/g);};\n      function createObject(property,value){var a={};a[property]=value;return a;}\n      var context = {\n        base : [],\n        data : {},\n        addBase : function(uri){\n          if(context.base.length===0){\n            context.base.push(uri);\n            return;\n          }\n          const last = context.base[context.base.length-1];\n          if(last!==uri) context.base.push(new URL(uri,last).toString());\n        },\n        addPrefix : function(prefix,uri){\n          const list = context.data[prefix];\n          if(list===undefined){\n            context.data[prefix] = [{uri:uri,count:0}];\n          }else if(list[list.length-1].uri!==uri){\n            list.push({uri:uri,count:0});\n          }\n        },\n        hasPrefix : function(prefix){\n          return this.data[prefix]!==undefined;\n        },\n        resolve : function(pname,force){\n          const prefix = Object.keys(context.data).find(key=>pname.indexOf(key+\":\")===0);\n          if(prefix!==undefined) {\n            const list = context.data[prefix];\n            if(list.length===1 && force!==true && isIRI(list[0].uri)) return pname;\n            const uri = list[list.length-1].uri;\n            return pname.replace(prefix+\":\",uri);\n          }else{\n            var base = context.base.length === 0 ? options.baseIRI : context.base[context.base.length-1];\n            if(!base || pname.match(/^(http:|https:|urn:|file:)/)) return pname;\n            if(pname.indexOf(\"//\")===0 && base) return base.split(\"//\")[0]+pname;\n            return new URL(pname,base).toString();\n          }\n        },\n        increment : function(prefix){\n          const list = context.data[prefix];\n          if(list!==undefined)list[list.length-1].count++;\n        },\n        decrement : function(prefix){\n          const list = context.data[prefix];\n          if(list!==undefined)list[list.length-1].count--;\n        },\n        toJSON : function(){\n          const root = {};\n          if(context.base.length>0){\n            if(root[\"@context\"]===undefined)root[\"@context\"] = {};\n            root[\"@context\"][\"@base\"] = context.base[0];\n          }\n          Object.keys(context.data).forEach(key=>{\n            const head = context.data[key][0];\n            if(head.uri===\"http://www.w3.org/2001/XMLSchema#\" && head.count < 1) return;\n            if(!isIRI(head.uri)) return;\n            if(root[\"@context\"]===undefined) root[\"@context\"] = {};\n            root[\"@context\"][key] = head.uri;\n          });\n          return root;\n        }\n      };\n\n      function expandList(container,force){\n        if(container[\"@list\"]===undefined) return container;\n        if(!force && !container[\"@list\"].find(x=>x[\"@list\"]!==undefined)) return container;\n\n        if(container[\"@list\"].length===0)\n          return {\"@id\" : \"http://www.w3.org/1999/02/22-rdf-syntax-ns#nil\"};\n\n        var root = {};\n        var focus = null;\n        container[\"@list\"].forEach(b=>{\n          if(focus===null) focus = root;\n          else {\n            focus[\"http://www.w3.org/1999/02/22-rdf-syntax-ns#rest\"] = {};\n            focus = focus[\"http://www.w3.org/1999/02/22-rdf-syntax-ns#rest\"];\n          }\n          focus[\"http://www.w3.org/1999/02/22-rdf-syntax-ns#first\"] = expandList(b,true);\n          focus[\"http://www.w3.org/1999/02/22-rdf-syntax-ns#rest\"] = {\n            \"@id\" : \"http://www.w3.org/1999/02/22-rdf-syntax-ns#nil\"\n          };\n        });\n        return root;\n      }\n\n\n    peg$result = peg$startRuleFunction();\n\n    if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n      return peg$result;\n    } else {\n      if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n        peg$fail(peg$endExpectation());\n      }\n\n      throw peg$buildStructuredError(\n        peg$maxFailExpected,\n        peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n        peg$maxFailPos < input.length\n          ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n          : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n      );\n    }\n  }\n\n  return {\n    SyntaxError: peg$SyntaxError,\n    parse:       peg$parse\n  };\n});\n","// Currently in sync with Node.js lib/assert.js\n// https://github.com/nodejs/node/commit/2a51ae424a513ec9a6aa3466baa0cc1d55dd4f3b\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n'use strict';\n\nfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar _require = require('./internal/errors'),\n    _require$codes = _require.codes,\n    ERR_AMBIGUOUS_ARGUMENT = _require$codes.ERR_AMBIGUOUS_ARGUMENT,\n    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n    ERR_INVALID_ARG_VALUE = _require$codes.ERR_INVALID_ARG_VALUE,\n    ERR_INVALID_RETURN_VALUE = _require$codes.ERR_INVALID_RETURN_VALUE,\n    ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;\n\nvar AssertionError = require('./internal/assert/assertion_error');\n\nvar _require2 = require('util/'),\n    inspect = _require2.inspect;\n\nvar _require$types = require('util/').types,\n    isPromise = _require$types.isPromise,\n    isRegExp = _require$types.isRegExp;\n\nvar objectAssign = Object.assign ? Object.assign : require('es6-object-assign').assign;\nvar objectIs = Object.is ? Object.is : require('object-is');\nvar errorCache = new Map();\nvar isDeepEqual;\nvar isDeepStrictEqual;\nvar parseExpressionAt;\nvar findNodeAround;\nvar decoder;\n\nfunction lazyLoadComparison() {\n  var comparison = require('./internal/util/comparisons');\n\n  isDeepEqual = comparison.isDeepEqual;\n  isDeepStrictEqual = comparison.isDeepStrictEqual;\n} // Escape control characters but not \\n and \\t to keep the line breaks and\n// indentation intact.\n// eslint-disable-next-line no-control-regex\n\n\nvar escapeSequencesRegExp = /[\\x00-\\x08\\x0b\\x0c\\x0e-\\x1f]/g;\nvar meta = [\"\\\\u0000\", \"\\\\u0001\", \"\\\\u0002\", \"\\\\u0003\", \"\\\\u0004\", \"\\\\u0005\", \"\\\\u0006\", \"\\\\u0007\", '\\\\b', '', '', \"\\\\u000b\", '\\\\f', '', \"\\\\u000e\", \"\\\\u000f\", \"\\\\u0010\", \"\\\\u0011\", \"\\\\u0012\", \"\\\\u0013\", \"\\\\u0014\", \"\\\\u0015\", \"\\\\u0016\", \"\\\\u0017\", \"\\\\u0018\", \"\\\\u0019\", \"\\\\u001a\", \"\\\\u001b\", \"\\\\u001c\", \"\\\\u001d\", \"\\\\u001e\", \"\\\\u001f\"];\n\nvar escapeFn = function escapeFn(str) {\n  return meta[str.charCodeAt(0)];\n};\n\nvar warned = false; // The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\nvar NO_EXCEPTION_SENTINEL = {}; // All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided. All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction innerFail(obj) {\n  if (obj.message instanceof Error) throw obj.message;\n  throw new AssertionError(obj);\n}\n\nfunction fail(actual, expected, message, operator, stackStartFn) {\n  var argsLen = arguments.length;\n  var internalMessage;\n\n  if (argsLen === 0) {\n    internalMessage = 'Failed';\n  } else if (argsLen === 1) {\n    message = actual;\n    actual = undefined;\n  } else {\n    if (warned === false) {\n      warned = true;\n      var warn = process.emitWarning ? process.emitWarning : console.warn.bind(console);\n      warn('assert.fail() with more than one argument is deprecated. ' + 'Please use assert.strictEqual() instead or only pass a message.', 'DeprecationWarning', 'DEP0094');\n    }\n\n    if (argsLen === 2) operator = '!=';\n  }\n\n  if (message instanceof Error) throw message;\n  var errArgs = {\n    actual: actual,\n    expected: expected,\n    operator: operator === undefined ? 'fail' : operator,\n    stackStartFn: stackStartFn || fail\n  };\n\n  if (message !== undefined) {\n    errArgs.message = message;\n  }\n\n  var err = new AssertionError(errArgs);\n\n  if (internalMessage) {\n    err.message = internalMessage;\n    err.generatedMessage = true;\n  }\n\n  throw err;\n}\n\nassert.fail = fail; // The AssertionError is defined in internal/error.\n\nassert.AssertionError = AssertionError;\n\nfunction innerOk(fn, argLen, value, message) {\n  if (!value) {\n    var generatedMessage = false;\n\n    if (argLen === 0) {\n      generatedMessage = true;\n      message = 'No value argument passed to `assert.ok()`';\n    } else if (message instanceof Error) {\n      throw message;\n    }\n\n    var err = new AssertionError({\n      actual: value,\n      expected: true,\n      message: message,\n      operator: '==',\n      stackStartFn: fn\n    });\n    err.generatedMessage = generatedMessage;\n    throw err;\n  }\n} // Pure assertion tests whether a value is truthy, as determined\n// by !!value.\n\n\nfunction ok() {\n  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n    args[_key] = arguments[_key];\n  }\n\n  innerOk.apply(void 0, [ok, args.length].concat(args));\n}\n\nassert.ok = ok; // The equality assertion tests shallow, coercive equality with ==.\n\n/* eslint-disable no-restricted-properties */\n\nassert.equal = function equal(actual, expected, message) {\n  if (arguments.length < 2) {\n    throw new ERR_MISSING_ARGS('actual', 'expected');\n  } // eslint-disable-next-line eqeqeq\n\n\n  if (actual != expected) {\n    innerFail({\n      actual: actual,\n      expected: expected,\n      message: message,\n      operator: '==',\n      stackStartFn: equal\n    });\n  }\n}; // The non-equality assertion tests for whether two objects are not\n// equal with !=.\n\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (arguments.length < 2) {\n    throw new ERR_MISSING_ARGS('actual', 'expected');\n  } // eslint-disable-next-line eqeqeq\n\n\n  if (actual == expected) {\n    innerFail({\n      actual: actual,\n      expected: expected,\n      message: message,\n      operator: '!=',\n      stackStartFn: notEqual\n    });\n  }\n}; // The equivalence assertion tests a deep equality relation.\n\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (arguments.length < 2) {\n    throw new ERR_MISSING_ARGS('actual', 'expected');\n  }\n\n  if (isDeepEqual === undefined) lazyLoadComparison();\n\n  if (!isDeepEqual(actual, expected)) {\n    innerFail({\n      actual: actual,\n      expected: expected,\n      message: message,\n      operator: 'deepEqual',\n      stackStartFn: deepEqual\n    });\n  }\n}; // The non-equivalence assertion tests for any deep inequality.\n\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (arguments.length < 2) {\n    throw new ERR_MISSING_ARGS('actual', 'expected');\n  }\n\n  if (isDeepEqual === undefined) lazyLoadComparison();\n\n  if (isDeepEqual(actual, expected)) {\n    innerFail({\n      actual: actual,\n      expected: expected,\n      message: message,\n      operator: 'notDeepEqual',\n      stackStartFn: notDeepEqual\n    });\n  }\n};\n/* eslint-enable */\n\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n  if (arguments.length < 2) {\n    throw new ERR_MISSING_ARGS('actual', 'expected');\n  }\n\n  if (isDeepEqual === undefined) lazyLoadComparison();\n\n  if (!isDeepStrictEqual(actual, expected)) {\n    innerFail({\n      actual: actual,\n      expected: expected,\n      message: message,\n      operator: 'deepStrictEqual',\n      stackStartFn: deepStrictEqual\n    });\n  }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\n\nfunction notDeepStrictEqual(actual, expected, message) {\n  if (arguments.length < 2) {\n    throw new ERR_MISSING_ARGS('actual', 'expected');\n  }\n\n  if (isDeepEqual === undefined) lazyLoadComparison();\n\n  if (isDeepStrictEqual(actual, expected)) {\n    innerFail({\n      actual: actual,\n      expected: expected,\n      message: message,\n      operator: 'notDeepStrictEqual',\n      stackStartFn: notDeepStrictEqual\n    });\n  }\n}\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (arguments.length < 2) {\n    throw new ERR_MISSING_ARGS('actual', 'expected');\n  }\n\n  if (!objectIs(actual, expected)) {\n    innerFail({\n      actual: actual,\n      expected: expected,\n      message: message,\n      operator: 'strictEqual',\n      stackStartFn: strictEqual\n    });\n  }\n};\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (arguments.length < 2) {\n    throw new ERR_MISSING_ARGS('actual', 'expected');\n  }\n\n  if (objectIs(actual, expected)) {\n    innerFail({\n      actual: actual,\n      expected: expected,\n      message: message,\n      operator: 'notStrictEqual',\n      stackStartFn: notStrictEqual\n    });\n  }\n};\n\nvar Comparison = function Comparison(obj, keys, actual) {\n  var _this = this;\n\n  _classCallCheck(this, Comparison);\n\n  keys.forEach(function (key) {\n    if (key in obj) {\n      if (actual !== undefined && typeof actual[key] === 'string' && isRegExp(obj[key]) && obj[key].test(actual[key])) {\n        _this[key] = actual[key];\n      } else {\n        _this[key] = obj[key];\n      }\n    }\n  });\n};\n\nfunction compareExceptionKey(actual, expected, key, message, keys, fn) {\n  if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) {\n    if (!message) {\n      // Create placeholder objects to create a nice output.\n      var a = new Comparison(actual, keys);\n      var b = new Comparison(expected, keys, actual);\n      var err = new AssertionError({\n        actual: a,\n        expected: b,\n        operator: 'deepStrictEqual',\n        stackStartFn: fn\n      });\n      err.actual = actual;\n      err.expected = expected;\n      err.operator = fn.name;\n      throw err;\n    }\n\n    innerFail({\n      actual: actual,\n      expected: expected,\n      message: message,\n      operator: fn.name,\n      stackStartFn: fn\n    });\n  }\n}\n\nfunction expectedException(actual, expected, msg, fn) {\n  if (typeof expected !== 'function') {\n    if (isRegExp(expected)) return expected.test(actual); // assert.doesNotThrow does not accept objects.\n\n    if (arguments.length === 2) {\n      throw new ERR_INVALID_ARG_TYPE('expected', ['Function', 'RegExp'], expected);\n    } // Handle primitives properly.\n\n\n    if (_typeof(actual) !== 'object' || actual === null) {\n      var err = new AssertionError({\n        actual: actual,\n        expected: expected,\n        message: msg,\n        operator: 'deepStrictEqual',\n        stackStartFn: fn\n      });\n      err.operator = fn.name;\n      throw err;\n    }\n\n    var keys = Object.keys(expected); // Special handle errors to make sure the name and the message are compared\n    // as well.\n\n    if (expected instanceof Error) {\n      keys.push('name', 'message');\n    } else if (keys.length === 0) {\n      throw new ERR_INVALID_ARG_VALUE('error', expected, 'may not be an empty object');\n    }\n\n    if (isDeepEqual === undefined) lazyLoadComparison();\n    keys.forEach(function (key) {\n      if (typeof actual[key] === 'string' && isRegExp(expected[key]) && expected[key].test(actual[key])) {\n        return;\n      }\n\n      compareExceptionKey(actual, expected, key, msg, keys, fn);\n    });\n    return true;\n  } // Guard instanceof against arrow functions as they don't have a prototype.\n\n\n  if (expected.prototype !== undefined && actual instanceof expected) {\n    return true;\n  }\n\n  if (Error.isPrototypeOf(expected)) {\n    return false;\n  }\n\n  return expected.call({}, actual) === true;\n}\n\nfunction getActual(fn) {\n  if (typeof fn !== 'function') {\n    throw new ERR_INVALID_ARG_TYPE('fn', 'Function', fn);\n  }\n\n  try {\n    fn();\n  } catch (e) {\n    return e;\n  }\n\n  return NO_EXCEPTION_SENTINEL;\n}\n\nfunction checkIsPromise(obj) {\n  // Accept native ES6 promises and promises that are implemented in a similar\n  // way. Do not accept thenables that use a function as `obj` and that have no\n  // `catch` handler.\n  // TODO: thenables are checked up until they have the correct methods,\n  // but according to documentation, the `then` method should receive\n  // the `fulfill` and `reject` arguments as well or it may be never resolved.\n  return isPromise(obj) || obj !== null && _typeof(obj) === 'object' && typeof obj.then === 'function' && typeof obj.catch === 'function';\n}\n\nfunction waitForActual(promiseFn) {\n  return Promise.resolve().then(function () {\n    var resultPromise;\n\n    if (typeof promiseFn === 'function') {\n      // Return a rejected promise if `promiseFn` throws synchronously.\n      resultPromise = promiseFn(); // Fail in case no promise is returned.\n\n      if (!checkIsPromise(resultPromise)) {\n        throw new ERR_INVALID_RETURN_VALUE('instance of Promise', 'promiseFn', resultPromise);\n      }\n    } else if (checkIsPromise(promiseFn)) {\n      resultPromise = promiseFn;\n    } else {\n      throw new ERR_INVALID_ARG_TYPE('promiseFn', ['Function', 'Promise'], promiseFn);\n    }\n\n    return Promise.resolve().then(function () {\n      return resultPromise;\n    }).then(function () {\n      return NO_EXCEPTION_SENTINEL;\n    }).catch(function (e) {\n      return e;\n    });\n  });\n}\n\nfunction expectsError(stackStartFn, actual, error, message) {\n  if (typeof error === 'string') {\n    if (arguments.length === 4) {\n      throw new ERR_INVALID_ARG_TYPE('error', ['Object', 'Error', 'Function', 'RegExp'], error);\n    }\n\n    if (_typeof(actual) === 'object' && actual !== null) {\n      if (actual.message === error) {\n        throw new ERR_AMBIGUOUS_ARGUMENT('error/message', \"The error message \\\"\".concat(actual.message, \"\\\" is identical to the message.\"));\n      }\n    } else if (actual === error) {\n      throw new ERR_AMBIGUOUS_ARGUMENT('error/message', \"The error \\\"\".concat(actual, \"\\\" is identical to the message.\"));\n    }\n\n    message = error;\n    error = undefined;\n  } else if (error != null && _typeof(error) !== 'object' && typeof error !== 'function') {\n    throw new ERR_INVALID_ARG_TYPE('error', ['Object', 'Error', 'Function', 'RegExp'], error);\n  }\n\n  if (actual === NO_EXCEPTION_SENTINEL) {\n    var details = '';\n\n    if (error && error.name) {\n      details += \" (\".concat(error.name, \")\");\n    }\n\n    details += message ? \": \".concat(message) : '.';\n    var fnType = stackStartFn.name === 'rejects' ? 'rejection' : 'exception';\n    innerFail({\n      actual: undefined,\n      expected: error,\n      operator: stackStartFn.name,\n      message: \"Missing expected \".concat(fnType).concat(details),\n      stackStartFn: stackStartFn\n    });\n  }\n\n  if (error && !expectedException(actual, error, message, stackStartFn)) {\n    throw actual;\n  }\n}\n\nfunction expectsNoError(stackStartFn, actual, error, message) {\n  if (actual === NO_EXCEPTION_SENTINEL) return;\n\n  if (typeof error === 'string') {\n    message = error;\n    error = undefined;\n  }\n\n  if (!error || expectedException(actual, error)) {\n    var details = message ? \": \".concat(message) : '.';\n    var fnType = stackStartFn.name === 'doesNotReject' ? 'rejection' : 'exception';\n    innerFail({\n      actual: actual,\n      expected: error,\n      operator: stackStartFn.name,\n      message: \"Got unwanted \".concat(fnType).concat(details, \"\\n\") + \"Actual message: \\\"\".concat(actual && actual.message, \"\\\"\"),\n      stackStartFn: stackStartFn\n    });\n  }\n\n  throw actual;\n}\n\nassert.throws = function throws(promiseFn) {\n  for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n    args[_key2 - 1] = arguments[_key2];\n  }\n\n  expectsError.apply(void 0, [throws, getActual(promiseFn)].concat(args));\n};\n\nassert.rejects = function rejects(promiseFn) {\n  for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {\n    args[_key3 - 1] = arguments[_key3];\n  }\n\n  return waitForActual(promiseFn).then(function (result) {\n    return expectsError.apply(void 0, [rejects, result].concat(args));\n  });\n};\n\nassert.doesNotThrow = function doesNotThrow(fn) {\n  for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {\n    args[_key4 - 1] = arguments[_key4];\n  }\n\n  expectsNoError.apply(void 0, [doesNotThrow, getActual(fn)].concat(args));\n};\n\nassert.doesNotReject = function doesNotReject(fn) {\n  for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {\n    args[_key5 - 1] = arguments[_key5];\n  }\n\n  return waitForActual(fn).then(function (result) {\n    return expectsNoError.apply(void 0, [doesNotReject, result].concat(args));\n  });\n};\n\nassert.ifError = function ifError(err) {\n  if (err !== null && err !== undefined) {\n    var message = 'ifError got unwanted exception: ';\n\n    if (_typeof(err) === 'object' && typeof err.message === 'string') {\n      if (err.message.length === 0 && err.constructor) {\n        message += err.constructor.name;\n      } else {\n        message += err.message;\n      }\n    } else {\n      message += inspect(err);\n    }\n\n    var newErr = new AssertionError({\n      actual: err,\n      expected: null,\n      operator: 'ifError',\n      message: message,\n      stackStartFn: ifError\n    }); // Make sure we actually have a stack trace!\n\n    var origStack = err.stack;\n\n    if (typeof origStack === 'string') {\n      // This will remove any duplicated frames from the error frames taken\n      // from within `ifError` and add the original error frames to the newly\n      // created ones.\n      var tmp2 = origStack.split('\\n');\n      tmp2.shift(); // Filter all frames existing in err.stack.\n\n      var tmp1 = newErr.stack.split('\\n');\n\n      for (var i = 0; i < tmp2.length; i++) {\n        // Find the first occurrence of the frame.\n        var pos = tmp1.indexOf(tmp2[i]);\n\n        if (pos !== -1) {\n          // Only keep new frames.\n          tmp1 = tmp1.slice(0, pos);\n          break;\n        }\n      }\n\n      newErr.stack = \"\".concat(tmp1.join('\\n'), \"\\n\").concat(tmp2.join('\\n'));\n    }\n\n    throw newErr;\n  }\n}; // Expose a strict only variant of assert\n\n\nfunction strict() {\n  for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {\n    args[_key6] = arguments[_key6];\n  }\n\n  innerOk.apply(void 0, [strict, args.length].concat(args));\n}\n\nassert.strict = objectAssign(strict, assert, {\n  equal: assert.strictEqual,\n  deepEqual: assert.deepStrictEqual,\n  notEqual: assert.notStrictEqual,\n  notDeepEqual: assert.notDeepStrictEqual\n});\nassert.strict.strict = assert.strict;","// Currently in sync with Node.js lib/internal/assert/assertion_error.js\n// https://github.com/nodejs/node/commit/0817840f775032169ddd70c85ac059f18ffcc81c\n'use strict';\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \"function\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \"function\") { throw new TypeError(\"Super expression must either be null or a function\"); } if (typeof _cache !== \"undefined\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\n\nfunction isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\n\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\"[native code]\") !== -1; }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nvar _require = require('util/'),\n    inspect = _require.inspect;\n\nvar _require2 = require('../errors'),\n    ERR_INVALID_ARG_TYPE = _require2.codes.ERR_INVALID_ARG_TYPE; // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n\n\nfunction endsWith(str, search, this_len) {\n  if (this_len === undefined || this_len > str.length) {\n    this_len = str.length;\n  }\n\n  return str.substring(this_len - search.length, this_len) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat\n\n\nfunction repeat(str, count) {\n  count = Math.floor(count);\n  if (str.length == 0 || count == 0) return '';\n  var maxCount = str.length * count;\n  count = Math.floor(Math.log(count) / Math.log(2));\n\n  while (count) {\n    str += str;\n    count--;\n  }\n\n  str += str.substring(0, maxCount - str.length);\n  return str;\n}\n\nvar blue = '';\nvar green = '';\nvar red = '';\nvar white = '';\nvar kReadableOperator = {\n  deepStrictEqual: 'Expected values to be strictly deep-equal:',\n  strictEqual: 'Expected values to be strictly equal:',\n  strictEqualObject: 'Expected \"actual\" to be reference-equal to \"expected\":',\n  deepEqual: 'Expected values to be loosely deep-equal:',\n  equal: 'Expected values to be loosely equal:',\n  notDeepStrictEqual: 'Expected \"actual\" not to be strictly deep-equal to:',\n  notStrictEqual: 'Expected \"actual\" to be strictly unequal to:',\n  notStrictEqualObject: 'Expected \"actual\" not to be reference-equal to \"expected\":',\n  notDeepEqual: 'Expected \"actual\" not to be loosely deep-equal to:',\n  notEqual: 'Expected \"actual\" to be loosely unequal to:',\n  notIdentical: 'Values identical but not reference-equal:'\n}; // Comparing short primitives should just show === / !== instead of using the\n// diff.\n\nvar kMaxShortLength = 10;\n\nfunction copyError(source) {\n  var keys = Object.keys(source);\n  var target = Object.create(Object.getPrototypeOf(source));\n  keys.forEach(function (key) {\n    target[key] = source[key];\n  });\n  Object.defineProperty(target, 'message', {\n    value: source.message\n  });\n  return target;\n}\n\nfunction inspectValue(val) {\n  // The util.inspect default values could be changed. This makes sure the\n  // error messages contain the necessary information nevertheless.\n  return inspect(val, {\n    compact: false,\n    customInspect: false,\n    depth: 1000,\n    maxArrayLength: Infinity,\n    // Assert compares only enumerable properties (with a few exceptions).\n    showHidden: false,\n    // Having a long line as error is better than wrapping the line for\n    // comparison for now.\n    // TODO(BridgeAR): `breakLength` should be limited as soon as soon as we\n    // have meta information about the inspected properties (i.e., know where\n    // in what line the property starts and ends).\n    breakLength: Infinity,\n    // Assert does not detect proxies currently.\n    showProxy: false,\n    sorted: true,\n    // Inspect getters as we also check them when comparing entries.\n    getters: true\n  });\n}\n\nfunction createErrDiff(actual, expected, operator) {\n  var other = '';\n  var res = '';\n  var lastPos = 0;\n  var end = '';\n  var skipped = false;\n  var actualInspected = inspectValue(actual);\n  var actualLines = actualInspected.split('\\n');\n  var expectedLines = inspectValue(expected).split('\\n');\n  var i = 0;\n  var indicator = ''; // In case both values are objects explicitly mark them as not reference equal\n  // for the `strictEqual` operator.\n\n  if (operator === 'strictEqual' && _typeof(actual) === 'object' && _typeof(expected) === 'object' && actual !== null && expected !== null) {\n    operator = 'strictEqualObject';\n  } // If \"actual\" and \"expected\" fit on a single line and they are not strictly\n  // equal, check further special handling.\n\n\n  if (actualLines.length === 1 && expectedLines.length === 1 && actualLines[0] !== expectedLines[0]) {\n    var inputLength = actualLines[0].length + expectedLines[0].length; // If the character length of \"actual\" and \"expected\" together is less than\n    // kMaxShortLength and if neither is an object and at least one of them is\n    // not `zero`, use the strict equal comparison to visualize the output.\n\n    if (inputLength <= kMaxShortLength) {\n      if ((_typeof(actual) !== 'object' || actual === null) && (_typeof(expected) !== 'object' || expected === null) && (actual !== 0 || expected !== 0)) {\n        // -0 === +0\n        return \"\".concat(kReadableOperator[operator], \"\\n\\n\") + \"\".concat(actualLines[0], \" !== \").concat(expectedLines[0], \"\\n\");\n      }\n    } else if (operator !== 'strictEqualObject') {\n      // If the stderr is a tty and the input length is lower than the current\n      // columns per line, add a mismatch indicator below the output. If it is\n      // not a tty, use a default value of 80 characters.\n      var maxLength = process.stderr && process.stderr.isTTY ? process.stderr.columns : 80;\n\n      if (inputLength < maxLength) {\n        while (actualLines[0][i] === expectedLines[0][i]) {\n          i++;\n        } // Ignore the first characters.\n\n\n        if (i > 2) {\n          // Add position indicator for the first mismatch in case it is a\n          // single line and the input length is less than the column length.\n          indicator = \"\\n  \".concat(repeat(' ', i), \"^\");\n          i = 0;\n        }\n      }\n    }\n  } // Remove all ending lines that match (this optimizes the output for\n  // readability by reducing the number of total changed lines).\n\n\n  var a = actualLines[actualLines.length - 1];\n  var b = expectedLines[expectedLines.length - 1];\n\n  while (a === b) {\n    if (i++ < 2) {\n      end = \"\\n  \".concat(a).concat(end);\n    } else {\n      other = a;\n    }\n\n    actualLines.pop();\n    expectedLines.pop();\n    if (actualLines.length === 0 || expectedLines.length === 0) break;\n    a = actualLines[actualLines.length - 1];\n    b = expectedLines[expectedLines.length - 1];\n  }\n\n  var maxLines = Math.max(actualLines.length, expectedLines.length); // Strict equal with identical objects that are not identical by reference.\n  // E.g., assert.deepStrictEqual({ a: Symbol() }, { a: Symbol() })\n\n  if (maxLines === 0) {\n    // We have to get the result again. The lines were all removed before.\n    var _actualLines = actualInspected.split('\\n'); // Only remove lines in case it makes sense to collapse those.\n    // TODO: Accept env to always show the full error.\n\n\n    if (_actualLines.length > 30) {\n      _actualLines[26] = \"\".concat(blue, \"...\").concat(white);\n\n      while (_actualLines.length > 27) {\n        _actualLines.pop();\n      }\n    }\n\n    return \"\".concat(kReadableOperator.notIdentical, \"\\n\\n\").concat(_actualLines.join('\\n'), \"\\n\");\n  }\n\n  if (i > 3) {\n    end = \"\\n\".concat(blue, \"...\").concat(white).concat(end);\n    skipped = true;\n  }\n\n  if (other !== '') {\n    end = \"\\n  \".concat(other).concat(end);\n    other = '';\n  }\n\n  var printedLines = 0;\n  var msg = kReadableOperator[operator] + \"\\n\".concat(green, \"+ actual\").concat(white, \" \").concat(red, \"- expected\").concat(white);\n  var skippedMsg = \" \".concat(blue, \"...\").concat(white, \" Lines skipped\");\n\n  for (i = 0; i < maxLines; i++) {\n    // Only extra expected lines exist\n    var cur = i - lastPos;\n\n    if (actualLines.length < i + 1) {\n      // If the last diverging line is more than one line above and the\n      // current line is at least line three, add some of the former lines and\n      // also add dots to indicate skipped entries.\n      if (cur > 1 && i > 2) {\n        if (cur > 4) {\n          res += \"\\n\".concat(blue, \"...\").concat(white);\n          skipped = true;\n        } else if (cur > 3) {\n          res += \"\\n  \".concat(expectedLines[i - 2]);\n          printedLines++;\n        }\n\n        res += \"\\n  \".concat(expectedLines[i - 1]);\n        printedLines++;\n      } // Mark the current line as the last diverging one.\n\n\n      lastPos = i; // Add the expected line to the cache.\n\n      other += \"\\n\".concat(red, \"-\").concat(white, \" \").concat(expectedLines[i]);\n      printedLines++; // Only extra actual lines exist\n    } else if (expectedLines.length < i + 1) {\n      // If the last diverging line is more than one line above and the\n      // current line is at least line three, add some of the former lines and\n      // also add dots to indicate skipped entries.\n      if (cur > 1 && i > 2) {\n        if (cur > 4) {\n          res += \"\\n\".concat(blue, \"...\").concat(white);\n          skipped = true;\n        } else if (cur > 3) {\n          res += \"\\n  \".concat(actualLines[i - 2]);\n          printedLines++;\n        }\n\n        res += \"\\n  \".concat(actualLines[i - 1]);\n        printedLines++;\n      } // Mark the current line as the last diverging one.\n\n\n      lastPos = i; // Add the actual line to the result.\n\n      res += \"\\n\".concat(green, \"+\").concat(white, \" \").concat(actualLines[i]);\n      printedLines++; // Lines diverge\n    } else {\n      var expectedLine = expectedLines[i];\n      var actualLine = actualLines[i]; // If the lines diverge, specifically check for lines that only diverge by\n      // a trailing comma. In that case it is actually identical and we should\n      // mark it as such.\n\n      var divergingLines = actualLine !== expectedLine && (!endsWith(actualLine, ',') || actualLine.slice(0, -1) !== expectedLine); // If the expected line has a trailing comma but is otherwise identical,\n      // add a comma at the end of the actual line. Otherwise the output could\n      // look weird as in:\n      //\n      //   [\n      //     1         // No comma at the end!\n      // +   2\n      //   ]\n      //\n\n      if (divergingLines && endsWith(expectedLine, ',') && expectedLine.slice(0, -1) === actualLine) {\n        divergingLines = false;\n        actualLine += ',';\n      }\n\n      if (divergingLines) {\n        // If the last diverging line is more than one line above and the\n        // current line is at least line three, add some of the former lines and\n        // also add dots to indicate skipped entries.\n        if (cur > 1 && i > 2) {\n          if (cur > 4) {\n            res += \"\\n\".concat(blue, \"...\").concat(white);\n            skipped = true;\n          } else if (cur > 3) {\n            res += \"\\n  \".concat(actualLines[i - 2]);\n            printedLines++;\n          }\n\n          res += \"\\n  \".concat(actualLines[i - 1]);\n          printedLines++;\n        } // Mark the current line as the last diverging one.\n\n\n        lastPos = i; // Add the actual line to the result and cache the expected diverging\n        // line so consecutive diverging lines show up as +++--- and not +-+-+-.\n\n        res += \"\\n\".concat(green, \"+\").concat(white, \" \").concat(actualLine);\n        other += \"\\n\".concat(red, \"-\").concat(white, \" \").concat(expectedLine);\n        printedLines += 2; // Lines are identical\n      } else {\n        // Add all cached information to the result before adding other things\n        // and reset the cache.\n        res += other;\n        other = ''; // If the last diverging line is exactly one line above or if it is the\n        // very first line, add the line to the result.\n\n        if (cur === 1 || i === 0) {\n          res += \"\\n  \".concat(actualLine);\n          printedLines++;\n        }\n      }\n    } // Inspected object to big (Show ~20 rows max)\n\n\n    if (printedLines > 20 && i < maxLines - 2) {\n      return \"\".concat(msg).concat(skippedMsg, \"\\n\").concat(res, \"\\n\").concat(blue, \"...\").concat(white).concat(other, \"\\n\") + \"\".concat(blue, \"...\").concat(white);\n    }\n  }\n\n  return \"\".concat(msg).concat(skipped ? skippedMsg : '', \"\\n\").concat(res).concat(other).concat(end).concat(indicator);\n}\n\nvar AssertionError =\n/*#__PURE__*/\nfunction (_Error) {\n  _inherits(AssertionError, _Error);\n\n  function AssertionError(options) {\n    var _this;\n\n    _classCallCheck(this, AssertionError);\n\n    if (_typeof(options) !== 'object' || options === null) {\n      throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);\n    }\n\n    var message = options.message,\n        operator = options.operator,\n        stackStartFn = options.stackStartFn;\n    var actual = options.actual,\n        expected = options.expected;\n    var limit = Error.stackTraceLimit;\n    Error.stackTraceLimit = 0;\n\n    if (message != null) {\n      _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, String(message)));\n    } else {\n      if (process.stderr && process.stderr.isTTY) {\n        // Reset on each call to make sure we handle dynamically set environment\n        // variables correct.\n        if (process.stderr && process.stderr.getColorDepth && process.stderr.getColorDepth() !== 1) {\n          blue = \"\\x1B[34m\";\n          green = \"\\x1B[32m\";\n          white = \"\\x1B[39m\";\n          red = \"\\x1B[31m\";\n        } else {\n          blue = '';\n          green = '';\n          white = '';\n          red = '';\n        }\n      } // Prevent the error stack from being visible by duplicating the error\n      // in a very close way to the original in case both sides are actually\n      // instances of Error.\n\n\n      if (_typeof(actual) === 'object' && actual !== null && _typeof(expected) === 'object' && expected !== null && 'stack' in actual && actual instanceof Error && 'stack' in expected && expected instanceof Error) {\n        actual = copyError(actual);\n        expected = copyError(expected);\n      }\n\n      if (operator === 'deepStrictEqual' || operator === 'strictEqual') {\n        _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, createErrDiff(actual, expected, operator)));\n      } else if (operator === 'notDeepStrictEqual' || operator === 'notStrictEqual') {\n        // In case the objects are equal but the operator requires unequal, show\n        // the first object and say A equals B\n        var base = kReadableOperator[operator];\n        var res = inspectValue(actual).split('\\n'); // In case \"actual\" is an object, it should not be reference equal.\n\n        if (operator === 'notStrictEqual' && _typeof(actual) === 'object' && actual !== null) {\n          base = kReadableOperator.notStrictEqualObject;\n        } // Only remove lines in case it makes sense to collapse those.\n        // TODO: Accept env to always show the full error.\n\n\n        if (res.length > 30) {\n          res[26] = \"\".concat(blue, \"...\").concat(white);\n\n          while (res.length > 27) {\n            res.pop();\n          }\n        } // Only print a single input.\n\n\n        if (res.length === 1) {\n          _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, \"\".concat(base, \" \").concat(res[0])));\n        } else {\n          _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, \"\".concat(base, \"\\n\\n\").concat(res.join('\\n'), \"\\n\")));\n        }\n      } else {\n        var _res = inspectValue(actual);\n\n        var other = '';\n        var knownOperators = kReadableOperator[operator];\n\n        if (operator === 'notDeepEqual' || operator === 'notEqual') {\n          _res = \"\".concat(kReadableOperator[operator], \"\\n\\n\").concat(_res);\n\n          if (_res.length > 1024) {\n            _res = \"\".concat(_res.slice(0, 1021), \"...\");\n          }\n        } else {\n          other = \"\".concat(inspectValue(expected));\n\n          if (_res.length > 512) {\n            _res = \"\".concat(_res.slice(0, 509), \"...\");\n          }\n\n          if (other.length > 512) {\n            other = \"\".concat(other.slice(0, 509), \"...\");\n          }\n\n          if (operator === 'deepEqual' || operator === 'equal') {\n            _res = \"\".concat(knownOperators, \"\\n\\n\").concat(_res, \"\\n\\nshould equal\\n\\n\");\n          } else {\n            other = \" \".concat(operator, \" \").concat(other);\n          }\n        }\n\n        _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, \"\".concat(_res).concat(other)));\n      }\n    }\n\n    Error.stackTraceLimit = limit;\n    _this.generatedMessage = !message;\n    Object.defineProperty(_assertThisInitialized(_this), 'name', {\n      value: 'AssertionError [ERR_ASSERTION]',\n      enumerable: false,\n      writable: true,\n      configurable: true\n    });\n    _this.code = 'ERR_ASSERTION';\n    _this.actual = actual;\n    _this.expected = expected;\n    _this.operator = operator;\n\n    if (Error.captureStackTrace) {\n      // eslint-disable-next-line no-restricted-syntax\n      Error.captureStackTrace(_assertThisInitialized(_this), stackStartFn);\n    } // Create error message including the error code in the name.\n\n\n    _this.stack; // Reset the name.\n\n    _this.name = 'AssertionError';\n    return _possibleConstructorReturn(_this);\n  }\n\n  _createClass(AssertionError, [{\n    key: \"toString\",\n    value: function toString() {\n      return \"\".concat(this.name, \" [\").concat(this.code, \"]: \").concat(this.message);\n    }\n  }, {\n    key: inspect.custom,\n    value: function value(recurseTimes, ctx) {\n      // This limits the `actual` and `expected` property default inspection to\n      // the minimum depth. Otherwise those values would be too verbose compared\n      // to the actual error message which contains a combined view of these two\n      // input values.\n      return inspect(this, _objectSpread({}, ctx, {\n        customInspect: false,\n        depth: 0\n      }));\n    }\n  }]);\n\n  return AssertionError;\n}(_wrapNativeSuper(Error));\n\nmodule.exports = AssertionError;","// Currently in sync with Node.js lib/internal/errors.js\n// https://github.com/nodejs/node/commit/3b044962c48fe313905877a96b5d0894a5404f6f\n\n/* eslint node-core/documented-errors: \"error\" */\n\n/* eslint node-core/alphabetize-errors: \"error\" */\n\n/* eslint node-core/prefer-util-format-errors: \"error\" */\n'use strict'; // The whole point behind this internal module is to allow Node.js to no\n// longer be forced to treat every error message change as a semver-major\n// change. The NodeError classes here all expose a `code` property whose\n// value statically and permanently identifies the error. While the error\n// message may change, the code should not.\n\nfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nvar codes = {}; // Lazy loaded\n\nvar assert;\nvar util;\n\nfunction createErrorType(code, message, Base) {\n  if (!Base) {\n    Base = Error;\n  }\n\n  function getMessage(arg1, arg2, arg3) {\n    if (typeof message === 'string') {\n      return message;\n    } else {\n      return message(arg1, arg2, arg3);\n    }\n  }\n\n  var NodeError =\n  /*#__PURE__*/\n  function (_Base) {\n    _inherits(NodeError, _Base);\n\n    function NodeError(arg1, arg2, arg3) {\n      var _this;\n\n      _classCallCheck(this, NodeError);\n\n      _this = _possibleConstructorReturn(this, _getPrototypeOf(NodeError).call(this, getMessage(arg1, arg2, arg3)));\n      _this.code = code;\n      return _this;\n    }\n\n    return NodeError;\n  }(Base);\n\n  codes[code] = NodeError;\n} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js\n\n\nfunction oneOf(expected, thing) {\n  if (Array.isArray(expected)) {\n    var len = expected.length;\n    expected = expected.map(function (i) {\n      return String(i);\n    });\n\n    if (len > 2) {\n      return \"one of \".concat(thing, \" \").concat(expected.slice(0, len - 1).join(', '), \", or \") + expected[len - 1];\n    } else if (len === 2) {\n      return \"one of \".concat(thing, \" \").concat(expected[0], \" or \").concat(expected[1]);\n    } else {\n      return \"of \".concat(thing, \" \").concat(expected[0]);\n    }\n  } else {\n    return \"of \".concat(thing, \" \").concat(String(expected));\n  }\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith\n\n\nfunction startsWith(str, search, pos) {\n  return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n\n\nfunction endsWith(str, search, this_len) {\n  if (this_len === undefined || this_len > str.length) {\n    this_len = str.length;\n  }\n\n  return str.substring(this_len - search.length, this_len) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\n\n\nfunction includes(str, search, start) {\n  if (typeof start !== 'number') {\n    start = 0;\n  }\n\n  if (start + search.length > str.length) {\n    return false;\n  } else {\n    return str.indexOf(search, start) !== -1;\n  }\n}\n\ncreateErrorType('ERR_AMBIGUOUS_ARGUMENT', 'The \"%s\" argument is ambiguous. %s', TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n  if (assert === undefined) assert = require('../assert');\n  assert(typeof name === 'string', \"'name' must be a string\"); // determiner: 'must be' or 'must not be'\n\n  var determiner;\n\n  if (typeof expected === 'string' && startsWith(expected, 'not ')) {\n    determiner = 'must not be';\n    expected = expected.replace(/^not /, '');\n  } else {\n    determiner = 'must be';\n  }\n\n  var msg;\n\n  if (endsWith(name, ' argument')) {\n    // For cases like 'first argument'\n    msg = \"The \".concat(name, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n  } else {\n    var type = includes(name, '.') ? 'property' : 'argument';\n    msg = \"The \\\"\".concat(name, \"\\\" \").concat(type, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n  } // TODO(BridgeAR): Improve the output by showing `null` and similar.\n\n\n  msg += \". Received type \".concat(_typeof(actual));\n  return msg;\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_VALUE', function (name, value) {\n  var reason = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'is invalid';\n  if (util === undefined) util = require('util/');\n  var inspected = util.inspect(value);\n\n  if (inspected.length > 128) {\n    inspected = \"\".concat(inspected.slice(0, 128), \"...\");\n  }\n\n  return \"The argument '\".concat(name, \"' \").concat(reason, \". Received \").concat(inspected);\n}, TypeError, RangeError);\ncreateErrorType('ERR_INVALID_RETURN_VALUE', function (input, name, value) {\n  var type;\n\n  if (value && value.constructor && value.constructor.name) {\n    type = \"instance of \".concat(value.constructor.name);\n  } else {\n    type = \"type \".concat(_typeof(value));\n  }\n\n  return \"Expected \".concat(input, \" to be returned from the \\\"\").concat(name, \"\\\"\") + \" function but got \".concat(type, \".\");\n}, TypeError);\ncreateErrorType('ERR_MISSING_ARGS', function () {\n  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n    args[_key] = arguments[_key];\n  }\n\n  if (assert === undefined) assert = require('../assert');\n  assert(args.length > 0, 'At least one arg needs to be specified');\n  var msg = 'The ';\n  var len = args.length;\n  args = args.map(function (a) {\n    return \"\\\"\".concat(a, \"\\\"\");\n  });\n\n  switch (len) {\n    case 1:\n      msg += \"\".concat(args[0], \" argument\");\n      break;\n\n    case 2:\n      msg += \"\".concat(args[0], \" and \").concat(args[1], \" arguments\");\n      break;\n\n    default:\n      msg += args.slice(0, len - 1).join(', ');\n      msg += \", and \".concat(args[len - 1], \" arguments\");\n      break;\n  }\n\n  return \"\".concat(msg, \" must be specified\");\n}, TypeError);\nmodule.exports.codes = codes;","// Currently in sync with Node.js lib/internal/util/comparisons.js\n// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9\n'use strict';\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); }\n\nfunction _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nvar regexFlagsSupported = /a/g.flags !== undefined;\n\nvar arrayFromSet = function arrayFromSet(set) {\n  var array = [];\n  set.forEach(function (value) {\n    return array.push(value);\n  });\n  return array;\n};\n\nvar arrayFromMap = function arrayFromMap(map) {\n  var array = [];\n  map.forEach(function (value, key) {\n    return array.push([key, value]);\n  });\n  return array;\n};\n\nvar objectIs = Object.is ? Object.is : require('object-is');\nvar objectGetOwnPropertySymbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function () {\n  return [];\n};\nvar numberIsNaN = Number.isNaN ? Number.isNaN : require('is-nan');\n\nfunction uncurryThis(f) {\n  return f.call.bind(f);\n}\n\nvar hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);\nvar propertyIsEnumerable = uncurryThis(Object.prototype.propertyIsEnumerable);\nvar objectToString = uncurryThis(Object.prototype.toString);\n\nvar _require$types = require('util/').types,\n    isAnyArrayBuffer = _require$types.isAnyArrayBuffer,\n    isArrayBufferView = _require$types.isArrayBufferView,\n    isDate = _require$types.isDate,\n    isMap = _require$types.isMap,\n    isRegExp = _require$types.isRegExp,\n    isSet = _require$types.isSet,\n    isNativeError = _require$types.isNativeError,\n    isBoxedPrimitive = _require$types.isBoxedPrimitive,\n    isNumberObject = _require$types.isNumberObject,\n    isStringObject = _require$types.isStringObject,\n    isBooleanObject = _require$types.isBooleanObject,\n    isBigIntObject = _require$types.isBigIntObject,\n    isSymbolObject = _require$types.isSymbolObject,\n    isFloat32Array = _require$types.isFloat32Array,\n    isFloat64Array = _require$types.isFloat64Array;\n\nfunction isNonIndex(key) {\n  if (key.length === 0 || key.length > 10) return true;\n\n  for (var i = 0; i < key.length; i++) {\n    var code = key.charCodeAt(i);\n    if (code < 48 || code > 57) return true;\n  } // The maximum size for an array is 2 ** 32 -1.\n\n\n  return key.length === 10 && key >= Math.pow(2, 32);\n}\n\nfunction getOwnNonIndexProperties(value) {\n  return Object.keys(value).filter(isNonIndex).concat(objectGetOwnPropertySymbols(value).filter(Object.prototype.propertyIsEnumerable.bind(value)));\n} // Taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n\n\nfunction compare(a, b) {\n  if (a === b) {\n    return 0;\n  }\n\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) {\n    return -1;\n  }\n\n  if (y < x) {\n    return 1;\n  }\n\n  return 0;\n}\n\nvar ONLY_ENUMERABLE = undefined;\nvar kStrict = true;\nvar kLoose = false;\nvar kNoIterator = 0;\nvar kIsArray = 1;\nvar kIsSet = 2;\nvar kIsMap = 3; // Check if they have the same source and flags\n\nfunction areSimilarRegExps(a, b) {\n  return regexFlagsSupported ? a.source === b.source && a.flags === b.flags : RegExp.prototype.toString.call(a) === RegExp.prototype.toString.call(b);\n}\n\nfunction areSimilarFloatArrays(a, b) {\n  if (a.byteLength !== b.byteLength) {\n    return false;\n  }\n\n  for (var offset = 0; offset < a.byteLength; offset++) {\n    if (a[offset] !== b[offset]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction areSimilarTypedArrays(a, b) {\n  if (a.byteLength !== b.byteLength) {\n    return false;\n  }\n\n  return compare(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength)) === 0;\n}\n\nfunction areEqualArrayBuffers(buf1, buf2) {\n  return buf1.byteLength === buf2.byteLength && compare(new Uint8Array(buf1), new Uint8Array(buf2)) === 0;\n}\n\nfunction isEqualBoxedPrimitive(val1, val2) {\n  if (isNumberObject(val1)) {\n    return isNumberObject(val2) && objectIs(Number.prototype.valueOf.call(val1), Number.prototype.valueOf.call(val2));\n  }\n\n  if (isStringObject(val1)) {\n    return isStringObject(val2) && String.prototype.valueOf.call(val1) === String.prototype.valueOf.call(val2);\n  }\n\n  if (isBooleanObject(val1)) {\n    return isBooleanObject(val2) && Boolean.prototype.valueOf.call(val1) === Boolean.prototype.valueOf.call(val2);\n  }\n\n  if (isBigIntObject(val1)) {\n    return isBigIntObject(val2) && BigInt.prototype.valueOf.call(val1) === BigInt.prototype.valueOf.call(val2);\n  }\n\n  return isSymbolObject(val2) && Symbol.prototype.valueOf.call(val1) === Symbol.prototype.valueOf.call(val2);\n} // Notes: Type tags are historical [[Class]] properties that can be set by\n// FunctionTemplate::SetClassName() in C++ or Symbol.toStringTag in JS\n// and retrieved using Object.prototype.toString.call(obj) in JS\n// See https://tc39.github.io/ecma262/#sec-object.prototype.tostring\n// for a list of tags pre-defined in the spec.\n// There are some unspecified tags in the wild too (e.g. typed array tags).\n// Since tags can be altered, they only serve fast failures\n//\n// Typed arrays and buffers are checked by comparing the content in their\n// underlying ArrayBuffer. This optimization requires that it's\n// reasonable to interpret their underlying memory in the same way,\n// which is checked by comparing their type tags.\n// (e.g. a Uint8Array and a Uint16Array with the same memory content\n// could still be different because they will be interpreted differently).\n//\n// For strict comparison, objects should have\n// a) The same built-in type tags\n// b) The same prototypes.\n\n\nfunction innerDeepEqual(val1, val2, strict, memos) {\n  // All identical values are equivalent, as determined by ===.\n  if (val1 === val2) {\n    if (val1 !== 0) return true;\n    return strict ? objectIs(val1, val2) : true;\n  } // Check more closely if val1 and val2 are equal.\n\n\n  if (strict) {\n    if (_typeof(val1) !== 'object') {\n      return typeof val1 === 'number' && numberIsNaN(val1) && numberIsNaN(val2);\n    }\n\n    if (_typeof(val2) !== 'object' || val1 === null || val2 === null) {\n      return false;\n    }\n\n    if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {\n      return false;\n    }\n  } else {\n    if (val1 === null || _typeof(val1) !== 'object') {\n      if (val2 === null || _typeof(val2) !== 'object') {\n        // eslint-disable-next-line eqeqeq\n        return val1 == val2;\n      }\n\n      return false;\n    }\n\n    if (val2 === null || _typeof(val2) !== 'object') {\n      return false;\n    }\n  }\n\n  var val1Tag = objectToString(val1);\n  var val2Tag = objectToString(val2);\n\n  if (val1Tag !== val2Tag) {\n    return false;\n  }\n\n  if (Array.isArray(val1)) {\n    // Check for sparse arrays and general fast path\n    if (val1.length !== val2.length) {\n      return false;\n    }\n\n    var keys1 = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);\n    var keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);\n\n    if (keys1.length !== keys2.length) {\n      return false;\n    }\n\n    return keyCheck(val1, val2, strict, memos, kIsArray, keys1);\n  } // [browserify] This triggers on certain types in IE (Map/Set) so we don't\n  // wan't to early return out of the rest of the checks. However we can check\n  // if the second value is one of these values and the first isn't.\n\n\n  if (val1Tag === '[object Object]') {\n    // return keyCheck(val1, val2, strict, memos, kNoIterator);\n    if (!isMap(val1) && isMap(val2) || !isSet(val1) && isSet(val2)) {\n      return false;\n    }\n  }\n\n  if (isDate(val1)) {\n    if (!isDate(val2) || Date.prototype.getTime.call(val1) !== Date.prototype.getTime.call(val2)) {\n      return false;\n    }\n  } else if (isRegExp(val1)) {\n    if (!isRegExp(val2) || !areSimilarRegExps(val1, val2)) {\n      return false;\n    }\n  } else if (isNativeError(val1) || val1 instanceof Error) {\n    // Do not compare the stack as it might differ even though the error itself\n    // is otherwise identical.\n    if (val1.message !== val2.message || val1.name !== val2.name) {\n      return false;\n    }\n  } else if (isArrayBufferView(val1)) {\n    if (!strict && (isFloat32Array(val1) || isFloat64Array(val1))) {\n      if (!areSimilarFloatArrays(val1, val2)) {\n        return false;\n      }\n    } else if (!areSimilarTypedArrays(val1, val2)) {\n      return false;\n    } // Buffer.compare returns true, so val1.length === val2.length. If they both\n    // only contain numeric keys, we don't need to exam further than checking\n    // the symbols.\n\n\n    var _keys = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);\n\n    var _keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);\n\n    if (_keys.length !== _keys2.length) {\n      return false;\n    }\n\n    return keyCheck(val1, val2, strict, memos, kNoIterator, _keys);\n  } else if (isSet(val1)) {\n    if (!isSet(val2) || val1.size !== val2.size) {\n      return false;\n    }\n\n    return keyCheck(val1, val2, strict, memos, kIsSet);\n  } else if (isMap(val1)) {\n    if (!isMap(val2) || val1.size !== val2.size) {\n      return false;\n    }\n\n    return keyCheck(val1, val2, strict, memos, kIsMap);\n  } else if (isAnyArrayBuffer(val1)) {\n    if (!areEqualArrayBuffers(val1, val2)) {\n      return false;\n    }\n  } else if (isBoxedPrimitive(val1) && !isEqualBoxedPrimitive(val1, val2)) {\n    return false;\n  }\n\n  return keyCheck(val1, val2, strict, memos, kNoIterator);\n}\n\nfunction getEnumerables(val, keys) {\n  return keys.filter(function (k) {\n    return propertyIsEnumerable(val, k);\n  });\n}\n\nfunction keyCheck(val1, val2, strict, memos, iterationType, aKeys) {\n  // For all remaining Object pairs, including Array, objects and Maps,\n  // equivalence is determined by having:\n  // a) The same number of owned enumerable properties\n  // b) The same set of keys/indexes (although not necessarily the same order)\n  // c) Equivalent values for every corresponding key/index\n  // d) For Sets and Maps, equal contents\n  // Note: this accounts for both named and indexed properties on Arrays.\n  if (arguments.length === 5) {\n    aKeys = Object.keys(val1);\n    var bKeys = Object.keys(val2); // The pair must have the same number of owned properties.\n\n    if (aKeys.length !== bKeys.length) {\n      return false;\n    }\n  } // Cheap key test\n\n\n  var i = 0;\n\n  for (; i < aKeys.length; i++) {\n    if (!hasOwnProperty(val2, aKeys[i])) {\n      return false;\n    }\n  }\n\n  if (strict && arguments.length === 5) {\n    var symbolKeysA = objectGetOwnPropertySymbols(val1);\n\n    if (symbolKeysA.length !== 0) {\n      var count = 0;\n\n      for (i = 0; i < symbolKeysA.length; i++) {\n        var key = symbolKeysA[i];\n\n        if (propertyIsEnumerable(val1, key)) {\n          if (!propertyIsEnumerable(val2, key)) {\n            return false;\n          }\n\n          aKeys.push(key);\n          count++;\n        } else if (propertyIsEnumerable(val2, key)) {\n          return false;\n        }\n      }\n\n      var symbolKeysB = objectGetOwnPropertySymbols(val2);\n\n      if (symbolKeysA.length !== symbolKeysB.length && getEnumerables(val2, symbolKeysB).length !== count) {\n        return false;\n      }\n    } else {\n      var _symbolKeysB = objectGetOwnPropertySymbols(val2);\n\n      if (_symbolKeysB.length !== 0 && getEnumerables(val2, _symbolKeysB).length !== 0) {\n        return false;\n      }\n    }\n  }\n\n  if (aKeys.length === 0 && (iterationType === kNoIterator || iterationType === kIsArray && val1.length === 0 || val1.size === 0)) {\n    return true;\n  } // Use memos to handle cycles.\n\n\n  if (memos === undefined) {\n    memos = {\n      val1: new Map(),\n      val2: new Map(),\n      position: 0\n    };\n  } else {\n    // We prevent up to two map.has(x) calls by directly retrieving the value\n    // and checking for undefined. The map can only contain numbers, so it is\n    // safe to check for undefined only.\n    var val2MemoA = memos.val1.get(val1);\n\n    if (val2MemoA !== undefined) {\n      var val2MemoB = memos.val2.get(val2);\n\n      if (val2MemoB !== undefined) {\n        return val2MemoA === val2MemoB;\n      }\n    }\n\n    memos.position++;\n  }\n\n  memos.val1.set(val1, memos.position);\n  memos.val2.set(val2, memos.position);\n  var areEq = objEquiv(val1, val2, strict, aKeys, memos, iterationType);\n  memos.val1.delete(val1);\n  memos.val2.delete(val2);\n  return areEq;\n}\n\nfunction setHasEqualElement(set, val1, strict, memo) {\n  // Go looking.\n  var setValues = arrayFromSet(set);\n\n  for (var i = 0; i < setValues.length; i++) {\n    var val2 = setValues[i];\n\n    if (innerDeepEqual(val1, val2, strict, memo)) {\n      // Remove the matching element to make sure we do not check that again.\n      set.delete(val2);\n      return true;\n    }\n  }\n\n  return false;\n} // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#Loose_equality_using\n// Sadly it is not possible to detect corresponding values properly in case the\n// type is a string, number, bigint or boolean. The reason is that those values\n// can match lots of different string values (e.g., 1n == '+00001').\n\n\nfunction findLooseMatchingPrimitives(prim) {\n  switch (_typeof(prim)) {\n    case 'undefined':\n      return null;\n\n    case 'object':\n      // Only pass in null as object!\n      return undefined;\n\n    case 'symbol':\n      return false;\n\n    case 'string':\n      prim = +prim;\n    // Loose equal entries exist only if the string is possible to convert to\n    // a regular number and not NaN.\n    // Fall through\n\n    case 'number':\n      if (numberIsNaN(prim)) {\n        return false;\n      }\n\n  }\n\n  return true;\n}\n\nfunction setMightHaveLoosePrim(a, b, prim) {\n  var altValue = findLooseMatchingPrimitives(prim);\n  if (altValue != null) return altValue;\n  return b.has(altValue) && !a.has(altValue);\n}\n\nfunction mapMightHaveLoosePrim(a, b, prim, item, memo) {\n  var altValue = findLooseMatchingPrimitives(prim);\n\n  if (altValue != null) {\n    return altValue;\n  }\n\n  var curB = b.get(altValue);\n\n  if (curB === undefined && !b.has(altValue) || !innerDeepEqual(item, curB, false, memo)) {\n    return false;\n  }\n\n  return !a.has(altValue) && innerDeepEqual(item, curB, false, memo);\n}\n\nfunction setEquiv(a, b, strict, memo) {\n  // This is a lazily initiated Set of entries which have to be compared\n  // pairwise.\n  var set = null;\n  var aValues = arrayFromSet(a);\n\n  for (var i = 0; i < aValues.length; i++) {\n    var val = aValues[i]; // Note: Checking for the objects first improves the performance for object\n    // heavy sets but it is a minor slow down for primitives. As they are fast\n    // to check this improves the worst case scenario instead.\n\n    if (_typeof(val) === 'object' && val !== null) {\n      if (set === null) {\n        set = new Set();\n      } // If the specified value doesn't exist in the second set its an not null\n      // object (or non strict only: a not matching primitive) we'll need to go\n      // hunting for something thats deep-(strict-)equal to it. To make this\n      // O(n log n) complexity we have to copy these values in a new set first.\n\n\n      set.add(val);\n    } else if (!b.has(val)) {\n      if (strict) return false; // Fast path to detect missing string, symbol, undefined and null values.\n\n      if (!setMightHaveLoosePrim(a, b, val)) {\n        return false;\n      }\n\n      if (set === null) {\n        set = new Set();\n      }\n\n      set.add(val);\n    }\n  }\n\n  if (set !== null) {\n    var bValues = arrayFromSet(b);\n\n    for (var _i = 0; _i < bValues.length; _i++) {\n      var _val = bValues[_i]; // We have to check if a primitive value is already\n      // matching and only if it's not, go hunting for it.\n\n      if (_typeof(_val) === 'object' && _val !== null) {\n        if (!setHasEqualElement(set, _val, strict, memo)) return false;\n      } else if (!strict && !a.has(_val) && !setHasEqualElement(set, _val, strict, memo)) {\n        return false;\n      }\n    }\n\n    return set.size === 0;\n  }\n\n  return true;\n}\n\nfunction mapHasEqualEntry(set, map, key1, item1, strict, memo) {\n  // To be able to handle cases like:\n  //   Map([[{}, 'a'], [{}, 'b']]) vs Map([[{}, 'b'], [{}, 'a']])\n  // ... we need to consider *all* matching keys, not just the first we find.\n  var setValues = arrayFromSet(set);\n\n  for (var i = 0; i < setValues.length; i++) {\n    var key2 = setValues[i];\n\n    if (innerDeepEqual(key1, key2, strict, memo) && innerDeepEqual(item1, map.get(key2), strict, memo)) {\n      set.delete(key2);\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction mapEquiv(a, b, strict, memo) {\n  var set = null;\n  var aEntries = arrayFromMap(a);\n\n  for (var i = 0; i < aEntries.length; i++) {\n    var _aEntries$i = _slicedToArray(aEntries[i], 2),\n        key = _aEntries$i[0],\n        item1 = _aEntries$i[1];\n\n    if (_typeof(key) === 'object' && key !== null) {\n      if (set === null) {\n        set = new Set();\n      }\n\n      set.add(key);\n    } else {\n      // By directly retrieving the value we prevent another b.has(key) check in\n      // almost all possible cases.\n      var item2 = b.get(key);\n\n      if (item2 === undefined && !b.has(key) || !innerDeepEqual(item1, item2, strict, memo)) {\n        if (strict) return false; // Fast path to detect missing string, symbol, undefined and null\n        // keys.\n\n        if (!mapMightHaveLoosePrim(a, b, key, item1, memo)) return false;\n\n        if (set === null) {\n          set = new Set();\n        }\n\n        set.add(key);\n      }\n    }\n  }\n\n  if (set !== null) {\n    var bEntries = arrayFromMap(b);\n\n    for (var _i2 = 0; _i2 < bEntries.length; _i2++) {\n      var _bEntries$_i = _slicedToArray(bEntries[_i2], 2),\n          key = _bEntries$_i[0],\n          item = _bEntries$_i[1];\n\n      if (_typeof(key) === 'object' && key !== null) {\n        if (!mapHasEqualEntry(set, a, key, item, strict, memo)) return false;\n      } else if (!strict && (!a.has(key) || !innerDeepEqual(a.get(key), item, false, memo)) && !mapHasEqualEntry(set, a, key, item, false, memo)) {\n        return false;\n      }\n    }\n\n    return set.size === 0;\n  }\n\n  return true;\n}\n\nfunction objEquiv(a, b, strict, keys, memos, iterationType) {\n  // Sets and maps don't have their entries accessible via normal object\n  // properties.\n  var i = 0;\n\n  if (iterationType === kIsSet) {\n    if (!setEquiv(a, b, strict, memos)) {\n      return false;\n    }\n  } else if (iterationType === kIsMap) {\n    if (!mapEquiv(a, b, strict, memos)) {\n      return false;\n    }\n  } else if (iterationType === kIsArray) {\n    for (; i < a.length; i++) {\n      if (hasOwnProperty(a, i)) {\n        if (!hasOwnProperty(b, i) || !innerDeepEqual(a[i], b[i], strict, memos)) {\n          return false;\n        }\n      } else if (hasOwnProperty(b, i)) {\n        return false;\n      } else {\n        // Array is sparse.\n        var keysA = Object.keys(a);\n\n        for (; i < keysA.length; i++) {\n          var key = keysA[i];\n\n          if (!hasOwnProperty(b, key) || !innerDeepEqual(a[key], b[key], strict, memos)) {\n            return false;\n          }\n        }\n\n        if (keysA.length !== Object.keys(b).length) {\n          return false;\n        }\n\n        return true;\n      }\n    }\n  } // The pair must have equivalent values for every corresponding key.\n  // Possibly expensive deep test:\n\n\n  for (i = 0; i < keys.length; i++) {\n    var _key = keys[i];\n\n    if (!innerDeepEqual(a[_key], b[_key], strict, memos)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isDeepEqual(val1, val2) {\n  return innerDeepEqual(val1, val2, kLoose);\n}\n\nfunction isDeepStrictEqual(val1, val2) {\n  return innerDeepEqual(val1, val2, kStrict);\n}\n\nmodule.exports = {\n  isDeepEqual: isDeepEqual,\n  isDeepStrictEqual: isDeepStrictEqual\n};","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nconst base64 = require('base64-js')\nconst ieee754 = require('ieee754')\nconst customInspectSymbol =\n  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\n    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\n    : null\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nconst K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Print warning and recommend using `buffer` v4.x which has an Object\n *               implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n    typeof console.error === 'function') {\n  console.error(\n    'This browser lacks typed array (Uint8Array) support which is required by ' +\n    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n  )\n}\n\nfunction typedArraySupport () {\n  // Can typed array instances can be augmented?\n  try {\n    const arr = new Uint8Array(1)\n    const proto = { foo: function () { return 42 } }\n    Object.setPrototypeOf(proto, Uint8Array.prototype)\n    Object.setPrototypeOf(arr, proto)\n    return arr.foo() === 42\n  } catch (e) {\n    return false\n  }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.buffer\n  }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.byteOffset\n  }\n})\n\nfunction createBuffer (length) {\n  if (length > K_MAX_LENGTH) {\n    throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n  }\n  // Return an augmented `Uint8Array` instance\n  const buf = new Uint8Array(length)\n  Object.setPrototypeOf(buf, Buffer.prototype)\n  return buf\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new TypeError(\n        'The \"string\" argument must be of type string. Received type number'\n      )\n    }\n    return allocUnsafe(arg)\n  }\n  return from(arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n  if (typeof value === 'string') {\n    return fromString(value, encodingOrOffset)\n  }\n\n  if (ArrayBuffer.isView(value)) {\n    return fromArrayView(value)\n  }\n\n  if (value == null) {\n    throw new TypeError(\n      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n      'or Array-like Object. Received type ' + (typeof value)\n    )\n  }\n\n  if (isInstance(value, ArrayBuffer) ||\n      (value && isInstance(value.buffer, ArrayBuffer))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof SharedArrayBuffer !== 'undefined' &&\n      (isInstance(value, SharedArrayBuffer) ||\n      (value && isInstance(value.buffer, SharedArrayBuffer)))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'number') {\n    throw new TypeError(\n      'The \"value\" argument must not be of type number. Received type number'\n    )\n  }\n\n  const valueOf = value.valueOf && value.valueOf()\n  if (valueOf != null && valueOf !== value) {\n    return Buffer.from(valueOf, encodingOrOffset, length)\n  }\n\n  const b = fromObject(value)\n  if (b) return b\n\n  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n      typeof value[Symbol.toPrimitive] === 'function') {\n    return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length)\n  }\n\n  throw new TypeError(\n    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n    'or Array-like Object. Received type ' + (typeof value)\n  )\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\nObject.setPrototypeOf(Buffer, Uint8Array)\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be of type number')\n  } else if (size < 0) {\n    throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n  }\n}\n\nfunction alloc (size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpreted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(size).fill(fill, encoding)\n      : createBuffer(size).fill(fill)\n  }\n  return createBuffer(size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n  assertSize(size)\n  return createBuffer(size < 0 ? 0 : checked(size) | 0)\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(size)\n}\n\nfunction fromString (string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('Unknown encoding: ' + encoding)\n  }\n\n  const length = byteLength(string, encoding) | 0\n  let buf = createBuffer(length)\n\n  const actual = buf.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    buf = buf.slice(0, actual)\n  }\n\n  return buf\n}\n\nfunction fromArrayLike (array) {\n  const length = array.length < 0 ? 0 : checked(array.length) | 0\n  const buf = createBuffer(length)\n  for (let i = 0; i < length; i += 1) {\n    buf[i] = array[i] & 255\n  }\n  return buf\n}\n\nfunction fromArrayView (arrayView) {\n  if (isInstance(arrayView, Uint8Array)) {\n    const copy = new Uint8Array(arrayView)\n    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\n  }\n  return fromArrayLike(arrayView)\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\"offset\" is outside of buffer bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\"length\" is outside of buffer bounds')\n  }\n\n  let buf\n  if (byteOffset === undefined && length === undefined) {\n    buf = new Uint8Array(array)\n  } else if (length === undefined) {\n    buf = new Uint8Array(array, byteOffset)\n  } else {\n    buf = new Uint8Array(array, byteOffset, length)\n  }\n\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(buf, Buffer.prototype)\n\n  return buf\n}\n\nfunction fromObject (obj) {\n  if (Buffer.isBuffer(obj)) {\n    const len = checked(obj.length) | 0\n    const buf = createBuffer(len)\n\n    if (buf.length === 0) {\n      return buf\n    }\n\n    obj.copy(buf, 0, 0, len)\n    return buf\n  }\n\n  if (obj.length !== undefined) {\n    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n      return createBuffer(0)\n    }\n    return fromArrayLike(obj)\n  }\n\n  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n    return fromArrayLike(obj.data)\n  }\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= K_MAX_LENGTH) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return b != null && b._isBuffer === true &&\n    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError(\n      'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n    )\n  }\n\n  if (a === b) return 0\n\n  let x = a.length\n  let y = b.length\n\n  for (let i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!Array.isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  let i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  const buffer = Buffer.allocUnsafe(length)\n  let pos = 0\n  for (i = 0; i < list.length; ++i) {\n    let buf = list[i]\n    if (isInstance(buf, Uint8Array)) {\n      if (pos + buf.length > buffer.length) {\n        if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)\n        buf.copy(buffer, pos)\n      } else {\n        Uint8Array.prototype.set.call(\n          buffer,\n          buf,\n          pos\n        )\n      }\n    } else if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    } else {\n      buf.copy(buffer, pos)\n    }\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    throw new TypeError(\n      'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n      'Received type ' + typeof string\n    )\n  }\n\n  const len = string.length\n  const mustMatch = (arguments.length > 2 && arguments[2] === true)\n  if (!mustMatch && len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  let loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) {\n          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n        }\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  let loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coercion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  const i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  const len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (let i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  const len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (let i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  const len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (let i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  const length = this.length\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.toLocaleString = Buffer.prototype.toString\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  let str = ''\n  const max = exports.INSPECT_MAX_BYTES\n  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n  if (this.length > max) str += ' ... '\n  return '<Buffer ' + str + '>'\n}\nif (customInspectSymbol) {\n  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (isInstance(target, Uint8Array)) {\n    target = Buffer.from(target, target.offset, target.byteLength)\n  }\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError(\n      'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n      'Received type ' + (typeof target)\n    )\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  let x = thisEnd - thisStart\n  let y = end - start\n  const len = Math.min(x, y)\n\n  const thisCopy = this.slice(thisStart, thisEnd)\n  const targetCopy = target.slice(start, end)\n\n  for (let i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset // Coerce to Number.\n  if (numberIsNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  let indexSize = 1\n  let arrLength = arr.length\n  let valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  let i\n  if (dir) {\n    let foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      let found = true\n      for (let j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  const remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  const strLen = string.length\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  let i\n  for (i = 0; i < length; ++i) {\n    const parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (numberIsNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset >>> 0\n    if (isFinite(length)) {\n      length = length >>> 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  const remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  let loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return asciiWrite(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  const res = []\n\n  let i = start\n  while (i < end) {\n    const firstByte = buf[i]\n    let codePoint = null\n    let bytesPerSequence = (firstByte > 0xEF)\n      ? 4\n      : (firstByte > 0xDF)\n          ? 3\n          : (firstByte > 0xBF)\n              ? 2\n              : 1\n\n    if (i + bytesPerSequence <= end) {\n      let secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nconst MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  const len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  let res = ''\n  let i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  let ret = ''\n  end = Math.min(buf.length, end)\n\n  for (let i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  let ret = ''\n  end = Math.min(buf.length, end)\n\n  for (let i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  const len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  let out = ''\n  for (let i = start; i < end; ++i) {\n    out += hexSliceLookupTable[buf[i]]\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  const bytes = buf.slice(start, end)\n  let res = ''\n  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\n  for (let i = 0; i < bytes.length - 1; i += 2) {\n    res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  const len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  const newBuf = this.subarray(start, end)\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(newBuf, Buffer.prototype)\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUintLE =\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  let val = this[offset]\n  let mul = 1\n  let i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUintBE =\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  let val = this[offset + --byteLength]\n  let mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUint8 =\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUint16LE =\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUint16BE =\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUint32LE =\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUint32BE =\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const lo = first +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 24\n\n  const hi = this[++offset] +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    last * 2 ** 24\n\n  return BigInt(lo) + (BigInt(hi) << BigInt(32))\n})\n\nBuffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const hi = first * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    this[++offset]\n\n  const lo = this[++offset] * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    last\n\n  return (BigInt(hi) << BigInt(32)) + BigInt(lo)\n})\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  let val = this[offset]\n  let mul = 1\n  let i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  let i = byteLength\n  let mul = 1\n  let val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  const val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  const val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const val = this[offset + 4] +\n    this[offset + 5] * 2 ** 8 +\n    this[offset + 6] * 2 ** 16 +\n    (last << 24) // Overflow\n\n  return (BigInt(val) << BigInt(32)) +\n    BigInt(first +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 24)\n})\n\nBuffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const val = (first << 24) + // Overflow\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    this[++offset]\n\n  return (BigInt(val) << BigInt(32)) +\n    BigInt(this[++offset] * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    last)\n})\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUintLE =\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  let mul = 1\n  let i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUintBE =\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  let i = byteLength - 1\n  let mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUint8 =\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeUint16LE =\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint16BE =\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint32LE =\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset + 3] = (value >>> 24)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 1] = (value >>> 8)\n  this[offset] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeUint32BE =\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nfunction wrtBigUInt64LE (buf, value, offset, min, max) {\n  checkIntBI(value, min, max, buf, offset, 7)\n\n  let lo = Number(value & BigInt(0xffffffff))\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  return offset\n}\n\nfunction wrtBigUInt64BE (buf, value, offset, min, max) {\n  checkIntBI(value, min, max, buf, offset, 7)\n\n  let lo = Number(value & BigInt(0xffffffff))\n  buf[offset + 7] = lo\n  lo = lo >> 8\n  buf[offset + 6] = lo\n  lo = lo >> 8\n  buf[offset + 5] = lo\n  lo = lo >> 8\n  buf[offset + 4] = lo\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n  buf[offset + 3] = hi\n  hi = hi >> 8\n  buf[offset + 2] = hi\n  hi = hi >> 8\n  buf[offset + 1] = hi\n  hi = hi >> 8\n  buf[offset] = hi\n  return offset + 8\n}\n\nBuffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE (value, offset = 0) {\n  return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE (value, offset = 0) {\n  return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    const limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  let i = 0\n  let mul = 1\n  let sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    const limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  let i = byteLength - 1\n  let mul = 1\n  let sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 3] = (value >>> 24)\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE (value, offset = 0) {\n  return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nBuffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE (value, offset = 0) {\n  return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('Index out of range')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  const len = end - start\n\n  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n    // Use built-in when available, missing from IE11\n    this.copyWithin(targetStart, start, end)\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, end),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n    if (val.length === 1) {\n      const code = val.charCodeAt(0)\n      if ((encoding === 'utf8' && code < 128) ||\n          encoding === 'latin1') {\n        // Fast path: If `val` fits into a single byte, use that numeric value.\n        val = code\n      }\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  } else if (typeof val === 'boolean') {\n    val = Number(val)\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  let i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    const bytes = Buffer.isBuffer(val)\n      ? val\n      : Buffer.from(val, encoding)\n    const len = bytes.length\n    if (len === 0) {\n      throw new TypeError('The value \"' + val +\n        '\" is invalid for argument \"value\"')\n    }\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// CUSTOM ERRORS\n// =============\n\n// Simplified versions from Node, changed for Buffer-only usage\nconst errors = {}\nfunction E (sym, getMessage, Base) {\n  errors[sym] = class NodeError extends Base {\n    constructor () {\n      super()\n\n      Object.defineProperty(this, 'message', {\n        value: getMessage.apply(this, arguments),\n        writable: true,\n        configurable: true\n      })\n\n      // Add the error code to the name to include it in the stack trace.\n      this.name = `${this.name} [${sym}]`\n      // Access the stack to generate the error message including the error code\n      // from the name.\n      this.stack // eslint-disable-line no-unused-expressions\n      // Reset the name to the actual name.\n      delete this.name\n    }\n\n    get code () {\n      return sym\n    }\n\n    set code (value) {\n      Object.defineProperty(this, 'code', {\n        configurable: true,\n        enumerable: true,\n        value,\n        writable: true\n      })\n    }\n\n    toString () {\n      return `${this.name} [${sym}]: ${this.message}`\n    }\n  }\n}\n\nE('ERR_BUFFER_OUT_OF_BOUNDS',\n  function (name) {\n    if (name) {\n      return `${name} is outside of buffer bounds`\n    }\n\n    return 'Attempt to access memory outside buffer bounds'\n  }, RangeError)\nE('ERR_INVALID_ARG_TYPE',\n  function (name, actual) {\n    return `The \"${name}\" argument must be of type number. Received type ${typeof actual}`\n  }, TypeError)\nE('ERR_OUT_OF_RANGE',\n  function (str, range, input) {\n    let msg = `The value of \"${str}\" is out of range.`\n    let received = input\n    if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\n      received = addNumericalSeparator(String(input))\n    } else if (typeof input === 'bigint') {\n      received = String(input)\n      if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {\n        received = addNumericalSeparator(received)\n      }\n      received += 'n'\n    }\n    msg += ` It must be ${range}. Received ${received}`\n    return msg\n  }, RangeError)\n\nfunction addNumericalSeparator (val) {\n  let res = ''\n  let i = val.length\n  const start = val[0] === '-' ? 1 : 0\n  for (; i >= start + 4; i -= 3) {\n    res = `_${val.slice(i - 3, i)}${res}`\n  }\n  return `${val.slice(0, i)}${res}`\n}\n\n// CHECK FUNCTIONS\n// ===============\n\nfunction checkBounds (buf, offset, byteLength) {\n  validateNumber(offset, 'offset')\n  if (buf[offset] === undefined || buf[offset + byteLength] === undefined) {\n    boundsError(offset, buf.length - (byteLength + 1))\n  }\n}\n\nfunction checkIntBI (value, min, max, buf, offset, byteLength) {\n  if (value > max || value < min) {\n    const n = typeof min === 'bigint' ? 'n' : ''\n    let range\n    if (byteLength > 3) {\n      if (min === 0 || min === BigInt(0)) {\n        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`\n      } else {\n        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +\n                `${(byteLength + 1) * 8 - 1}${n}`\n      }\n    } else {\n      range = `>= ${min}${n} and <= ${max}${n}`\n    }\n    throw new errors.ERR_OUT_OF_RANGE('value', range, value)\n  }\n  checkBounds(buf, offset, byteLength)\n}\n\nfunction validateNumber (value, name) {\n  if (typeof value !== 'number') {\n    throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value)\n  }\n}\n\nfunction boundsError (value, length, type) {\n  if (Math.floor(value) !== value) {\n    validateNumber(value, type)\n    throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)\n  }\n\n  if (length < 0) {\n    throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()\n  }\n\n  throw new errors.ERR_OUT_OF_RANGE(type || 'offset',\n                                    `>= ${type ? 1 : 0} and <= ${length}`,\n                                    value)\n}\n\n// HELPER FUNCTIONS\n// ================\n\nconst INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node takes equal signs as end of the Base64 encoding\n  str = str.split('=')[0]\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = str.trim().replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  let codePoint\n  const length = string.length\n  let leadSurrogate = null\n  const bytes = []\n\n  for (let i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  const byteArray = []\n  for (let i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  let c, hi, lo\n  const byteArray = []\n  for (let i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  let i\n  for (i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n  return obj instanceof type ||\n    (obj != null && obj.constructor != null && obj.constructor.name != null &&\n      obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n  // For IE11 support\n  return obj !== obj // eslint-disable-line no-self-compare\n}\n\n// Create lookup table for `toString('hex')`\n// See: https://github.com/feross/buffer/issues/219\nconst hexSliceLookupTable = (function () {\n  const alphabet = '0123456789abcdef'\n  const table = new Array(256)\n  for (let i = 0; i < 16; ++i) {\n    const i16 = i * 16\n    for (let j = 0; j < 16; ++j) {\n      table[i16 + j] = alphabet[i] + alphabet[j]\n    }\n  }\n  return table\n})()\n\n// Return not function with Error if BigInt not supported\nfunction defineBigIntMethod (fn) {\n  return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn\n}\n\nfunction BufferBigIntNotDefined () {\n  throw new Error('BigInt not supported')\n}\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar callBind = require('./');\n\nvar $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));\n\nmodule.exports = function callBoundIntrinsic(name, allowMissing) {\n\tvar intrinsic = GetIntrinsic(name, !!allowMissing);\n\tif (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {\n\t\treturn callBind(intrinsic);\n\t}\n\treturn intrinsic;\n};\n","'use strict';\n\nvar bind = require('function-bind');\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $apply = GetIntrinsic('%Function.prototype.apply%');\nvar $call = GetIntrinsic('%Function.prototype.call%');\nvar $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply);\n\nvar $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);\nvar $defineProperty = GetIntrinsic('%Object.defineProperty%', true);\nvar $max = GetIntrinsic('%Math.max%');\n\nif ($defineProperty) {\n\ttry {\n\t\t$defineProperty({}, 'a', { value: 1 });\n\t} catch (e) {\n\t\t// IE 8 has a broken defineProperty\n\t\t$defineProperty = null;\n\t}\n}\n\nmodule.exports = function callBind(originalFunction) {\n\tvar func = $reflectApply(bind, $call, arguments);\n\tif ($gOPD && $defineProperty) {\n\t\tvar desc = $gOPD(func, 'length');\n\t\tif (desc.configurable) {\n\t\t\t// original length, plus the receiver, minus any additional arguments (after the receiver)\n\t\t\t$defineProperty(\n\t\t\t\tfunc,\n\t\t\t\t'length',\n\t\t\t\t{ value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }\n\t\t\t);\n\t\t}\n\t}\n\treturn func;\n};\n\nvar applyBind = function applyBind() {\n\treturn $reflectApply(bind, $apply, arguments);\n};\n\nif ($defineProperty) {\n\t$defineProperty(module.exports, 'apply', { value: applyBind });\n} else {\n\tmodule.exports.apply = applyBind;\n}\n","/*global window, global*/\nvar util = require(\"util\")\nvar assert = require(\"assert\")\nfunction now() { return new Date().getTime() }\n\nvar slice = Array.prototype.slice\nvar console\nvar times = {}\n\nif (typeof global !== \"undefined\" && global.console) {\n    console = global.console\n} else if (typeof window !== \"undefined\" && window.console) {\n    console = window.console\n} else {\n    console = {}\n}\n\nvar functions = [\n    [log, \"log\"],\n    [info, \"info\"],\n    [warn, \"warn\"],\n    [error, \"error\"],\n    [time, \"time\"],\n    [timeEnd, \"timeEnd\"],\n    [trace, \"trace\"],\n    [dir, \"dir\"],\n    [consoleAssert, \"assert\"]\n]\n\nfor (var i = 0; i < functions.length; i++) {\n    var tuple = functions[i]\n    var f = tuple[0]\n    var name = tuple[1]\n\n    if (!console[name]) {\n        console[name] = f\n    }\n}\n\nmodule.exports = console\n\nfunction log() {}\n\nfunction info() {\n    console.log.apply(console, arguments)\n}\n\nfunction warn() {\n    console.log.apply(console, arguments)\n}\n\nfunction error() {\n    console.warn.apply(console, arguments)\n}\n\nfunction time(label) {\n    times[label] = now()\n}\n\nfunction timeEnd(label) {\n    var time = times[label]\n    if (!time) {\n        throw new Error(\"No such label: \" + label)\n    }\n\n    delete times[label]\n    var duration = now() - time\n    console.log(label + \": \" + duration + \"ms\")\n}\n\nfunction trace() {\n    var err = new Error()\n    err.name = \"Trace\"\n    err.message = util.format.apply(null, arguments)\n    console.error(err.stack)\n}\n\nfunction dir(object) {\n    console.log(util.inspect(object) + \"\\n\")\n}\n\nfunction consoleAssert(expression) {\n    if (!expression) {\n        var arr = slice.call(arguments, 1)\n        assert.ok(false, util.format.apply(null, arr))\n    }\n}\n","var global = typeof self !== 'undefined' ? self : this;\nvar __self__ = (function () {\nfunction F() {\nthis.fetch = false;\nthis.DOMException = global.DOMException\n}\nF.prototype = global;\nreturn new F();\n})();\n(function(self) {\n\nvar irrelevant = (function (exports) {\n\n  var support = {\n    searchParams: 'URLSearchParams' in self,\n    iterable: 'Symbol' in self && 'iterator' in Symbol,\n    blob:\n      'FileReader' in self &&\n      'Blob' in self &&\n      (function() {\n        try {\n          new Blob();\n          return true\n        } catch (e) {\n          return false\n        }\n      })(),\n    formData: 'FormData' in self,\n    arrayBuffer: 'ArrayBuffer' in self\n  };\n\n  function isDataView(obj) {\n    return obj && DataView.prototype.isPrototypeOf(obj)\n  }\n\n  if (support.arrayBuffer) {\n    var viewClasses = [\n      '[object Int8Array]',\n      '[object Uint8Array]',\n      '[object Uint8ClampedArray]',\n      '[object Int16Array]',\n      '[object Uint16Array]',\n      '[object Int32Array]',\n      '[object Uint32Array]',\n      '[object Float32Array]',\n      '[object Float64Array]'\n    ];\n\n    var isArrayBufferView =\n      ArrayBuffer.isView ||\n      function(obj) {\n        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1\n      };\n  }\n\n  function normalizeName(name) {\n    if (typeof name !== 'string') {\n      name = String(name);\n    }\n    if (/[^a-z0-9\\-#$%&'*+.^_`|~]/i.test(name)) {\n      throw new TypeError('Invalid character in header field name')\n    }\n    return name.toLowerCase()\n  }\n\n  function normalizeValue(value) {\n    if (typeof value !== 'string') {\n      value = String(value);\n    }\n    return value\n  }\n\n  // Build a destructive iterator for the value list\n  function iteratorFor(items) {\n    var iterator = {\n      next: function() {\n        var value = items.shift();\n        return {done: value === undefined, value: value}\n      }\n    };\n\n    if (support.iterable) {\n      iterator[Symbol.iterator] = function() {\n        return iterator\n      };\n    }\n\n    return iterator\n  }\n\n  function Headers(headers) {\n    this.map = {};\n\n    if (headers instanceof Headers) {\n      headers.forEach(function(value, name) {\n        this.append(name, value);\n      }, this);\n    } else if (Array.isArray(headers)) {\n      headers.forEach(function(header) {\n        this.append(header[0], header[1]);\n      }, this);\n    } else if (headers) {\n      Object.getOwnPropertyNames(headers).forEach(function(name) {\n        this.append(name, headers[name]);\n      }, this);\n    }\n  }\n\n  Headers.prototype.append = function(name, value) {\n    name = normalizeName(name);\n    value = normalizeValue(value);\n    var oldValue = this.map[name];\n    this.map[name] = oldValue ? oldValue + ', ' + value : value;\n  };\n\n  Headers.prototype['delete'] = function(name) {\n    delete this.map[normalizeName(name)];\n  };\n\n  Headers.prototype.get = function(name) {\n    name = normalizeName(name);\n    return this.has(name) ? this.map[name] : null\n  };\n\n  Headers.prototype.has = function(name) {\n    return this.map.hasOwnProperty(normalizeName(name))\n  };\n\n  Headers.prototype.set = function(name, value) {\n    this.map[normalizeName(name)] = normalizeValue(value);\n  };\n\n  Headers.prototype.forEach = function(callback, thisArg) {\n    for (var name in this.map) {\n      if (this.map.hasOwnProperty(name)) {\n        callback.call(thisArg, this.map[name], name, this);\n      }\n    }\n  };\n\n  Headers.prototype.keys = function() {\n    var items = [];\n    this.forEach(function(value, name) {\n      items.push(name);\n    });\n    return iteratorFor(items)\n  };\n\n  Headers.prototype.values = function() {\n    var items = [];\n    this.forEach(function(value) {\n      items.push(value);\n    });\n    return iteratorFor(items)\n  };\n\n  Headers.prototype.entries = function() {\n    var items = [];\n    this.forEach(function(value, name) {\n      items.push([name, value]);\n    });\n    return iteratorFor(items)\n  };\n\n  if (support.iterable) {\n    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;\n  }\n\n  function consumed(body) {\n    if (body.bodyUsed) {\n      return Promise.reject(new TypeError('Already read'))\n    }\n    body.bodyUsed = true;\n  }\n\n  function fileReaderReady(reader) {\n    return new Promise(function(resolve, reject) {\n      reader.onload = function() {\n        resolve(reader.result);\n      };\n      reader.onerror = function() {\n        reject(reader.error);\n      };\n    })\n  }\n\n  function readBlobAsArrayBuffer(blob) {\n    var reader = new FileReader();\n    var promise = fileReaderReady(reader);\n    reader.readAsArrayBuffer(blob);\n    return promise\n  }\n\n  function readBlobAsText(blob) {\n    var reader = new FileReader();\n    var promise = fileReaderReady(reader);\n    reader.readAsText(blob);\n    return promise\n  }\n\n  function readArrayBufferAsText(buf) {\n    var view = new Uint8Array(buf);\n    var chars = new Array(view.length);\n\n    for (var i = 0; i < view.length; i++) {\n      chars[i] = String.fromCharCode(view[i]);\n    }\n    return chars.join('')\n  }\n\n  function bufferClone(buf) {\n    if (buf.slice) {\n      return buf.slice(0)\n    } else {\n      var view = new Uint8Array(buf.byteLength);\n      view.set(new Uint8Array(buf));\n      return view.buffer\n    }\n  }\n\n  function Body() {\n    this.bodyUsed = false;\n\n    this._initBody = function(body) {\n      this._bodyInit = body;\n      if (!body) {\n        this._bodyText = '';\n      } else if (typeof body === 'string') {\n        this._bodyText = body;\n      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {\n        this._bodyBlob = body;\n      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {\n        this._bodyFormData = body;\n      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n        this._bodyText = body.toString();\n      } else if (support.arrayBuffer && support.blob && isDataView(body)) {\n        this._bodyArrayBuffer = bufferClone(body.buffer);\n        // IE 10-11 can't handle a DataView body.\n        this._bodyInit = new Blob([this._bodyArrayBuffer]);\n      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {\n        this._bodyArrayBuffer = bufferClone(body);\n      } else {\n        this._bodyText = body = Object.prototype.toString.call(body);\n      }\n\n      if (!this.headers.get('content-type')) {\n        if (typeof body === 'string') {\n          this.headers.set('content-type', 'text/plain;charset=UTF-8');\n        } else if (this._bodyBlob && this._bodyBlob.type) {\n          this.headers.set('content-type', this._bodyBlob.type);\n        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');\n        }\n      }\n    };\n\n    if (support.blob) {\n      this.blob = function() {\n        var rejected = consumed(this);\n        if (rejected) {\n          return rejected\n        }\n\n        if (this._bodyBlob) {\n          return Promise.resolve(this._bodyBlob)\n        } else if (this._bodyArrayBuffer) {\n          return Promise.resolve(new Blob([this._bodyArrayBuffer]))\n        } else if (this._bodyFormData) {\n          throw new Error('could not read FormData body as blob')\n        } else {\n          return Promise.resolve(new Blob([this._bodyText]))\n        }\n      };\n\n      this.arrayBuffer = function() {\n        if (this._bodyArrayBuffer) {\n          return consumed(this) || Promise.resolve(this._bodyArrayBuffer)\n        } else {\n          return this.blob().then(readBlobAsArrayBuffer)\n        }\n      };\n    }\n\n    this.text = function() {\n      var rejected = consumed(this);\n      if (rejected) {\n        return rejected\n      }\n\n      if (this._bodyBlob) {\n        return readBlobAsText(this._bodyBlob)\n      } else if (this._bodyArrayBuffer) {\n        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))\n      } else if (this._bodyFormData) {\n        throw new Error('could not read FormData body as text')\n      } else {\n        return Promise.resolve(this._bodyText)\n      }\n    };\n\n    if (support.formData) {\n      this.formData = function() {\n        return this.text().then(decode)\n      };\n    }\n\n    this.json = function() {\n      return this.text().then(JSON.parse)\n    };\n\n    return this\n  }\n\n  // HTTP methods whose capitalization should be normalized\n  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];\n\n  function normalizeMethod(method) {\n    var upcased = method.toUpperCase();\n    return methods.indexOf(upcased) > -1 ? upcased : method\n  }\n\n  function Request(input, options) {\n    options = options || {};\n    var body = options.body;\n\n    if (input instanceof Request) {\n      if (input.bodyUsed) {\n        throw new TypeError('Already read')\n      }\n      this.url = input.url;\n      this.credentials = input.credentials;\n      if (!options.headers) {\n        this.headers = new Headers(input.headers);\n      }\n      this.method = input.method;\n      this.mode = input.mode;\n      this.signal = input.signal;\n      if (!body && input._bodyInit != null) {\n        body = input._bodyInit;\n        input.bodyUsed = true;\n      }\n    } else {\n      this.url = String(input);\n    }\n\n    this.credentials = options.credentials || this.credentials || 'same-origin';\n    if (options.headers || !this.headers) {\n      this.headers = new Headers(options.headers);\n    }\n    this.method = normalizeMethod(options.method || this.method || 'GET');\n    this.mode = options.mode || this.mode || null;\n    this.signal = options.signal || this.signal;\n    this.referrer = null;\n\n    if ((this.method === 'GET' || this.method === 'HEAD') && body) {\n      throw new TypeError('Body not allowed for GET or HEAD requests')\n    }\n    this._initBody(body);\n  }\n\n  Request.prototype.clone = function() {\n    return new Request(this, {body: this._bodyInit})\n  };\n\n  function decode(body) {\n    var form = new FormData();\n    body\n      .trim()\n      .split('&')\n      .forEach(function(bytes) {\n        if (bytes) {\n          var split = bytes.split('=');\n          var name = split.shift().replace(/\\+/g, ' ');\n          var value = split.join('=').replace(/\\+/g, ' ');\n          form.append(decodeURIComponent(name), decodeURIComponent(value));\n        }\n      });\n    return form\n  }\n\n  function parseHeaders(rawHeaders) {\n    var headers = new Headers();\n    // Replace instances of \\r\\n and \\n followed by at least one space or horizontal tab with a space\n    // https://tools.ietf.org/html/rfc7230#section-3.2\n    var preProcessedHeaders = rawHeaders.replace(/\\r?\\n[\\t ]+/g, ' ');\n    preProcessedHeaders.split(/\\r?\\n/).forEach(function(line) {\n      var parts = line.split(':');\n      var key = parts.shift().trim();\n      if (key) {\n        var value = parts.join(':').trim();\n        headers.append(key, value);\n      }\n    });\n    return headers\n  }\n\n  Body.call(Request.prototype);\n\n  function Response(bodyInit, options) {\n    if (!options) {\n      options = {};\n    }\n\n    this.type = 'default';\n    this.status = options.status === undefined ? 200 : options.status;\n    this.ok = this.status >= 200 && this.status < 300;\n    this.statusText = 'statusText' in options ? options.statusText : 'OK';\n    this.headers = new Headers(options.headers);\n    this.url = options.url || '';\n    this._initBody(bodyInit);\n  }\n\n  Body.call(Response.prototype);\n\n  Response.prototype.clone = function() {\n    return new Response(this._bodyInit, {\n      status: this.status,\n      statusText: this.statusText,\n      headers: new Headers(this.headers),\n      url: this.url\n    })\n  };\n\n  Response.error = function() {\n    var response = new Response(null, {status: 0, statusText: ''});\n    response.type = 'error';\n    return response\n  };\n\n  var redirectStatuses = [301, 302, 303, 307, 308];\n\n  Response.redirect = function(url, status) {\n    if (redirectStatuses.indexOf(status) === -1) {\n      throw new RangeError('Invalid status code')\n    }\n\n    return new Response(null, {status: status, headers: {location: url}})\n  };\n\n  exports.DOMException = self.DOMException;\n  try {\n    new exports.DOMException();\n  } catch (err) {\n    exports.DOMException = function(message, name) {\n      this.message = message;\n      this.name = name;\n      var error = Error(message);\n      this.stack = error.stack;\n    };\n    exports.DOMException.prototype = Object.create(Error.prototype);\n    exports.DOMException.prototype.constructor = exports.DOMException;\n  }\n\n  function fetch(input, init) {\n    return new Promise(function(resolve, reject) {\n      var request = new Request(input, init);\n\n      if (request.signal && request.signal.aborted) {\n        return reject(new exports.DOMException('Aborted', 'AbortError'))\n      }\n\n      var xhr = new XMLHttpRequest();\n\n      function abortXhr() {\n        xhr.abort();\n      }\n\n      xhr.onload = function() {\n        var options = {\n          status: xhr.status,\n          statusText: xhr.statusText,\n          headers: parseHeaders(xhr.getAllResponseHeaders() || '')\n        };\n        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');\n        var body = 'response' in xhr ? xhr.response : xhr.responseText;\n        resolve(new Response(body, options));\n      };\n\n      xhr.onerror = function() {\n        reject(new TypeError('Network request failed'));\n      };\n\n      xhr.ontimeout = function() {\n        reject(new TypeError('Network request failed'));\n      };\n\n      xhr.onabort = function() {\n        reject(new exports.DOMException('Aborted', 'AbortError'));\n      };\n\n      xhr.open(request.method, request.url, true);\n\n      if (request.credentials === 'include') {\n        xhr.withCredentials = true;\n      } else if (request.credentials === 'omit') {\n        xhr.withCredentials = false;\n      }\n\n      if ('responseType' in xhr && support.blob) {\n        xhr.responseType = 'blob';\n      }\n\n      request.headers.forEach(function(value, name) {\n        xhr.setRequestHeader(name, value);\n      });\n\n      if (request.signal) {\n        request.signal.addEventListener('abort', abortXhr);\n\n        xhr.onreadystatechange = function() {\n          // DONE (success or failure)\n          if (xhr.readyState === 4) {\n            request.signal.removeEventListener('abort', abortXhr);\n          }\n        };\n      }\n\n      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);\n    })\n  }\n\n  fetch.polyfill = true;\n\n  if (!self.fetch) {\n    self.fetch = fetch;\n    self.Headers = Headers;\n    self.Request = Request;\n    self.Response = Response;\n  }\n\n  exports.Headers = Headers;\n  exports.Request = Request;\n  exports.Response = Response;\n  exports.fetch = fetch;\n\n  Object.defineProperty(exports, '__esModule', { value: true });\n\n  return exports;\n\n})({});\n})(__self__);\n__self__.fetch.ponyfill = true;\n// Remove \"polyfill\" property added by whatwg-fetch\ndelete __self__.fetch.polyfill;\n// Choose between native implementation (global) or custom implementation (__self__)\n// var ctx = global.fetch ? global : __self__;\nvar ctx = __self__; // this line disable service worker support temporarily\nexports = ctx.fetch // To enable: import fetch from 'cross-fetch'\nexports.default = ctx.fetch // For TypeScript consumers without esModuleInterop.\nexports.fetch = ctx.fetch // To enable: import {fetch} from 'cross-fetch'\nexports.Headers = ctx.Headers\nexports.Request = ctx.Request\nexports.Response = ctx.Response\nmodule.exports = exports\n","'use strict';\n\nvar keys = require('object-keys');\nvar hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';\n\nvar toStr = Object.prototype.toString;\nvar concat = Array.prototype.concat;\nvar origDefineProperty = Object.defineProperty;\n\nvar isFunction = function (fn) {\n\treturn typeof fn === 'function' && toStr.call(fn) === '[object Function]';\n};\n\nvar hasPropertyDescriptors = require('has-property-descriptors')();\n\nvar supportsDescriptors = origDefineProperty && hasPropertyDescriptors;\n\nvar defineProperty = function (object, name, value, predicate) {\n\tif (name in object && (!isFunction(predicate) || !predicate())) {\n\t\treturn;\n\t}\n\tif (supportsDescriptors) {\n\t\torigDefineProperty(object, name, {\n\t\t\tconfigurable: true,\n\t\t\tenumerable: false,\n\t\t\tvalue: value,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\tobject[name] = value; // eslint-disable-line no-param-reassign\n\t}\n};\n\nvar defineProperties = function (object, map) {\n\tvar predicates = arguments.length > 2 ? arguments[2] : {};\n\tvar props = keys(map);\n\tif (hasSymbols) {\n\t\tprops = concat.call(props, Object.getOwnPropertySymbols(map));\n\t}\n\tfor (var i = 0; i < props.length; i += 1) {\n\t\tdefineProperty(object, props[i], map[props[i]], predicates[props[i]]);\n\t}\n};\n\ndefineProperties.supportsDescriptors = !!supportsDescriptors;\n\nmodule.exports = defineProperties;\n","/**\n * Code refactored from Mozilla Developer Network:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\n */\n\n'use strict';\n\nfunction assign(target, firstSource) {\n  if (target === undefined || target === null) {\n    throw new TypeError('Cannot convert first argument to object');\n  }\n\n  var to = Object(target);\n  for (var i = 1; i < arguments.length; i++) {\n    var nextSource = arguments[i];\n    if (nextSource === undefined || nextSource === null) {\n      continue;\n    }\n\n    var keysArray = Object.keys(Object(nextSource));\n    for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {\n      var nextKey = keysArray[nextIndex];\n      var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);\n      if (desc !== undefined && desc.enumerable) {\n        to[nextKey] = nextSource[nextKey];\n      }\n    }\n  }\n  return to;\n}\n\nfunction polyfill() {\n  if (!Object.assign) {\n    Object.defineProperty(Object, 'assign', {\n      enumerable: false,\n      configurable: true,\n      writable: true,\n      value: assign\n    });\n  }\n}\n\nmodule.exports = {\n  assign: assign,\n  polyfill: polyfill\n};\n","'use strict';\n\nvar isCallable = require('is-callable');\n\nvar toStr = Object.prototype.toString;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar forEachArray = function forEachArray(array, iterator, receiver) {\n    for (var i = 0, len = array.length; i < len; i++) {\n        if (hasOwnProperty.call(array, i)) {\n            if (receiver == null) {\n                iterator(array[i], i, array);\n            } else {\n                iterator.call(receiver, array[i], i, array);\n            }\n        }\n    }\n};\n\nvar forEachString = function forEachString(string, iterator, receiver) {\n    for (var i = 0, len = string.length; i < len; i++) {\n        // no such thing as a sparse string.\n        if (receiver == null) {\n            iterator(string.charAt(i), i, string);\n        } else {\n            iterator.call(receiver, string.charAt(i), i, string);\n        }\n    }\n};\n\nvar forEachObject = function forEachObject(object, iterator, receiver) {\n    for (var k in object) {\n        if (hasOwnProperty.call(object, k)) {\n            if (receiver == null) {\n                iterator(object[k], k, object);\n            } else {\n                iterator.call(receiver, object[k], k, object);\n            }\n        }\n    }\n};\n\nvar forEach = function forEach(list, iterator, thisArg) {\n    if (!isCallable(iterator)) {\n        throw new TypeError('iterator must be a function');\n    }\n\n    var receiver;\n    if (arguments.length >= 3) {\n        receiver = thisArg;\n    }\n\n    if (toStr.call(list) === '[object Array]') {\n        forEachArray(list, iterator, receiver);\n    } else if (typeof list === 'string') {\n        forEachString(list, iterator, receiver);\n    } else {\n        forEachObject(list, iterator, receiver);\n    }\n};\n\nmodule.exports = forEach;\n","'use strict';\n\n/* eslint no-invalid-this: 1 */\n\nvar ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';\nvar slice = Array.prototype.slice;\nvar toStr = Object.prototype.toString;\nvar funcType = '[object Function]';\n\nmodule.exports = function bind(that) {\n    var target = this;\n    if (typeof target !== 'function' || toStr.call(target) !== funcType) {\n        throw new TypeError(ERROR_MESSAGE + target);\n    }\n    var args = slice.call(arguments, 1);\n\n    var bound;\n    var binder = function () {\n        if (this instanceof bound) {\n            var result = target.apply(\n                this,\n                args.concat(slice.call(arguments))\n            );\n            if (Object(result) === result) {\n                return result;\n            }\n            return this;\n        } else {\n            return target.apply(\n                that,\n                args.concat(slice.call(arguments))\n            );\n        }\n    };\n\n    var boundLength = Math.max(0, target.length - args.length);\n    var boundArgs = [];\n    for (var i = 0; i < boundLength; i++) {\n        boundArgs.push('$' + i);\n    }\n\n    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);\n\n    if (target.prototype) {\n        var Empty = function Empty() {};\n        Empty.prototype = target.prototype;\n        bound.prototype = new Empty();\n        Empty.prototype = null;\n    }\n\n    return bound;\n};\n","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = Function.prototype.bind || implementation;\n","'use strict';\n\nvar undefined;\n\nvar $SyntaxError = SyntaxError;\nvar $Function = Function;\nvar $TypeError = TypeError;\n\n// eslint-disable-next-line consistent-return\nvar getEvalledConstructor = function (expressionSyntax) {\n\ttry {\n\t\treturn $Function('\"use strict\"; return (' + expressionSyntax + ').constructor;')();\n\t} catch (e) {}\n};\n\nvar $gOPD = Object.getOwnPropertyDescriptor;\nif ($gOPD) {\n\ttry {\n\t\t$gOPD({}, '');\n\t} catch (e) {\n\t\t$gOPD = null; // this is IE 8, which has a broken gOPD\n\t}\n}\n\nvar throwTypeError = function () {\n\tthrow new $TypeError();\n};\nvar ThrowTypeError = $gOPD\n\t? (function () {\n\t\ttry {\n\t\t\t// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties\n\t\t\targuments.callee; // IE 8 does not throw here\n\t\t\treturn throwTypeError;\n\t\t} catch (calleeThrows) {\n\t\t\ttry {\n\t\t\t\t// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')\n\t\t\t\treturn $gOPD(arguments, 'callee').get;\n\t\t\t} catch (gOPDthrows) {\n\t\t\t\treturn throwTypeError;\n\t\t\t}\n\t\t}\n\t}())\n\t: throwTypeError;\n\nvar hasSymbols = require('has-symbols')();\n\nvar getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto\n\nvar needsEval = {};\n\nvar TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);\n\nvar INTRINSICS = {\n\t'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,\n\t'%Array%': Array,\n\t'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,\n\t'%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,\n\t'%AsyncFromSyncIteratorPrototype%': undefined,\n\t'%AsyncFunction%': needsEval,\n\t'%AsyncGenerator%': needsEval,\n\t'%AsyncGeneratorFunction%': needsEval,\n\t'%AsyncIteratorPrototype%': needsEval,\n\t'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,\n\t'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,\n\t'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined : BigInt64Array,\n\t'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined : BigUint64Array,\n\t'%Boolean%': Boolean,\n\t'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,\n\t'%Date%': Date,\n\t'%decodeURI%': decodeURI,\n\t'%decodeURIComponent%': decodeURIComponent,\n\t'%encodeURI%': encodeURI,\n\t'%encodeURIComponent%': encodeURIComponent,\n\t'%Error%': Error,\n\t'%eval%': eval, // eslint-disable-line no-eval\n\t'%EvalError%': EvalError,\n\t'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,\n\t'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,\n\t'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,\n\t'%Function%': $Function,\n\t'%GeneratorFunction%': needsEval,\n\t'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,\n\t'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,\n\t'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,\n\t'%isFinite%': isFinite,\n\t'%isNaN%': isNaN,\n\t'%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,\n\t'%JSON%': typeof JSON === 'object' ? JSON : undefined,\n\t'%Map%': typeof Map === 'undefined' ? undefined : Map,\n\t'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),\n\t'%Math%': Math,\n\t'%Number%': Number,\n\t'%Object%': Object,\n\t'%parseFloat%': parseFloat,\n\t'%parseInt%': parseInt,\n\t'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,\n\t'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,\n\t'%RangeError%': RangeError,\n\t'%ReferenceError%': ReferenceError,\n\t'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,\n\t'%RegExp%': RegExp,\n\t'%Set%': typeof Set === 'undefined' ? undefined : Set,\n\t'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),\n\t'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,\n\t'%String%': String,\n\t'%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,\n\t'%Symbol%': hasSymbols ? Symbol : undefined,\n\t'%SyntaxError%': $SyntaxError,\n\t'%ThrowTypeError%': ThrowTypeError,\n\t'%TypedArray%': TypedArray,\n\t'%TypeError%': $TypeError,\n\t'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,\n\t'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,\n\t'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,\n\t'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,\n\t'%URIError%': URIError,\n\t'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,\n\t'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,\n\t'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet\n};\n\ntry {\n\tnull.error; // eslint-disable-line no-unused-expressions\n} catch (e) {\n\t// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229\n\tvar errorProto = getProto(getProto(e));\n\tINTRINSICS['%Error.prototype%'] = errorProto;\n}\n\nvar doEval = function doEval(name) {\n\tvar value;\n\tif (name === '%AsyncFunction%') {\n\t\tvalue = getEvalledConstructor('async function () {}');\n\t} else if (name === '%GeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('function* () {}');\n\t} else if (name === '%AsyncGeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('async function* () {}');\n\t} else if (name === '%AsyncGenerator%') {\n\t\tvar fn = doEval('%AsyncGeneratorFunction%');\n\t\tif (fn) {\n\t\t\tvalue = fn.prototype;\n\t\t}\n\t} else if (name === '%AsyncIteratorPrototype%') {\n\t\tvar gen = doEval('%AsyncGenerator%');\n\t\tif (gen) {\n\t\t\tvalue = getProto(gen.prototype);\n\t\t}\n\t}\n\n\tINTRINSICS[name] = value;\n\n\treturn value;\n};\n\nvar LEGACY_ALIASES = {\n\t'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],\n\t'%ArrayPrototype%': ['Array', 'prototype'],\n\t'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],\n\t'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],\n\t'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],\n\t'%ArrayProto_values%': ['Array', 'prototype', 'values'],\n\t'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],\n\t'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],\n\t'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],\n\t'%BooleanPrototype%': ['Boolean', 'prototype'],\n\t'%DataViewPrototype%': ['DataView', 'prototype'],\n\t'%DatePrototype%': ['Date', 'prototype'],\n\t'%ErrorPrototype%': ['Error', 'prototype'],\n\t'%EvalErrorPrototype%': ['EvalError', 'prototype'],\n\t'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],\n\t'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],\n\t'%FunctionPrototype%': ['Function', 'prototype'],\n\t'%Generator%': ['GeneratorFunction', 'prototype'],\n\t'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],\n\t'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],\n\t'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],\n\t'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],\n\t'%JSONParse%': ['JSON', 'parse'],\n\t'%JSONStringify%': ['JSON', 'stringify'],\n\t'%MapPrototype%': ['Map', 'prototype'],\n\t'%NumberPrototype%': ['Number', 'prototype'],\n\t'%ObjectPrototype%': ['Object', 'prototype'],\n\t'%ObjProto_toString%': ['Object', 'prototype', 'toString'],\n\t'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],\n\t'%PromisePrototype%': ['Promise', 'prototype'],\n\t'%PromiseProto_then%': ['Promise', 'prototype', 'then'],\n\t'%Promise_all%': ['Promise', 'all'],\n\t'%Promise_reject%': ['Promise', 'reject'],\n\t'%Promise_resolve%': ['Promise', 'resolve'],\n\t'%RangeErrorPrototype%': ['RangeError', 'prototype'],\n\t'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],\n\t'%RegExpPrototype%': ['RegExp', 'prototype'],\n\t'%SetPrototype%': ['Set', 'prototype'],\n\t'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],\n\t'%StringPrototype%': ['String', 'prototype'],\n\t'%SymbolPrototype%': ['Symbol', 'prototype'],\n\t'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],\n\t'%TypedArrayPrototype%': ['TypedArray', 'prototype'],\n\t'%TypeErrorPrototype%': ['TypeError', 'prototype'],\n\t'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],\n\t'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],\n\t'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],\n\t'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],\n\t'%URIErrorPrototype%': ['URIError', 'prototype'],\n\t'%WeakMapPrototype%': ['WeakMap', 'prototype'],\n\t'%WeakSetPrototype%': ['WeakSet', 'prototype']\n};\n\nvar bind = require('function-bind');\nvar hasOwn = require('has');\nvar $concat = bind.call(Function.call, Array.prototype.concat);\nvar $spliceApply = bind.call(Function.apply, Array.prototype.splice);\nvar $replace = bind.call(Function.call, String.prototype.replace);\nvar $strSlice = bind.call(Function.call, String.prototype.slice);\nvar $exec = bind.call(Function.call, RegExp.prototype.exec);\n\n/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */\nvar rePropName = /[^%.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|%$))/g;\nvar reEscapeChar = /\\\\(\\\\)?/g; /** Used to match backslashes in property paths. */\nvar stringToPath = function stringToPath(string) {\n\tvar first = $strSlice(string, 0, 1);\n\tvar last = $strSlice(string, -1);\n\tif (first === '%' && last !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected closing `%`');\n\t} else if (last === '%' && first !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected opening `%`');\n\t}\n\tvar result = [];\n\t$replace(string, rePropName, function (match, number, quote, subString) {\n\t\tresult[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;\n\t});\n\treturn result;\n};\n/* end adaptation */\n\nvar getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {\n\tvar intrinsicName = name;\n\tvar alias;\n\tif (hasOwn(LEGACY_ALIASES, intrinsicName)) {\n\t\talias = LEGACY_ALIASES[intrinsicName];\n\t\tintrinsicName = '%' + alias[0] + '%';\n\t}\n\n\tif (hasOwn(INTRINSICS, intrinsicName)) {\n\t\tvar value = INTRINSICS[intrinsicName];\n\t\tif (value === needsEval) {\n\t\t\tvalue = doEval(intrinsicName);\n\t\t}\n\t\tif (typeof value === 'undefined' && !allowMissing) {\n\t\t\tthrow new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');\n\t\t}\n\n\t\treturn {\n\t\t\talias: alias,\n\t\t\tname: intrinsicName,\n\t\t\tvalue: value\n\t\t};\n\t}\n\n\tthrow new $SyntaxError('intrinsic ' + name + ' does not exist!');\n};\n\nmodule.exports = function GetIntrinsic(name, allowMissing) {\n\tif (typeof name !== 'string' || name.length === 0) {\n\t\tthrow new $TypeError('intrinsic name must be a non-empty string');\n\t}\n\tif (arguments.length > 1 && typeof allowMissing !== 'boolean') {\n\t\tthrow new $TypeError('\"allowMissing\" argument must be a boolean');\n\t}\n\n\tif ($exec(/^%?[^%]*%?$/, name) === null) {\n\t\tthrow new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');\n\t}\n\tvar parts = stringToPath(name);\n\tvar intrinsicBaseName = parts.length > 0 ? parts[0] : '';\n\n\tvar intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);\n\tvar intrinsicRealName = intrinsic.name;\n\tvar value = intrinsic.value;\n\tvar skipFurtherCaching = false;\n\n\tvar alias = intrinsic.alias;\n\tif (alias) {\n\t\tintrinsicBaseName = alias[0];\n\t\t$spliceApply(parts, $concat([0, 1], alias));\n\t}\n\n\tfor (var i = 1, isOwn = true; i < parts.length; i += 1) {\n\t\tvar part = parts[i];\n\t\tvar first = $strSlice(part, 0, 1);\n\t\tvar last = $strSlice(part, -1);\n\t\tif (\n\t\t\t(\n\t\t\t\t(first === '\"' || first === \"'\" || first === '`')\n\t\t\t\t|| (last === '\"' || last === \"'\" || last === '`')\n\t\t\t)\n\t\t\t&& first !== last\n\t\t) {\n\t\t\tthrow new $SyntaxError('property names with quotes must have matching quotes');\n\t\t}\n\t\tif (part === 'constructor' || !isOwn) {\n\t\t\tskipFurtherCaching = true;\n\t\t}\n\n\t\tintrinsicBaseName += '.' + part;\n\t\tintrinsicRealName = '%' + intrinsicBaseName + '%';\n\n\t\tif (hasOwn(INTRINSICS, intrinsicRealName)) {\n\t\t\tvalue = INTRINSICS[intrinsicRealName];\n\t\t} else if (value != null) {\n\t\t\tif (!(part in value)) {\n\t\t\t\tif (!allowMissing) {\n\t\t\t\t\tthrow new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');\n\t\t\t\t}\n\t\t\t\treturn void undefined;\n\t\t\t}\n\t\t\tif ($gOPD && (i + 1) >= parts.length) {\n\t\t\t\tvar desc = $gOPD(value, part);\n\t\t\t\tisOwn = !!desc;\n\n\t\t\t\t// By convention, when a data property is converted to an accessor\n\t\t\t\t// property to emulate a data property that does not suffer from\n\t\t\t\t// the override mistake, that accessor's getter is marked with\n\t\t\t\t// an `originalValue` property. Here, when we detect this, we\n\t\t\t\t// uphold the illusion by pretending to see that original data\n\t\t\t\t// property, i.e., returning the value rather than the getter\n\t\t\t\t// itself.\n\t\t\t\tif (isOwn && 'get' in desc && !('originalValue' in desc.get)) {\n\t\t\t\t\tvalue = desc.get;\n\t\t\t\t} else {\n\t\t\t\t\tvalue = value[part];\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tisOwn = hasOwn(value, part);\n\t\t\t\tvalue = value[part];\n\t\t\t}\n\n\t\t\tif (isOwn && !skipFurtherCaching) {\n\t\t\t\tINTRINSICS[intrinsicRealName] = value;\n\t\t\t}\n\t\t}\n\t}\n\treturn value;\n};\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);\n\nif ($gOPD) {\n\ttry {\n\t\t$gOPD([], 'length');\n\t} catch (e) {\n\t\t// IE 8 has a broken gOPD\n\t\t$gOPD = null;\n\t}\n}\n\nmodule.exports = $gOPD;\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $defineProperty = GetIntrinsic('%Object.defineProperty%', true);\n\nvar hasPropertyDescriptors = function hasPropertyDescriptors() {\n\tif ($defineProperty) {\n\t\ttry {\n\t\t\t$defineProperty({}, 'a', { value: 1 });\n\t\t\treturn true;\n\t\t} catch (e) {\n\t\t\t// IE 8 has a broken defineProperty\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn false;\n};\n\nhasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {\n\t// node v0.6 has a bug where array lengths can be Set but not Defined\n\tif (!hasPropertyDescriptors()) {\n\t\treturn null;\n\t}\n\ttry {\n\t\treturn $defineProperty([], 'length', { value: 1 }).length !== 1;\n\t} catch (e) {\n\t\t// In Firefox 4-22, defining length on an array throws an exception.\n\t\treturn true;\n\t}\n};\n\nmodule.exports = hasPropertyDescriptors;\n","'use strict';\n\nvar origSymbol = typeof Symbol !== 'undefined' && Symbol;\nvar hasSymbolSham = require('./shams');\n\nmodule.exports = function hasNativeSymbols() {\n\tif (typeof origSymbol !== 'function') { return false; }\n\tif (typeof Symbol !== 'function') { return false; }\n\tif (typeof origSymbol('foo') !== 'symbol') { return false; }\n\tif (typeof Symbol('bar') !== 'symbol') { return false; }\n\n\treturn hasSymbolSham();\n};\n","'use strict';\n\n/* eslint complexity: [2, 18], max-statements: [2, 33] */\nmodule.exports = function hasSymbols() {\n\tif (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }\n\tif (typeof Symbol.iterator === 'symbol') { return true; }\n\n\tvar obj = {};\n\tvar sym = Symbol('test');\n\tvar symObj = Object(sym);\n\tif (typeof sym === 'string') { return false; }\n\n\tif (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }\n\tif (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }\n\n\t// temp disabled per https://github.com/ljharb/object.assign/issues/17\n\t// if (sym instanceof Symbol) { return false; }\n\t// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4\n\t// if (!(symObj instanceof Symbol)) { return false; }\n\n\t// if (typeof Symbol.prototype.toString !== 'function') { return false; }\n\t// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }\n\n\tvar symVal = 42;\n\tobj[sym] = symVal;\n\tfor (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop\n\tif (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }\n\n\tvar syms = Object.getOwnPropertySymbols(obj);\n\tif (syms.length !== 1 || syms[0] !== sym) { return false; }\n\n\tif (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }\n\n\tif (typeof Object.getOwnPropertyDescriptor === 'function') {\n\t\tvar descriptor = Object.getOwnPropertyDescriptor(obj, sym);\n\t\tif (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }\n\t}\n\n\treturn true;\n};\n","'use strict';\n\nvar hasSymbols = require('has-symbols/shams');\n\nmodule.exports = function hasToStringTagShams() {\n\treturn hasSymbols() && !!Symbol.toStringTag;\n};\n","'use strict';\n\nvar bind = require('function-bind');\n\nmodule.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);\n","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","'use strict';\n\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar callBound = require('call-bind/callBound');\n\nvar $toString = callBound('Object.prototype.toString');\n\nvar isStandardArguments = function isArguments(value) {\n\tif (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) {\n\t\treturn false;\n\t}\n\treturn $toString(value) === '[object Arguments]';\n};\n\nvar isLegacyArguments = function isArguments(value) {\n\tif (isStandardArguments(value)) {\n\t\treturn true;\n\t}\n\treturn value !== null &&\n\t\ttypeof value === 'object' &&\n\t\ttypeof value.length === 'number' &&\n\t\tvalue.length >= 0 &&\n\t\t$toString(value) !== '[object Array]' &&\n\t\t$toString(value.callee) === '[object Function]';\n};\n\nvar supportsStandardArguments = (function () {\n\treturn isStandardArguments(arguments);\n}());\n\nisStandardArguments.isLegacyArguments = isLegacyArguments; // for tests\n\nmodule.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;\n","'use strict';\n\nvar fnToStr = Function.prototype.toString;\nvar reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;\nvar badArrayLike;\nvar isCallableMarker;\nif (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {\n\ttry {\n\t\tbadArrayLike = Object.defineProperty({}, 'length', {\n\t\t\tget: function () {\n\t\t\t\tthrow isCallableMarker;\n\t\t\t}\n\t\t});\n\t\tisCallableMarker = {};\n\t\t// eslint-disable-next-line no-throw-literal\n\t\treflectApply(function () { throw 42; }, null, badArrayLike);\n\t} catch (_) {\n\t\tif (_ !== isCallableMarker) {\n\t\t\treflectApply = null;\n\t\t}\n\t}\n} else {\n\treflectApply = null;\n}\n\nvar constructorRegex = /^\\s*class\\b/;\nvar isES6ClassFn = function isES6ClassFunction(value) {\n\ttry {\n\t\tvar fnStr = fnToStr.call(value);\n\t\treturn constructorRegex.test(fnStr);\n\t} catch (e) {\n\t\treturn false; // not a function\n\t}\n};\n\nvar tryFunctionObject = function tryFunctionToStr(value) {\n\ttry {\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tfnToStr.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar objectClass = '[object Object]';\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar ddaClass = '[object HTMLAllCollection]'; // IE 11\nvar ddaClass2 = '[object HTML document.all class]';\nvar ddaClass3 = '[object HTMLCollection]'; // IE 9-10\nvar hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`\n\nvar isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing\n\nvar isDDA = function isDocumentDotAll() { return false; };\nif (typeof document === 'object') {\n\t// Firefox 3 canonicalizes DDA to undefined when it's not accessed directly\n\tvar all = document.all;\n\tif (toStr.call(all) === toStr.call(document.all)) {\n\t\tisDDA = function isDocumentDotAll(value) {\n\t\t\t/* globals document: false */\n\t\t\t// in IE 6-8, typeof document.all is \"object\" and it's truthy\n\t\t\tif ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {\n\t\t\t\ttry {\n\t\t\t\t\tvar str = toStr.call(value);\n\t\t\t\t\treturn (\n\t\t\t\t\t\tstr === ddaClass\n\t\t\t\t\t\t|| str === ddaClass2\n\t\t\t\t\t\t|| str === ddaClass3 // opera 12.16\n\t\t\t\t\t\t|| str === objectClass // IE 6-8\n\t\t\t\t\t) && value('') == null; // eslint-disable-line eqeqeq\n\t\t\t\t} catch (e) { /**/ }\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n\t}\n}\n\nmodule.exports = reflectApply\n\t? function isCallable(value) {\n\t\tif (isDDA(value)) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\ttry {\n\t\t\treflectApply(value, null, badArrayLike);\n\t\t} catch (e) {\n\t\t\tif (e !== isCallableMarker) { return false; }\n\t\t}\n\t\treturn !isES6ClassFn(value) && tryFunctionObject(value);\n\t}\n\t: function isCallable(value) {\n\t\tif (isDDA(value)) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\tif (hasToStringTag) { return tryFunctionObject(value); }\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tvar strClass = toStr.call(value);\n\t\tif (strClass !== fnClass && strClass !== genClass && !(/^\\[object HTML/).test(strClass)) { return false; }\n\t\treturn tryFunctionObject(value);\n\t};\n","'use strict';\n\nvar toStr = Object.prototype.toString;\nvar fnToStr = Function.prototype.toString;\nvar isFnRegex = /^\\s*(?:function)?\\*/;\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar getProto = Object.getPrototypeOf;\nvar getGeneratorFunc = function () { // eslint-disable-line consistent-return\n\tif (!hasToStringTag) {\n\t\treturn false;\n\t}\n\ttry {\n\t\treturn Function('return function*() {}')();\n\t} catch (e) {\n\t}\n};\nvar GeneratorFunction;\n\nmodule.exports = function isGeneratorFunction(fn) {\n\tif (typeof fn !== 'function') {\n\t\treturn false;\n\t}\n\tif (isFnRegex.test(fnToStr.call(fn))) {\n\t\treturn true;\n\t}\n\tif (!hasToStringTag) {\n\t\tvar str = toStr.call(fn);\n\t\treturn str === '[object GeneratorFunction]';\n\t}\n\tif (!getProto) {\n\t\treturn false;\n\t}\n\tif (typeof GeneratorFunction === 'undefined') {\n\t\tvar generatorFunc = getGeneratorFunc();\n\t\tGeneratorFunction = generatorFunc ? getProto(generatorFunc) : false;\n\t}\n\treturn getProto(fn) === GeneratorFunction;\n};\n","'use strict';\n\n/* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */\n\nmodule.exports = function isNaN(value) {\n\treturn value !== value;\n};\n","'use strict';\n\nvar callBind = require('call-bind');\nvar define = require('define-properties');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar shim = require('./shim');\n\nvar polyfill = callBind(getPolyfill(), Number);\n\n/* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */\n\ndefine(polyfill, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = polyfill;\n","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = function getPolyfill() {\n\tif (Number.isNaN && Number.isNaN(NaN) && !Number.isNaN('a')) {\n\t\treturn Number.isNaN;\n\t}\n\treturn implementation;\n};\n","'use strict';\n\nvar define = require('define-properties');\nvar getPolyfill = require('./polyfill');\n\n/* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */\n\nmodule.exports = function shimNumberIsNaN() {\n\tvar polyfill = getPolyfill();\n\tdefine(Number, { isNaN: polyfill }, {\n\t\tisNaN: function testIsNaN() {\n\t\t\treturn Number.isNaN !== polyfill;\n\t\t}\n\t});\n\treturn polyfill;\n};\n","'use strict';\n\nvar forEach = require('for-each');\nvar availableTypedArrays = require('available-typed-arrays');\nvar callBound = require('call-bind/callBound');\n\nvar $toString = callBound('Object.prototype.toString');\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar gOPD = require('gopd');\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\nvar typedArrays = availableTypedArrays();\n\nvar $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) {\n\tfor (var i = 0; i < array.length; i += 1) {\n\t\tif (array[i] === value) {\n\t\t\treturn i;\n\t\t}\n\t}\n\treturn -1;\n};\nvar $slice = callBound('String.prototype.slice');\nvar toStrTags = {};\nvar getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');\nif (hasToStringTag && gOPD && getPrototypeOf) {\n\tforEach(typedArrays, function (typedArray) {\n\t\tvar arr = new g[typedArray]();\n\t\tif (Symbol.toStringTag in arr) {\n\t\t\tvar proto = getPrototypeOf(arr);\n\t\t\tvar descriptor = gOPD(proto, Symbol.toStringTag);\n\t\t\tif (!descriptor) {\n\t\t\t\tvar superProto = getPrototypeOf(proto);\n\t\t\t\tdescriptor = gOPD(superProto, Symbol.toStringTag);\n\t\t\t}\n\t\t\ttoStrTags[typedArray] = descriptor.get;\n\t\t}\n\t});\n}\n\nvar tryTypedArrays = function tryAllTypedArrays(value) {\n\tvar anyTrue = false;\n\tforEach(toStrTags, function (getter, typedArray) {\n\t\tif (!anyTrue) {\n\t\t\ttry {\n\t\t\t\tanyTrue = getter.call(value) === typedArray;\n\t\t\t} catch (e) { /**/ }\n\t\t}\n\t});\n\treturn anyTrue;\n};\n\nmodule.exports = function isTypedArray(value) {\n\tif (!value || typeof value !== 'object') { return false; }\n\tif (!hasToStringTag || !(Symbol.toStringTag in value)) {\n\t\tvar tag = $slice($toString(value), 8, -1);\n\t\treturn $indexOf(typedArrays, tag) > -1;\n\t}\n\tif (!gOPD) { return false; }\n\treturn tryTypedArrays(value);\n};\n","'use strict';\n\nvar numberIsNaN = function (value) {\n\treturn value !== value;\n};\n\nmodule.exports = function is(a, b) {\n\tif (a === 0 && b === 0) {\n\t\treturn 1 / a === 1 / b;\n\t}\n\tif (a === b) {\n\t\treturn true;\n\t}\n\tif (numberIsNaN(a) && numberIsNaN(b)) {\n\t\treturn true;\n\t}\n\treturn false;\n};\n\n","'use strict';\n\nvar define = require('define-properties');\nvar callBind = require('call-bind');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar shim = require('./shim');\n\nvar polyfill = callBind(getPolyfill(), Object);\n\ndefine(polyfill, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = polyfill;\n","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = function getPolyfill() {\n\treturn typeof Object.is === 'function' ? Object.is : implementation;\n};\n","'use strict';\n\nvar getPolyfill = require('./polyfill');\nvar define = require('define-properties');\n\nmodule.exports = function shimObjectIs() {\n\tvar polyfill = getPolyfill();\n\tdefine(Object, { is: polyfill }, {\n\t\tis: function testObjectIs() {\n\t\t\treturn Object.is !== polyfill;\n\t\t}\n\t});\n\treturn polyfill;\n};\n","'use strict';\n\nvar keysShim;\nif (!Object.keys) {\n\t// modified from https://github.com/es-shims/es5-shim\n\tvar has = Object.prototype.hasOwnProperty;\n\tvar toStr = Object.prototype.toString;\n\tvar isArgs = require('./isArguments'); // eslint-disable-line global-require\n\tvar isEnumerable = Object.prototype.propertyIsEnumerable;\n\tvar hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');\n\tvar hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');\n\tvar dontEnums = [\n\t\t'toString',\n\t\t'toLocaleString',\n\t\t'valueOf',\n\t\t'hasOwnProperty',\n\t\t'isPrototypeOf',\n\t\t'propertyIsEnumerable',\n\t\t'constructor'\n\t];\n\tvar equalsConstructorPrototype = function (o) {\n\t\tvar ctor = o.constructor;\n\t\treturn ctor && ctor.prototype === o;\n\t};\n\tvar excludedKeys = {\n\t\t$applicationCache: true,\n\t\t$console: true,\n\t\t$external: true,\n\t\t$frame: true,\n\t\t$frameElement: true,\n\t\t$frames: true,\n\t\t$innerHeight: true,\n\t\t$innerWidth: true,\n\t\t$onmozfullscreenchange: true,\n\t\t$onmozfullscreenerror: true,\n\t\t$outerHeight: true,\n\t\t$outerWidth: true,\n\t\t$pageXOffset: true,\n\t\t$pageYOffset: true,\n\t\t$parent: true,\n\t\t$scrollLeft: true,\n\t\t$scrollTop: true,\n\t\t$scrollX: true,\n\t\t$scrollY: true,\n\t\t$self: true,\n\t\t$webkitIndexedDB: true,\n\t\t$webkitStorageInfo: true,\n\t\t$window: true\n\t};\n\tvar hasAutomationEqualityBug = (function () {\n\t\t/* global window */\n\t\tif (typeof window === 'undefined') { return false; }\n\t\tfor (var k in window) {\n\t\t\ttry {\n\t\t\t\tif (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tequalsConstructorPrototype(window[k]);\n\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} catch (e) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}());\n\tvar equalsConstructorPrototypeIfNotBuggy = function (o) {\n\t\t/* global window */\n\t\tif (typeof window === 'undefined' || !hasAutomationEqualityBug) {\n\t\t\treturn equalsConstructorPrototype(o);\n\t\t}\n\t\ttry {\n\t\t\treturn equalsConstructorPrototype(o);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n\n\tkeysShim = function keys(object) {\n\t\tvar isObject = object !== null && typeof object === 'object';\n\t\tvar isFunction = toStr.call(object) === '[object Function]';\n\t\tvar isArguments = isArgs(object);\n\t\tvar isString = isObject && toStr.call(object) === '[object String]';\n\t\tvar theKeys = [];\n\n\t\tif (!isObject && !isFunction && !isArguments) {\n\t\t\tthrow new TypeError('Object.keys called on a non-object');\n\t\t}\n\n\t\tvar skipProto = hasProtoEnumBug && isFunction;\n\t\tif (isString && object.length > 0 && !has.call(object, 0)) {\n\t\t\tfor (var i = 0; i < object.length; ++i) {\n\t\t\t\ttheKeys.push(String(i));\n\t\t\t}\n\t\t}\n\n\t\tif (isArguments && object.length > 0) {\n\t\t\tfor (var j = 0; j < object.length; ++j) {\n\t\t\t\ttheKeys.push(String(j));\n\t\t\t}\n\t\t} else {\n\t\t\tfor (var name in object) {\n\t\t\t\tif (!(skipProto && name === 'prototype') && has.call(object, name)) {\n\t\t\t\t\ttheKeys.push(String(name));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (hasDontEnumBug) {\n\t\t\tvar skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);\n\n\t\t\tfor (var k = 0; k < dontEnums.length; ++k) {\n\t\t\t\tif (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {\n\t\t\t\t\ttheKeys.push(dontEnums[k]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn theKeys;\n\t};\n}\nmodule.exports = keysShim;\n","'use strict';\n\nvar slice = Array.prototype.slice;\nvar isArgs = require('./isArguments');\n\nvar origKeys = Object.keys;\nvar keysShim = origKeys ? function keys(o) { return origKeys(o); } : require('./implementation');\n\nvar originalKeys = Object.keys;\n\nkeysShim.shim = function shimObjectKeys() {\n\tif (Object.keys) {\n\t\tvar keysWorksWithArguments = (function () {\n\t\t\t// Safari 5.0 bug\n\t\t\tvar args = Object.keys(arguments);\n\t\t\treturn args && args.length === arguments.length;\n\t\t}(1, 2));\n\t\tif (!keysWorksWithArguments) {\n\t\t\tObject.keys = function keys(object) { // eslint-disable-line func-name-matching\n\t\t\t\tif (isArgs(object)) {\n\t\t\t\t\treturn originalKeys(slice.call(object));\n\t\t\t\t}\n\t\t\t\treturn originalKeys(object);\n\t\t\t};\n\t\t}\n\t} else {\n\t\tObject.keys = keysShim;\n\t}\n\treturn Object.keys || keysShim;\n};\n\nmodule.exports = keysShim;\n","'use strict';\n\nvar toStr = Object.prototype.toString;\n\nmodule.exports = function isArguments(value) {\n\tvar str = toStr.call(value);\n\tvar isArgs = str === '[object Arguments]';\n\tif (!isArgs) {\n\t\tisArgs = str !== '[object Array]' &&\n\t\t\tvalue !== null &&\n\t\t\ttypeof value === 'object' &&\n\t\t\ttypeof value.length === 'number' &&\n\t\t\tvalue.length >= 0 &&\n\t\t\ttoStr.call(value.callee) === '[object Function]';\n\t}\n\treturn isArgs;\n};\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n// If obj.hasOwnProperty has been overridden, then calling\n// obj.hasOwnProperty(prop) will break.\n// See: https://github.com/joyent/node/issues/1707\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nmodule.exports = function(qs, sep, eq, options) {\n  sep = sep || '&';\n  eq = eq || '=';\n  var obj = {};\n\n  if (typeof qs !== 'string' || qs.length === 0) {\n    return obj;\n  }\n\n  var regexp = /\\+/g;\n  qs = qs.split(sep);\n\n  var maxKeys = 1000;\n  if (options && typeof options.maxKeys === 'number') {\n    maxKeys = options.maxKeys;\n  }\n\n  var len = qs.length;\n  // maxKeys <= 0 means that we should not limit keys count\n  if (maxKeys > 0 && len > maxKeys) {\n    len = maxKeys;\n  }\n\n  for (var i = 0; i < len; ++i) {\n    var x = qs[i].replace(regexp, '%20'),\n        idx = x.indexOf(eq),\n        kstr, vstr, k, v;\n\n    if (idx >= 0) {\n      kstr = x.substr(0, idx);\n      vstr = x.substr(idx + 1);\n    } else {\n      kstr = x;\n      vstr = '';\n    }\n\n    k = decodeURIComponent(kstr);\n    v = decodeURIComponent(vstr);\n\n    if (!hasOwnProperty(obj, k)) {\n      obj[k] = v;\n    } else if (Array.isArray(obj[k])) {\n      obj[k].push(v);\n    } else {\n      obj[k] = [obj[k], v];\n    }\n  }\n\n  return obj;\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar stringifyPrimitive = function(v) {\n  switch (typeof v) {\n    case 'string':\n      return v;\n\n    case 'boolean':\n      return v ? 'true' : 'false';\n\n    case 'number':\n      return isFinite(v) ? v : '';\n\n    default:\n      return '';\n  }\n};\n\nmodule.exports = function(obj, sep, eq, name) {\n  sep = sep || '&';\n  eq = eq || '=';\n  if (obj === null) {\n    obj = undefined;\n  }\n\n  if (typeof obj === 'object') {\n    return Object.keys(obj).map(function(k) {\n      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n      if (Array.isArray(obj[k])) {\n        return obj[k].map(function(v) {\n          return ks + encodeURIComponent(stringifyPrimitive(v));\n        }).join(sep);\n      } else {\n        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));\n      }\n    }).join(sep);\n\n  }\n\n  if (!name) return '';\n  return encodeURIComponent(stringifyPrimitive(name)) + eq +\n         encodeURIComponent(stringifyPrimitive(obj));\n};\n","'use strict';\n\nexports.decode = exports.parse = require('./decode');\nexports.encode = exports.stringify = require('./encode');\n","/*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\nlet promise\n\nmodule.exports = typeof queueMicrotask === 'function'\n  ? queueMicrotask.bind(typeof window !== 'undefined' ? window : global)\n  // reuse resolved promise, and allocate it lazily\n  : cb => (promise || (promise = Promise.resolve()))\n    .then(cb)\n    .catch(err => setTimeout(() => { throw err }, 0))\n","/**\n * Provides a way to access commonly used namespaces\n *\n * Usage:\n *\n *   ```\n *   const $rdf = require('rdflib'); //or any other RDF/JS-compatible library\n *   const ns = require('solid-namespace')($rdf);\n *   const store = $rdf.graph();\n *\n *   let me = ...;\n *   let name = store.any(me, ns.vcard(‘fn’)) || store.any(me, ns.foaf(‘name’));\n *   ```\n * @module vocab\n */\nconst aliases = {\n  acl: 'http://www.w3.org/ns/auth/acl#',\n  arg: 'http://www.w3.org/ns/pim/arg#',\n  as: 'https://www.w3.org/ns/activitystreams#',\n  cal: 'http://www.w3.org/2002/12/cal/ical#',\n  cert: 'http://www.w3.org/ns/auth/cert#',\n  contact: 'http://www.w3.org/2000/10/swap/pim/contact#',\n  dc: 'http://purl.org/dc/elements/1.1/',\n  dct: 'http://purl.org/dc/terms/',\n  doap: 'http://usefulinc.com/ns/doap#',\n  foaf: 'http://xmlns.com/foaf/0.1/',\n  geo: 'http://www.w3.org/2003/01/geo/wgs84_pos#',\n  gpx: 'http://www.w3.org/ns/pim/gpx#',\n  http: 'http://www.w3.org/2007/ont/http#',\n  httph: 'http://www.w3.org/2007/ont/httph#',\n  icalTZ: 'http://www.w3.org/2002/12/cal/icaltzd#', // Beware: not cal:\n  ldp: 'http://www.w3.org/ns/ldp#',\n  link: 'http://www.w3.org/2007/ont/link#',\n  log: 'http://www.w3.org/2000/10/swap/log#',\n  meeting: 'http://www.w3.org/ns/pim/meeting#',\n  mo: 'http://purl.org/ontology/mo/',\n  org: 'http://www.w3.org/ns/org#',\n  owl: 'http://www.w3.org/2002/07/owl#',\n  pad: 'http://www.w3.org/ns/pim/pad#',\n  patch: 'http://www.w3.org/ns/pim/patch#',\n  prov: 'http://www.w3.org/ns/prov#',\n  qu: 'http://www.w3.org/2000/10/swap/pim/qif#',\n  trip: 'http://www.w3.org/ns/pim/trip#',\n  rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',\n  rdfs: 'http://www.w3.org/2000/01/rdf-schema#',\n  rss: 'http://purl.org/rss/1.0/',\n  sched: 'http://www.w3.org/ns/pim/schedule#',\n  schema: 'http://schema.org/', // @@ beware confusion with documents no 303\n  sioc: 'http://rdfs.org/sioc/ns#',\n  solid: 'http://www.w3.org/ns/solid/terms#',\n  space: 'http://www.w3.org/ns/pim/space#',\n  stat: 'http://www.w3.org/ns/posix/stat#',\n  tab: 'http://www.w3.org/2007/ont/link#',\n  tabont: 'http://www.w3.org/2007/ont/link#',\n  ui: 'http://www.w3.org/ns/ui#',\n  vcard: 'http://www.w3.org/2006/vcard/ns#',\n  wf: 'http://www.w3.org/2005/01/wf/flow#',\n  xsd: 'http://www.w3.org/2001/XMLSchema#',\n  cco: 'http://www.ontologyrepository.com/CommonCoreOntologies/',\n  skos: 'http://www.w3.org/2004/02/skos/core#',\n  bookmark: 'http://www.w3.org/2002/01/bookmark#',\n  vann: 'http://purl.org/vocab/vann/'\n}\n\n/**\n * @param [rdflib] {RDF} Optional RDF Library (such as rdflib.js or rdf-ext) to inject\n */\nfunction vocab (rdf = { namedNode: u => u }) {\n  const namespaces = {}\n  for (const alias in aliases) {\n    const expansion = aliases[alias]\n    namespaces[alias] = function (localName = '') {\n      return rdf.namedNode(expansion + localName)\n    }\n  };\n\n  return namespaces\n};\n\nmodule.exports = vocab\n","/*! https://mths.be/punycode v1.3.2 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports &&\n\t\t!exports.nodeType && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\t!module.nodeType && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (\n\t\tfreeGlobal.global === freeGlobal ||\n\t\tfreeGlobal.window === freeGlobal ||\n\t\tfreeGlobal.self === freeGlobal\n\t) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^\\x20-\\x7E]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\tvar result = [];\n\t\twhile (length--) {\n\t\t\tresult[length] = fn(array[length]);\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings or email\n\t * addresses.\n\t * @private\n\t * @param {String} domain The domain name or email address.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\tvar parts = string.split('@');\n\t\tvar result = '';\n\t\tif (parts.length > 1) {\n\t\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t\t// the local part (i.e. everything up to `@`) intact.\n\t\t\tresult = parts[0] + '@';\n\t\t\tstring = parts[1];\n\t\t}\n\t\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\t\tstring = string.replace(regexSeparators, '\\x2E');\n\t\tvar labels = string.split('.');\n\t\tvar encoded = map(labels, fn).join('.');\n\t\treturn result + encoded;\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t    counter = 0,\n\t\t    length = string.length,\n\t\t    value,\n\t\t    extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t//  0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * http://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t    inputLength = input.length,\n\t\t    out,\n\t\t    i = 0,\n\t\t    n = initialN,\n\t\t    bias = initialBias,\n\t\t    basic,\n\t\t    j,\n\t\t    index,\n\t\t    oldi,\n\t\t    w,\n\t\t    k,\n\t\t    digit,\n\t\t    t,\n\t\t    /** Cached calculation results */\n\t\t    baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols (e.g. a domain name label) to a\n\t * Punycode string of ASCII-only symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t    delta,\n\t\t    handledCPCount,\n\t\t    basicLength,\n\t\t    bias,\n\t\t    j,\n\t\t    m,\n\t\t    q,\n\t\t    k,\n\t\t    t,\n\t\t    currentValue,\n\t\t    output = [],\n\t\t    /** `inputLength` will hold the number of code points in `input`. */\n\t\t    inputLength,\n\t\t    /** Cached calculation results */\n\t\t    handledCPCountPlusOne,\n\t\t    baseMinusT,\n\t\t    qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name or an email address\n\t * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n\t * it doesn't matter if you call it on a string that has already been\n\t * converted to Unicode.\n\t * @memberOf punycode\n\t * @param {String} input The Punycoded domain name or email address to\n\t * convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name or an email address to\n\t * Punycode. Only the non-ASCII parts of the domain name will be converted,\n\t * i.e. it doesn't matter if you call it with a domain that's already in\n\t * ASCII.\n\t * @memberOf punycode\n\t * @param {String} input The domain name or email address to convert, as a\n\t * Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name or\n\t * email address.\n\t */\n\tfunction toASCII(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.3.2',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine('punycode', function() {\n\t\t\treturn punycode;\n\t\t});\n\t} else if (freeExports && freeModule) {\n\t\tif (module.exports == freeExports) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar punycode = require('punycode');\nvar util = require('./util');\n\nexports.parse = urlParse;\nexports.resolve = urlResolve;\nexports.resolveObject = urlResolveObject;\nexports.format = urlFormat;\n\nexports.Url = Url;\n\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.host = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.query = null;\n  this.pathname = null;\n  this.path = null;\n  this.href = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n    portPattern = /:[0-9]*$/,\n\n    // Special case for a simple path URL\n    simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n\n    // RFC 2396: characters reserved for delimiting URLs.\n    // We actually just auto-escape these.\n    delims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'],\n\n    // RFC 2396: characters not allowed for various reasons.\n    unwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims),\n\n    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.\n    autoEscape = ['\\''].concat(unwise),\n    // Characters that are never ever allowed in a hostname.\n    // Note that any invalid chars are also handled, but these\n    // are the ones that are *expected* to be seen, so we fast-path\n    // them.\n    nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),\n    hostEndingChars = ['/', '?', '#'],\n    hostnameMaxLen = 255,\n    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n    // protocols that can allow \"unsafe\" and \"unwise\" chars.\n    unsafeProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that never have a hostname.\n    hostlessProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that always contain a // bit.\n    slashedProtocol = {\n      'http': true,\n      'https': true,\n      'ftp': true,\n      'gopher': true,\n      'file': true,\n      'http:': true,\n      'https:': true,\n      'ftp:': true,\n      'gopher:': true,\n      'file:': true\n    },\n    querystring = require('querystring');\n\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n  if (url && util.isObject(url) && url instanceof Url) return url;\n\n  var u = new Url;\n  u.parse(url, parseQueryString, slashesDenoteHost);\n  return u;\n}\n\nUrl.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {\n  if (!util.isString(url)) {\n    throw new TypeError(\"Parameter 'url' must be a string, not \" + typeof url);\n  }\n\n  // Copy chrome, IE, opera backslash-handling behavior.\n  // Back slashes before the query string get converted to forward slashes\n  // See: https://code.google.com/p/chromium/issues/detail?id=25916\n  var queryIndex = url.indexOf('?'),\n      splitter =\n          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',\n      uSplit = url.split(splitter),\n      slashRegex = /\\\\/g;\n  uSplit[0] = uSplit[0].replace(slashRegex, '/');\n  url = uSplit.join(splitter);\n\n  var rest = url;\n\n  // trim before proceeding.\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\n  rest = rest.trim();\n\n  if (!slashesDenoteHost && url.split('#').length === 1) {\n    // Try fast path regexp\n    var simplePath = simplePathPattern.exec(rest);\n    if (simplePath) {\n      this.path = rest;\n      this.href = rest;\n      this.pathname = simplePath[1];\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n        if (parseQueryString) {\n          this.query = querystring.parse(this.search.substr(1));\n        } else {\n          this.query = this.search.substr(1);\n        }\n      } else if (parseQueryString) {\n        this.search = '';\n        this.query = {};\n      }\n      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n  if (proto) {\n    proto = proto[0];\n    var lowerProto = proto.toLowerCase();\n    this.protocol = lowerProto;\n    rest = rest.substr(proto.length);\n  }\n\n  // figure out if it's got a host\n  // user@server is *always* interpreted as a hostname, and url\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\n  // how the browser resolves relative URLs.\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n    var slashes = rest.substr(0, 2) === '//';\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] &&\n      (slashes || (proto && !slashedProtocol[proto]))) {\n\n    // there's a hostname.\n    // the first instance of /, ?, ;, or # ends the host.\n    //\n    // If there is an @ in the hostname, then non-host chars *are* allowed\n    // to the left of the last @ sign, unless some host-ending character\n    // comes *before* the @-sign.\n    // URLs are obnoxious.\n    //\n    // ex:\n    // http://a@b@c/ => user:a@b host:c\n    // http://a@b?@c => user:a host:c path:/?@c\n\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n\n    // find the first instance of any hostEndingChars\n    var hostEnd = -1;\n    for (var i = 0; i < hostEndingChars.length; i++) {\n      var hec = rest.indexOf(hostEndingChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\n    }\n\n    // at this point, either we have an explicit point where the\n    // auth portion cannot go past, or the last @ char is the decider.\n    var auth, atSign;\n    if (hostEnd === -1) {\n      // atSign can be anywhere.\n      atSign = rest.lastIndexOf('@');\n    } else {\n      // atSign must be in auth portion.\n      // http://a@b/c@d => host:b auth:a path:/c@d\n      atSign = rest.lastIndexOf('@', hostEnd);\n    }\n\n    // Now we have a portion which is definitely the auth.\n    // Pull that off.\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign);\n      rest = rest.slice(atSign + 1);\n      this.auth = decodeURIComponent(auth);\n    }\n\n    // the host is the remaining to the left of the first non-host char\n    hostEnd = -1;\n    for (var i = 0; i < nonHostChars.length; i++) {\n      var hec = rest.indexOf(nonHostChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\n    }\n    // if we still have not hit it, then the entire thing is a host.\n    if (hostEnd === -1)\n      hostEnd = rest.length;\n\n    this.host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd);\n\n    // pull out port.\n    this.parseHost();\n\n    // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n    this.hostname = this.hostname || '';\n\n    // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n    var ipv6Hostname = this.hostname[0] === '[' &&\n        this.hostname[this.hostname.length - 1] === ']';\n\n    // validate a little.\n    if (!ipv6Hostname) {\n      var hostparts = this.hostname.split(/\\./);\n      for (var i = 0, l = hostparts.length; i < l; i++) {\n        var part = hostparts[i];\n        if (!part) continue;\n        if (!part.match(hostnamePartPattern)) {\n          var newpart = '';\n          for (var j = 0, k = part.length; j < k; j++) {\n            if (part.charCodeAt(j) > 127) {\n              // we replace non-ASCII char with a temporary placeholder\n              // we need this to make sure size of hostname is not\n              // broken by replacing non-ASCII by nothing\n              newpart += 'x';\n            } else {\n              newpart += part[j];\n            }\n          }\n          // we test again with ASCII char only\n          if (!newpart.match(hostnamePartPattern)) {\n            var validParts = hostparts.slice(0, i);\n            var notHost = hostparts.slice(i + 1);\n            var bit = part.match(hostnamePartStart);\n            if (bit) {\n              validParts.push(bit[1]);\n              notHost.unshift(bit[2]);\n            }\n            if (notHost.length) {\n              rest = '/' + notHost.join('.') + rest;\n            }\n            this.hostname = validParts.join('.');\n            break;\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    } else {\n      // hostnames are always lower case.\n      this.hostname = this.hostname.toLowerCase();\n    }\n\n    if (!ipv6Hostname) {\n      // IDNA Support: Returns a punycoded representation of \"domain\".\n      // It only converts parts of the domain name that\n      // have non-ASCII characters, i.e. it doesn't matter if\n      // you call it with a domain that already is ASCII-only.\n      this.hostname = punycode.toASCII(this.hostname);\n    }\n\n    var p = this.port ? ':' + this.port : '';\n    var h = this.hostname || '';\n    this.host = h + p;\n    this.href += this.host;\n\n    // strip [ and ] from the hostname\n    // the host field still retains them, though\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n      if (rest[0] !== '/') {\n        rest = '/' + rest;\n      }\n    }\n  }\n\n  // now rest is set to the post-host stuff.\n  // chop off any delim chars.\n  if (!unsafeProtocol[lowerProto]) {\n\n    // First, make 100% sure that any \"autoEscape\" chars get\n    // escaped, even if encodeURIComponent doesn't think they\n    // need to be.\n    for (var i = 0, l = autoEscape.length; i < l; i++) {\n      var ae = autoEscape[i];\n      if (rest.indexOf(ae) === -1)\n        continue;\n      var esc = encodeURIComponent(ae);\n      if (esc === ae) {\n        esc = escape(ae);\n      }\n      rest = rest.split(ae).join(esc);\n    }\n  }\n\n\n  // chop off from the tail first.\n  var hash = rest.indexOf('#');\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash);\n    rest = rest.slice(0, hash);\n  }\n  var qm = rest.indexOf('?');\n  if (qm !== -1) {\n    this.search = rest.substr(qm);\n    this.query = rest.substr(qm + 1);\n    if (parseQueryString) {\n      this.query = querystring.parse(this.query);\n    }\n    rest = rest.slice(0, qm);\n  } else if (parseQueryString) {\n    // no query string, but parseQueryString still requested\n    this.search = '';\n    this.query = {};\n  }\n  if (rest) this.pathname = rest;\n  if (slashedProtocol[lowerProto] &&\n      this.hostname && !this.pathname) {\n    this.pathname = '/';\n  }\n\n  //to support http.request\n  if (this.pathname || this.search) {\n    var p = this.pathname || '';\n    var s = this.search || '';\n    this.path = p + s;\n  }\n\n  // finally, reconstruct the href based on what has been validated.\n  this.href = this.format();\n  return this;\n};\n\n// format a parsed object into a url string\nfunction urlFormat(obj) {\n  // ensure it's an object, and not a string url.\n  // If it's an obj, this is a no-op.\n  // this way, you can call url_format() on strings\n  // to clean up potentially wonky urls.\n  if (util.isString(obj)) obj = urlParse(obj);\n  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);\n  return obj.format();\n}\n\nUrl.prototype.format = function() {\n  var auth = this.auth || '';\n  if (auth) {\n    auth = encodeURIComponent(auth);\n    auth = auth.replace(/%3A/i, ':');\n    auth += '@';\n  }\n\n  var protocol = this.protocol || '',\n      pathname = this.pathname || '',\n      hash = this.hash || '',\n      host = false,\n      query = '';\n\n  if (this.host) {\n    host = auth + this.host;\n  } else if (this.hostname) {\n    host = auth + (this.hostname.indexOf(':') === -1 ?\n        this.hostname :\n        '[' + this.hostname + ']');\n    if (this.port) {\n      host += ':' + this.port;\n    }\n  }\n\n  if (this.query &&\n      util.isObject(this.query) &&\n      Object.keys(this.query).length) {\n    query = querystring.stringify(this.query);\n  }\n\n  var search = this.search || (query && ('?' + query)) || '';\n\n  if (protocol && protocol.substr(-1) !== ':') protocol += ':';\n\n  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.\n  // unless they had them to begin with.\n  if (this.slashes ||\n      (!protocol || slashedProtocol[protocol]) && host !== false) {\n    host = '//' + (host || '');\n    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;\n  } else if (!host) {\n    host = '';\n  }\n\n  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;\n  if (search && search.charAt(0) !== '?') search = '?' + search;\n\n  pathname = pathname.replace(/[?#]/g, function(match) {\n    return encodeURIComponent(match);\n  });\n  search = search.replace('#', '%23');\n\n  return protocol + host + pathname + search + hash;\n};\n\nfunction urlResolve(source, relative) {\n  return urlParse(source, false, true).resolve(relative);\n}\n\nUrl.prototype.resolve = function(relative) {\n  return this.resolveObject(urlParse(relative, false, true)).format();\n};\n\nfunction urlResolveObject(source, relative) {\n  if (!source) return relative;\n  return urlParse(source, false, true).resolveObject(relative);\n}\n\nUrl.prototype.resolveObject = function(relative) {\n  if (util.isString(relative)) {\n    var rel = new Url();\n    rel.parse(relative, false, true);\n    relative = rel;\n  }\n\n  var result = new Url();\n  var tkeys = Object.keys(this);\n  for (var tk = 0; tk < tkeys.length; tk++) {\n    var tkey = tkeys[tk];\n    result[tkey] = this[tkey];\n  }\n\n  // hash is always overridden, no matter what.\n  // even href=\"\" will remove it.\n  result.hash = relative.hash;\n\n  // if the relative url is empty, then there's nothing left to do here.\n  if (relative.href === '') {\n    result.href = result.format();\n    return result;\n  }\n\n  // hrefs like //foo/bar always cut to the protocol.\n  if (relative.slashes && !relative.protocol) {\n    // take everything except the protocol from relative\n    var rkeys = Object.keys(relative);\n    for (var rk = 0; rk < rkeys.length; rk++) {\n      var rkey = rkeys[rk];\n      if (rkey !== 'protocol')\n        result[rkey] = relative[rkey];\n    }\n\n    //urlParse appends trailing / to urls like http://www.example.com\n    if (slashedProtocol[result.protocol] &&\n        result.hostname && !result.pathname) {\n      result.path = result.pathname = '/';\n    }\n\n    result.href = result.format();\n    return result;\n  }\n\n  if (relative.protocol && relative.protocol !== result.protocol) {\n    // if it's a known url protocol, then changing\n    // the protocol does weird things\n    // first, if it's not file:, then we MUST have a host,\n    // and if there was a path\n    // to begin with, then we MUST have a path.\n    // if it is file:, then the host is dropped,\n    // because that's known to be hostless.\n    // anything else is assumed to be absolute.\n    if (!slashedProtocol[relative.protocol]) {\n      var keys = Object.keys(relative);\n      for (var v = 0; v < keys.length; v++) {\n        var k = keys[v];\n        result[k] = relative[k];\n      }\n      result.href = result.format();\n      return result;\n    }\n\n    result.protocol = relative.protocol;\n    if (!relative.host && !hostlessProtocol[relative.protocol]) {\n      var relPath = (relative.pathname || '').split('/');\n      while (relPath.length && !(relative.host = relPath.shift()));\n      if (!relative.host) relative.host = '';\n      if (!relative.hostname) relative.hostname = '';\n      if (relPath[0] !== '') relPath.unshift('');\n      if (relPath.length < 2) relPath.unshift('');\n      result.pathname = relPath.join('/');\n    } else {\n      result.pathname = relative.pathname;\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    result.host = relative.host || '';\n    result.auth = relative.auth;\n    result.hostname = relative.hostname || relative.host;\n    result.port = relative.port;\n    // to support http.request\n    if (result.pathname || result.search) {\n      var p = result.pathname || '';\n      var s = result.search || '';\n      result.path = p + s;\n    }\n    result.slashes = result.slashes || relative.slashes;\n    result.href = result.format();\n    return result;\n  }\n\n  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),\n      isRelAbs = (\n          relative.host ||\n          relative.pathname && relative.pathname.charAt(0) === '/'\n      ),\n      mustEndAbs = (isRelAbs || isSourceAbs ||\n                    (result.host && relative.pathname)),\n      removeAllDots = mustEndAbs,\n      srcPath = result.pathname && result.pathname.split('/') || [],\n      relPath = relative.pathname && relative.pathname.split('/') || [],\n      psychotic = result.protocol && !slashedProtocol[result.protocol];\n\n  // if the url is a non-slashed url, then relative\n  // links like ../.. should be able\n  // to crawl up to the hostname, as well.  This is strange.\n  // result.protocol has already been set by now.\n  // Later on, put the first path part into the host field.\n  if (psychotic) {\n    result.hostname = '';\n    result.port = null;\n    if (result.host) {\n      if (srcPath[0] === '') srcPath[0] = result.host;\n      else srcPath.unshift(result.host);\n    }\n    result.host = '';\n    if (relative.protocol) {\n      relative.hostname = null;\n      relative.port = null;\n      if (relative.host) {\n        if (relPath[0] === '') relPath[0] = relative.host;\n        else relPath.unshift(relative.host);\n      }\n      relative.host = null;\n    }\n    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\n  }\n\n  if (isRelAbs) {\n    // it's absolute.\n    result.host = (relative.host || relative.host === '') ?\n                  relative.host : result.host;\n    result.hostname = (relative.hostname || relative.hostname === '') ?\n                      relative.hostname : result.hostname;\n    result.search = relative.search;\n    result.query = relative.query;\n    srcPath = relPath;\n    // fall through to the dot-handling below.\n  } else if (relPath.length) {\n    // it's relative\n    // throw away the existing file, and take the new path instead.\n    if (!srcPath) srcPath = [];\n    srcPath.pop();\n    srcPath = srcPath.concat(relPath);\n    result.search = relative.search;\n    result.query = relative.query;\n  } else if (!util.isNullOrUndefined(relative.search)) {\n    // just pull out the search.\n    // like href='?foo'.\n    // Put this after the other two cases because it simplifies the booleans\n    if (psychotic) {\n      result.hostname = result.host = srcPath.shift();\n      //occationaly the auth can get stuck only in host\n      //this especially happens in cases like\n      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n      var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                       result.host.split('@') : false;\n      if (authInHost) {\n        result.auth = authInHost.shift();\n        result.host = result.hostname = authInHost.shift();\n      }\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    //to support http.request\n    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n      result.path = (result.pathname ? result.pathname : '') +\n                    (result.search ? result.search : '');\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  if (!srcPath.length) {\n    // no path at all.  easy.\n    // we've already handled the other stuff above.\n    result.pathname = null;\n    //to support http.request\n    if (result.search) {\n      result.path = '/' + result.search;\n    } else {\n      result.path = null;\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  // if a url ENDs in . or .., then it must get a trailing slash.\n  // however, if it ends in anything else non-slashy,\n  // then it must NOT get a trailing slash.\n  var last = srcPath.slice(-1)[0];\n  var hasTrailingSlash = (\n      (result.host || relative.host || srcPath.length > 1) &&\n      (last === '.' || last === '..') || last === '');\n\n  // strip single dots, resolve double dots to parent dir\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = srcPath.length; i >= 0; i--) {\n    last = srcPath[i];\n    if (last === '.') {\n      srcPath.splice(i, 1);\n    } else if (last === '..') {\n      srcPath.splice(i, 1);\n      up++;\n    } else if (up) {\n      srcPath.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (!mustEndAbs && !removeAllDots) {\n    for (; up--; up) {\n      srcPath.unshift('..');\n    }\n  }\n\n  if (mustEndAbs && srcPath[0] !== '' &&\n      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {\n    srcPath.unshift('');\n  }\n\n  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {\n    srcPath.push('');\n  }\n\n  var isAbsolute = srcPath[0] === '' ||\n      (srcPath[0] && srcPath[0].charAt(0) === '/');\n\n  // put the host back\n  if (psychotic) {\n    result.hostname = result.host = isAbsolute ? '' :\n                                    srcPath.length ? srcPath.shift() : '';\n    //occationaly the auth can get stuck only in host\n    //this especially happens in cases like\n    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n    var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                     result.host.split('@') : false;\n    if (authInHost) {\n      result.auth = authInHost.shift();\n      result.host = result.hostname = authInHost.shift();\n    }\n  }\n\n  mustEndAbs = mustEndAbs || (result.host && srcPath.length);\n\n  if (mustEndAbs && !isAbsolute) {\n    srcPath.unshift('');\n  }\n\n  if (!srcPath.length) {\n    result.pathname = null;\n    result.path = null;\n  } else {\n    result.pathname = srcPath.join('/');\n  }\n\n  //to support request.http\n  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n    result.path = (result.pathname ? result.pathname : '') +\n                  (result.search ? result.search : '');\n  }\n  result.auth = relative.auth || result.auth;\n  result.slashes = result.slashes || relative.slashes;\n  result.href = result.format();\n  return result;\n};\n\nUrl.prototype.parseHost = function() {\n  var host = this.host;\n  var port = portPattern.exec(host);\n  if (port) {\n    port = port[0];\n    if (port !== ':') {\n      this.port = port.substr(1);\n    }\n    host = host.substr(0, host.length - port.length);\n  }\n  if (host) this.hostname = host;\n};\n","'use strict';\n\nmodule.exports = {\n  isString: function(arg) {\n    return typeof(arg) === 'string';\n  },\n  isObject: function(arg) {\n    return typeof(arg) === 'object' && arg !== null;\n  },\n  isNull: function(arg) {\n    return arg === null;\n  },\n  isNullOrUndefined: function(arg) {\n    return arg == null;\n  }\n};\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","// Currently in sync with Node.js lib/internal/util/types.js\n// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9\n\n'use strict';\n\nvar isArgumentsObject = require('is-arguments');\nvar isGeneratorFunction = require('is-generator-function');\nvar whichTypedArray = require('which-typed-array');\nvar isTypedArray = require('is-typed-array');\n\nfunction uncurryThis(f) {\n  return f.call.bind(f);\n}\n\nvar BigIntSupported = typeof BigInt !== 'undefined';\nvar SymbolSupported = typeof Symbol !== 'undefined';\n\nvar ObjectToString = uncurryThis(Object.prototype.toString);\n\nvar numberValue = uncurryThis(Number.prototype.valueOf);\nvar stringValue = uncurryThis(String.prototype.valueOf);\nvar booleanValue = uncurryThis(Boolean.prototype.valueOf);\n\nif (BigIntSupported) {\n  var bigIntValue = uncurryThis(BigInt.prototype.valueOf);\n}\n\nif (SymbolSupported) {\n  var symbolValue = uncurryThis(Symbol.prototype.valueOf);\n}\n\nfunction checkBoxedPrimitive(value, prototypeValueOf) {\n  if (typeof value !== 'object') {\n    return false;\n  }\n  try {\n    prototypeValueOf(value);\n    return true;\n  } catch(e) {\n    return false;\n  }\n}\n\nexports.isArgumentsObject = isArgumentsObject;\nexports.isGeneratorFunction = isGeneratorFunction;\nexports.isTypedArray = isTypedArray;\n\n// Taken from here and modified for better browser support\n// https://github.com/sindresorhus/p-is-promise/blob/cda35a513bda03f977ad5cde3a079d237e82d7ef/index.js\nfunction isPromise(input) {\n\treturn (\n\t\t(\n\t\t\ttypeof Promise !== 'undefined' &&\n\t\t\tinput instanceof Promise\n\t\t) ||\n\t\t(\n\t\t\tinput !== null &&\n\t\t\ttypeof input === 'object' &&\n\t\t\ttypeof input.then === 'function' &&\n\t\t\ttypeof input.catch === 'function'\n\t\t)\n\t);\n}\nexports.isPromise = isPromise;\n\nfunction isArrayBufferView(value) {\n  if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {\n    return ArrayBuffer.isView(value);\n  }\n\n  return (\n    isTypedArray(value) ||\n    isDataView(value)\n  );\n}\nexports.isArrayBufferView = isArrayBufferView;\n\n\nfunction isUint8Array(value) {\n  return whichTypedArray(value) === 'Uint8Array';\n}\nexports.isUint8Array = isUint8Array;\n\nfunction isUint8ClampedArray(value) {\n  return whichTypedArray(value) === 'Uint8ClampedArray';\n}\nexports.isUint8ClampedArray = isUint8ClampedArray;\n\nfunction isUint16Array(value) {\n  return whichTypedArray(value) === 'Uint16Array';\n}\nexports.isUint16Array = isUint16Array;\n\nfunction isUint32Array(value) {\n  return whichTypedArray(value) === 'Uint32Array';\n}\nexports.isUint32Array = isUint32Array;\n\nfunction isInt8Array(value) {\n  return whichTypedArray(value) === 'Int8Array';\n}\nexports.isInt8Array = isInt8Array;\n\nfunction isInt16Array(value) {\n  return whichTypedArray(value) === 'Int16Array';\n}\nexports.isInt16Array = isInt16Array;\n\nfunction isInt32Array(value) {\n  return whichTypedArray(value) === 'Int32Array';\n}\nexports.isInt32Array = isInt32Array;\n\nfunction isFloat32Array(value) {\n  return whichTypedArray(value) === 'Float32Array';\n}\nexports.isFloat32Array = isFloat32Array;\n\nfunction isFloat64Array(value) {\n  return whichTypedArray(value) === 'Float64Array';\n}\nexports.isFloat64Array = isFloat64Array;\n\nfunction isBigInt64Array(value) {\n  return whichTypedArray(value) === 'BigInt64Array';\n}\nexports.isBigInt64Array = isBigInt64Array;\n\nfunction isBigUint64Array(value) {\n  return whichTypedArray(value) === 'BigUint64Array';\n}\nexports.isBigUint64Array = isBigUint64Array;\n\nfunction isMapToString(value) {\n  return ObjectToString(value) === '[object Map]';\n}\nisMapToString.working = (\n  typeof Map !== 'undefined' &&\n  isMapToString(new Map())\n);\n\nfunction isMap(value) {\n  if (typeof Map === 'undefined') {\n    return false;\n  }\n\n  return isMapToString.working\n    ? isMapToString(value)\n    : value instanceof Map;\n}\nexports.isMap = isMap;\n\nfunction isSetToString(value) {\n  return ObjectToString(value) === '[object Set]';\n}\nisSetToString.working = (\n  typeof Set !== 'undefined' &&\n  isSetToString(new Set())\n);\nfunction isSet(value) {\n  if (typeof Set === 'undefined') {\n    return false;\n  }\n\n  return isSetToString.working\n    ? isSetToString(value)\n    : value instanceof Set;\n}\nexports.isSet = isSet;\n\nfunction isWeakMapToString(value) {\n  return ObjectToString(value) === '[object WeakMap]';\n}\nisWeakMapToString.working = (\n  typeof WeakMap !== 'undefined' &&\n  isWeakMapToString(new WeakMap())\n);\nfunction isWeakMap(value) {\n  if (typeof WeakMap === 'undefined') {\n    return false;\n  }\n\n  return isWeakMapToString.working\n    ? isWeakMapToString(value)\n    : value instanceof WeakMap;\n}\nexports.isWeakMap = isWeakMap;\n\nfunction isWeakSetToString(value) {\n  return ObjectToString(value) === '[object WeakSet]';\n}\nisWeakSetToString.working = (\n  typeof WeakSet !== 'undefined' &&\n  isWeakSetToString(new WeakSet())\n);\nfunction isWeakSet(value) {\n  return isWeakSetToString(value);\n}\nexports.isWeakSet = isWeakSet;\n\nfunction isArrayBufferToString(value) {\n  return ObjectToString(value) === '[object ArrayBuffer]';\n}\nisArrayBufferToString.working = (\n  typeof ArrayBuffer !== 'undefined' &&\n  isArrayBufferToString(new ArrayBuffer())\n);\nfunction isArrayBuffer(value) {\n  if (typeof ArrayBuffer === 'undefined') {\n    return false;\n  }\n\n  return isArrayBufferToString.working\n    ? isArrayBufferToString(value)\n    : value instanceof ArrayBuffer;\n}\nexports.isArrayBuffer = isArrayBuffer;\n\nfunction isDataViewToString(value) {\n  return ObjectToString(value) === '[object DataView]';\n}\nisDataViewToString.working = (\n  typeof ArrayBuffer !== 'undefined' &&\n  typeof DataView !== 'undefined' &&\n  isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1))\n);\nfunction isDataView(value) {\n  if (typeof DataView === 'undefined') {\n    return false;\n  }\n\n  return isDataViewToString.working\n    ? isDataViewToString(value)\n    : value instanceof DataView;\n}\nexports.isDataView = isDataView;\n\n// Store a copy of SharedArrayBuffer in case it's deleted elsewhere\nvar SharedArrayBufferCopy = typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : undefined;\nfunction isSharedArrayBufferToString(value) {\n  return ObjectToString(value) === '[object SharedArrayBuffer]';\n}\nfunction isSharedArrayBuffer(value) {\n  if (typeof SharedArrayBufferCopy === 'undefined') {\n    return false;\n  }\n\n  if (typeof isSharedArrayBufferToString.working === 'undefined') {\n    isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy());\n  }\n\n  return isSharedArrayBufferToString.working\n    ? isSharedArrayBufferToString(value)\n    : value instanceof SharedArrayBufferCopy;\n}\nexports.isSharedArrayBuffer = isSharedArrayBuffer;\n\nfunction isAsyncFunction(value) {\n  return ObjectToString(value) === '[object AsyncFunction]';\n}\nexports.isAsyncFunction = isAsyncFunction;\n\nfunction isMapIterator(value) {\n  return ObjectToString(value) === '[object Map Iterator]';\n}\nexports.isMapIterator = isMapIterator;\n\nfunction isSetIterator(value) {\n  return ObjectToString(value) === '[object Set Iterator]';\n}\nexports.isSetIterator = isSetIterator;\n\nfunction isGeneratorObject(value) {\n  return ObjectToString(value) === '[object Generator]';\n}\nexports.isGeneratorObject = isGeneratorObject;\n\nfunction isWebAssemblyCompiledModule(value) {\n  return ObjectToString(value) === '[object WebAssembly.Module]';\n}\nexports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;\n\nfunction isNumberObject(value) {\n  return checkBoxedPrimitive(value, numberValue);\n}\nexports.isNumberObject = isNumberObject;\n\nfunction isStringObject(value) {\n  return checkBoxedPrimitive(value, stringValue);\n}\nexports.isStringObject = isStringObject;\n\nfunction isBooleanObject(value) {\n  return checkBoxedPrimitive(value, booleanValue);\n}\nexports.isBooleanObject = isBooleanObject;\n\nfunction isBigIntObject(value) {\n  return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);\n}\nexports.isBigIntObject = isBigIntObject;\n\nfunction isSymbolObject(value) {\n  return SymbolSupported && checkBoxedPrimitive(value, symbolValue);\n}\nexports.isSymbolObject = isSymbolObject;\n\nfunction isBoxedPrimitive(value) {\n  return (\n    isNumberObject(value) ||\n    isStringObject(value) ||\n    isBooleanObject(value) ||\n    isBigIntObject(value) ||\n    isSymbolObject(value)\n  );\n}\nexports.isBoxedPrimitive = isBoxedPrimitive;\n\nfunction isAnyArrayBuffer(value) {\n  return typeof Uint8Array !== 'undefined' && (\n    isArrayBuffer(value) ||\n    isSharedArrayBuffer(value)\n  );\n}\nexports.isAnyArrayBuffer = isAnyArrayBuffer;\n\n['isProxy', 'isExternal', 'isModuleNamespaceObject'].forEach(function(method) {\n  Object.defineProperty(exports, method, {\n    enumerable: false,\n    value: function() {\n      throw new Error(method + ' is not supported in userland');\n    }\n  });\n});\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||\n  function getOwnPropertyDescriptors(obj) {\n    var keys = Object.keys(obj);\n    var descriptors = {};\n    for (var i = 0; i < keys.length; i++) {\n      descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);\n    }\n    return descriptors;\n  };\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  if (typeof process !== 'undefined' && process.noDeprecation === true) {\n    return fn;\n  }\n\n  // Allow for deprecating things in the process of starting up.\n  if (typeof process === 'undefined') {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnvRegex = /^$/;\n\nif (process.env.NODE_DEBUG) {\n  var debugEnv = process.env.NODE_DEBUG;\n  debugEnv = debugEnv.replace(/[|\\\\{}()[\\]^$+?.]/g, '\\\\$&')\n    .replace(/\\*/g, '.*')\n    .replace(/,/g, '$|^')\n    .toUpperCase();\n  debugEnvRegex = new RegExp('^' + debugEnv + '$', 'i');\n}\nexports.debuglog = function(set) {\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (debugEnvRegex.test(set)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').slice(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.slice(1, -1);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nexports.types = require('./support/types');\n\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\nexports.types.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\nexports.types.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\nexports.types.isNativeError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nvar kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;\n\nexports.promisify = function promisify(original) {\n  if (typeof original !== 'function')\n    throw new TypeError('The \"original\" argument must be of type Function');\n\n  if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {\n    var fn = original[kCustomPromisifiedSymbol];\n    if (typeof fn !== 'function') {\n      throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n    }\n    Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n      value: fn, enumerable: false, writable: false, configurable: true\n    });\n    return fn;\n  }\n\n  function fn() {\n    var promiseResolve, promiseReject;\n    var promise = new Promise(function (resolve, reject) {\n      promiseResolve = resolve;\n      promiseReject = reject;\n    });\n\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n    args.push(function (err, value) {\n      if (err) {\n        promiseReject(err);\n      } else {\n        promiseResolve(value);\n      }\n    });\n\n    try {\n      original.apply(this, args);\n    } catch (err) {\n      promiseReject(err);\n    }\n\n    return promise;\n  }\n\n  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));\n\n  if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n    value: fn, enumerable: false, writable: false, configurable: true\n  });\n  return Object.defineProperties(\n    fn,\n    getOwnPropertyDescriptors(original)\n  );\n}\n\nexports.promisify.custom = kCustomPromisifiedSymbol\n\nfunction callbackifyOnRejected(reason, cb) {\n  // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).\n  // Because `null` is a special error value in callbacks which means \"no error\n  // occurred\", we error-wrap so the callback consumer can distinguish between\n  // \"the promise rejected with null\" or \"the promise fulfilled with undefined\".\n  if (!reason) {\n    var newReason = new Error('Promise was rejected with a falsy value');\n    newReason.reason = reason;\n    reason = newReason;\n  }\n  return cb(reason);\n}\n\nfunction callbackify(original) {\n  if (typeof original !== 'function') {\n    throw new TypeError('The \"original\" argument must be of type Function');\n  }\n\n  // We DO NOT return the promise as it gives the user a false sense that\n  // the promise is actually somehow related to the callback's execution\n  // and that the callback throwing will reject the promise.\n  function callbackified() {\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n\n    var maybeCb = args.pop();\n    if (typeof maybeCb !== 'function') {\n      throw new TypeError('The last argument must be of type Function');\n    }\n    var self = this;\n    var cb = function() {\n      return maybeCb.apply(self, arguments);\n    };\n    // In true node style we process the callback on `nextTick` with all the\n    // implications (stack, `uncaughtException`, `async_hooks`)\n    original.apply(this, args)\n      .then(function(ret) { process.nextTick(cb.bind(null, null, ret)) },\n            function(rej) { process.nextTick(callbackifyOnRejected.bind(null, rej, cb)) });\n  }\n\n  Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n  Object.defineProperties(callbackified,\n                          getOwnPropertyDescriptors(original));\n  return callbackified;\n}\nexports.callbackify = callbackify;\n","'use strict';\n\nvar forEach = require('for-each');\nvar availableTypedArrays = require('available-typed-arrays');\nvar callBound = require('call-bind/callBound');\nvar gOPD = require('gopd');\n\nvar $toString = callBound('Object.prototype.toString');\nvar hasToStringTag = require('has-tostringtag/shams')();\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\nvar typedArrays = availableTypedArrays();\n\nvar $slice = callBound('String.prototype.slice');\nvar toStrTags = {};\nvar getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');\nif (hasToStringTag && gOPD && getPrototypeOf) {\n\tforEach(typedArrays, function (typedArray) {\n\t\tif (typeof g[typedArray] === 'function') {\n\t\t\tvar arr = new g[typedArray]();\n\t\t\tif (Symbol.toStringTag in arr) {\n\t\t\t\tvar proto = getPrototypeOf(arr);\n\t\t\t\tvar descriptor = gOPD(proto, Symbol.toStringTag);\n\t\t\t\tif (!descriptor) {\n\t\t\t\t\tvar superProto = getPrototypeOf(proto);\n\t\t\t\t\tdescriptor = gOPD(superProto, Symbol.toStringTag);\n\t\t\t\t}\n\t\t\t\ttoStrTags[typedArray] = descriptor.get;\n\t\t\t}\n\t\t}\n\t});\n}\n\nvar tryTypedArrays = function tryAllTypedArrays(value) {\n\tvar foundName = false;\n\tforEach(toStrTags, function (getter, typedArray) {\n\t\tif (!foundName) {\n\t\t\ttry {\n\t\t\t\tvar name = getter.call(value);\n\t\t\t\tif (name === typedArray) {\n\t\t\t\t\tfoundName = name;\n\t\t\t\t}\n\t\t\t} catch (e) {}\n\t\t}\n\t});\n\treturn foundName;\n};\n\nvar isTypedArray = require('is-typed-array');\n\nmodule.exports = function whichTypedArray(value) {\n\tif (!isTypedArray(value)) { return false; }\n\tif (!hasToStringTag || !(Symbol.toStringTag in value)) { return $slice($toString(value), 8, -1); }\n\treturn tryTypedArrays(value);\n};\n","module.exports = __WEBPACK_EXTERNAL_MODULE__8392__;","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction _regeneratorRuntime() {\n  \"use strict\"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */\n  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {\n    return e;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  var t,\n    e = {},\n    r = Object.prototype,\n    n = r.hasOwnProperty,\n    o = Object.defineProperty || function (t, e, r) {\n      t[e] = r.value;\n    },\n    i = \"function\" == typeof Symbol ? Symbol : {},\n    a = i.iterator || \"@@iterator\",\n    c = i.asyncIterator || \"@@asyncIterator\",\n    u = i.toStringTag || \"@@toStringTag\";\n  function define(t, e, r) {\n    return Object.defineProperty(t, e, {\n      value: r,\n      enumerable: !0,\n      configurable: !0,\n      writable: !0\n    }), t[e];\n  }\n  try {\n    define({}, \"\");\n  } catch (t) {\n    define = function define(t, e, r) {\n      return t[e] = r;\n    };\n  }\n  function wrap(t, e, r, n) {\n    var i = e && e.prototype instanceof Generator ? e : Generator,\n      a = Object.create(i.prototype),\n      c = new Context(n || []);\n    return o(a, \"_invoke\", {\n      value: makeInvokeMethod(t, r, c)\n    }), a;\n  }\n  function tryCatch(t, e, r) {\n    try {\n      return {\n        type: \"normal\",\n        arg: t.call(e, r)\n      };\n    } catch (t) {\n      return {\n        type: \"throw\",\n        arg: t\n      };\n    }\n  }\n  e.wrap = wrap;\n  var h = \"suspendedStart\",\n    l = \"suspendedYield\",\n    f = \"executing\",\n    s = \"completed\",\n    y = {};\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n  var p = {};\n  define(p, a, function () {\n    return this;\n  });\n  var d = Object.getPrototypeOf,\n    v = d && d(d(values([])));\n  v && v !== r && n.call(v, a) && (p = v);\n  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);\n  function defineIteratorMethods(t) {\n    [\"next\", \"throw\", \"return\"].forEach(function (e) {\n      define(t, e, function (t) {\n        return this._invoke(e, t);\n      });\n    });\n  }\n  function AsyncIterator(t, e) {\n    function invoke(r, o, i, a) {\n      var c = tryCatch(t[r], t, o);\n      if (\"throw\" !== c.type) {\n        var u = c.arg,\n          h = u.value;\n        return h && \"object\" == _typeof(h) && n.call(h, \"__await\") ? e.resolve(h.__await).then(function (t) {\n          invoke(\"next\", t, i, a);\n        }, function (t) {\n          invoke(\"throw\", t, i, a);\n        }) : e.resolve(h).then(function (t) {\n          u.value = t, i(u);\n        }, function (t) {\n          return invoke(\"throw\", t, i, a);\n        });\n      }\n      a(c.arg);\n    }\n    var r;\n    o(this, \"_invoke\", {\n      value: function value(t, n) {\n        function callInvokeWithMethodAndArg() {\n          return new e(function (e, r) {\n            invoke(t, n, e, r);\n          });\n        }\n        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();\n      }\n    });\n  }\n  function makeInvokeMethod(e, r, n) {\n    var o = h;\n    return function (i, a) {\n      if (o === f) throw Error(\"Generator is already running\");\n      if (o === s) {\n        if (\"throw\" === i) throw a;\n        return {\n          value: t,\n          done: !0\n        };\n      }\n      for (n.method = i, n.arg = a;;) {\n        var c = n.delegate;\n        if (c) {\n          var u = maybeInvokeDelegate(c, n);\n          if (u) {\n            if (u === y) continue;\n            return u;\n          }\n        }\n        if (\"next\" === n.method) n.sent = n._sent = n.arg;else if (\"throw\" === n.method) {\n          if (o === h) throw o = s, n.arg;\n          n.dispatchException(n.arg);\n        } else \"return\" === n.method && n.abrupt(\"return\", n.arg);\n        o = f;\n        var p = tryCatch(e, r, n);\n        if (\"normal\" === p.type) {\n          if (o = n.done ? s : l, p.arg === y) continue;\n          return {\n            value: p.arg,\n            done: n.done\n          };\n        }\n        \"throw\" === p.type && (o = s, n.method = \"throw\", n.arg = p.arg);\n      }\n    };\n  }\n  function maybeInvokeDelegate(e, r) {\n    var n = r.method,\n      o = e.iterator[n];\n    if (o === t) return r.delegate = null, \"throw\" === n && e.iterator[\"return\"] && (r.method = \"return\", r.arg = t, maybeInvokeDelegate(e, r), \"throw\" === r.method) || \"return\" !== n && (r.method = \"throw\", r.arg = new TypeError(\"The iterator does not provide a '\" + n + \"' method\")), y;\n    var i = tryCatch(o, e.iterator, r.arg);\n    if (\"throw\" === i.type) return r.method = \"throw\", r.arg = i.arg, r.delegate = null, y;\n    var a = i.arg;\n    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, \"return\" !== r.method && (r.method = \"next\", r.arg = t), r.delegate = null, y) : a : (r.method = \"throw\", r.arg = new TypeError(\"iterator result is not an object\"), r.delegate = null, y);\n  }\n  function pushTryEntry(t) {\n    var e = {\n      tryLoc: t[0]\n    };\n    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);\n  }\n  function resetTryEntry(t) {\n    var e = t.completion || {};\n    e.type = \"normal\", delete e.arg, t.completion = e;\n  }\n  function Context(t) {\n    this.tryEntries = [{\n      tryLoc: \"root\"\n    }], t.forEach(pushTryEntry, this), this.reset(!0);\n  }\n  function values(e) {\n    if (e || \"\" === e) {\n      var r = e[a];\n      if (r) return r.call(e);\n      if (\"function\" == typeof e.next) return e;\n      if (!isNaN(e.length)) {\n        var o = -1,\n          i = function next() {\n            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;\n            return next.value = t, next.done = !0, next;\n          };\n        return i.next = i;\n      }\n    }\n    throw new TypeError(_typeof(e) + \" is not iterable\");\n  }\n  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, \"constructor\", {\n    value: GeneratorFunctionPrototype,\n    configurable: !0\n  }), o(GeneratorFunctionPrototype, \"constructor\", {\n    value: GeneratorFunction,\n    configurable: !0\n  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, \"GeneratorFunction\"), e.isGeneratorFunction = function (t) {\n    var e = \"function\" == typeof t && t.constructor;\n    return !!e && (e === GeneratorFunction || \"GeneratorFunction\" === (e.displayName || e.name));\n  }, e.mark = function (t) {\n    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, \"GeneratorFunction\")), t.prototype = Object.create(g), t;\n  }, e.awrap = function (t) {\n    return {\n      __await: t\n    };\n  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {\n    return this;\n  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {\n    void 0 === i && (i = Promise);\n    var a = new AsyncIterator(wrap(t, r, n, o), i);\n    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {\n      return t.done ? t.value : a.next();\n    });\n  }, defineIteratorMethods(g), define(g, u, \"Generator\"), define(g, a, function () {\n    return this;\n  }), define(g, \"toString\", function () {\n    return \"[object Generator]\";\n  }), e.keys = function (t) {\n    var e = Object(t),\n      r = [];\n    for (var n in e) r.push(n);\n    return r.reverse(), function next() {\n      for (; r.length;) {\n        var t = r.pop();\n        if (t in e) return next.value = t, next.done = !1, next;\n      }\n      return next.done = !0, next;\n    };\n  }, e.values = values, Context.prototype = {\n    constructor: Context,\n    reset: function reset(e) {\n      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = \"next\", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) \"t\" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);\n    },\n    stop: function stop() {\n      this.done = !0;\n      var t = this.tryEntries[0].completion;\n      if (\"throw\" === t.type) throw t.arg;\n      return this.rval;\n    },\n    dispatchException: function dispatchException(e) {\n      if (this.done) throw e;\n      var r = this;\n      function handle(n, o) {\n        return a.type = \"throw\", a.arg = e, r.next = n, o && (r.method = \"next\", r.arg = t), !!o;\n      }\n      for (var o = this.tryEntries.length - 1; o >= 0; --o) {\n        var i = this.tryEntries[o],\n          a = i.completion;\n        if (\"root\" === i.tryLoc) return handle(\"end\");\n        if (i.tryLoc <= this.prev) {\n          var c = n.call(i, \"catchLoc\"),\n            u = n.call(i, \"finallyLoc\");\n          if (c && u) {\n            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);\n            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);\n          } else if (c) {\n            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);\n          } else {\n            if (!u) throw Error(\"try statement without catch or finally\");\n            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);\n          }\n        }\n      }\n    },\n    abrupt: function abrupt(t, e) {\n      for (var r = this.tryEntries.length - 1; r >= 0; --r) {\n        var o = this.tryEntries[r];\n        if (o.tryLoc <= this.prev && n.call(o, \"finallyLoc\") && this.prev < o.finallyLoc) {\n          var i = o;\n          break;\n        }\n      }\n      i && (\"break\" === t || \"continue\" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);\n      var a = i ? i.completion : {};\n      return a.type = t, a.arg = e, i ? (this.method = \"next\", this.next = i.finallyLoc, y) : this.complete(a);\n    },\n    complete: function complete(t, e) {\n      if (\"throw\" === t.type) throw t.arg;\n      return \"break\" === t.type || \"continue\" === t.type ? this.next = t.arg : \"return\" === t.type ? (this.rval = this.arg = t.arg, this.method = \"return\", this.next = \"end\") : \"normal\" === t.type && e && (this.next = e), y;\n    },\n    finish: function finish(t) {\n      for (var e = this.tryEntries.length - 1; e >= 0; --e) {\n        var r = this.tryEntries[e];\n        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;\n      }\n    },\n    \"catch\": function _catch(t) {\n      for (var e = this.tryEntries.length - 1; e >= 0; --e) {\n        var r = this.tryEntries[e];\n        if (r.tryLoc === t) {\n          var n = r.completion;\n          if (\"throw\" === n.type) {\n            var o = n.arg;\n            resetTryEntry(r);\n          }\n          return o;\n        }\n      }\n      throw Error(\"illegal catch attempt\");\n    },\n    delegateYield: function delegateYield(e, r, n) {\n      return this.delegate = {\n        iterator: values(e),\n        resultName: r,\n        nextLoc: n\n      }, \"next\" === this.method && (this.arg = t), y;\n    }\n  }, e;\n}\nmodule.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(o);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","// TODO(Babel 8): Remove this file.\n\nvar runtime = require(\"../helpers/regeneratorRuntime\")();\nmodule.exports = runtime;\n\n// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n","'use strict';\n\nvar possibleNames = [\n\t'BigInt64Array',\n\t'BigUint64Array',\n\t'Float32Array',\n\t'Float64Array',\n\t'Int16Array',\n\t'Int32Array',\n\t'Int8Array',\n\t'Uint16Array',\n\t'Uint32Array',\n\t'Uint8Array',\n\t'Uint8ClampedArray'\n];\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\n\nmodule.exports = function availableTypedArrays() {\n\tvar out = [];\n\tfor (var i = 0; i < possibleNames.length; i++) {\n\t\tif (typeof g[possibleNames[i]] === 'function') {\n\t\t\tout[out.length] = possibleNames[i];\n\t\t}\n\t}\n\treturn out;\n};\n","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);\n  }\n}\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}","import toPropertyKey from \"./toPropertyKey.js\";\nexport default function _defineProperty(obj, key, value) {\n  key = toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}","export default function _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}","export default function _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n  return _setPrototypeOf(o, p);\n}","import setPrototypeOf from \"./setPrototypeOf.js\";\nexport default function _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  Object.defineProperty(subClass, \"prototype\", {\n    writable: false\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}","import _typeof from \"./typeof.js\";\nimport assertThisInitialized from \"./assertThisInitialized.js\";\nexport default function _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  } else if (call !== void 0) {\n    throw new TypeError(\"Derived constructors may only return object or undefined\");\n  }\n  return assertThisInitialized(self);\n}","export default function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n  return self;\n}","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nexport default function toPropertyKey(t) {\n  var i = toPrimitive(t, \"string\");\n  return \"symbol\" == _typeof(i) ? i : i + \"\";\n}","import _typeof from \"./typeof.js\";\nexport default function toPrimitive(t, r) {\n  if (\"object\" != _typeof(t) || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != _typeof(i)) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}","export default function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, _typeof(o);\n}","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.f = {};\n// This file contains only the entry chunk.\n// The chunk loading function for additional chunks\n__webpack_require__.e = (chunkId) => {\n\treturn Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {\n\t\t__webpack_require__.f[key](chunkId, promises);\n\t\treturn promises;\n\t}, []));\n};","// This function allow to reference async chunks\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"\" + chunkId + \".rdflib.min.js\";\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.hmd = (module) => {\n\tmodule = Object.create(module);\n\tif (!module.children) module.children = [];\n\tObject.defineProperty(module, 'exports', {\n\t\tenumerable: true,\n\t\tset: () => {\n\t\t\tthrow new Error('ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + module.id);\n\t\t}\n\t});\n\treturn module;\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","var scriptUrl;\nif (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + \"\";\nvar document = __webpack_require__.g.document;\nif (!scriptUrl && document) {\n\tif (document.currentScript)\n\t\tscriptUrl = document.currentScript.src;\n\tif (!scriptUrl) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tif(scripts.length) {\n\t\t\tvar i = scripts.length - 1;\n\t\t\twhile (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;\n\t\t}\n\t}\n}\n// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration\n// or pass an empty string (\"\") and set the __webpack_public_path__ variable from your code to use your own logic.\nif (!scriptUrl) throw new Error(\"Automatic publicPath is not supported in this browser\");\nscriptUrl = scriptUrl.replace(/#.*$/, \"\").replace(/\\?.*$/, \"\").replace(/\\/[^\\/]+$/, \"/\");\n__webpack_require__.p = scriptUrl;","// no baseURI\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t792: 0\n};\n\n__webpack_require__.f.j = (chunkId, promises) => {\n\t\t// JSONP chunk loading for javascript\n\t\tvar installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;\n\t\tif(installedChunkData !== 0) { // 0 means \"already installed\".\n\n\t\t\t// a Promise means \"currently loading\".\n\t\t\tif(installedChunkData) {\n\t\t\t\tpromises.push(installedChunkData[2]);\n\t\t\t} else {\n\t\t\t\tif(true) { // all chunks have JS\n\t\t\t\t\t// setup Promise in chunk cache\n\t\t\t\t\tvar promise = new Promise((resolve, reject) => (installedChunkData = installedChunks[chunkId] = [resolve, reject]));\n\t\t\t\t\tpromises.push(installedChunkData[2] = promise);\n\n\t\t\t\t\t// start chunk loading\n\t\t\t\t\tvar url = __webpack_require__.p + __webpack_require__.u(chunkId);\n\t\t\t\t\t// create error before stack unwound to get useful stacktrace later\n\t\t\t\t\tvar error = new Error();\n\t\t\t\t\tvar loadingEnded = (event) => {\n\t\t\t\t\t\tif(__webpack_require__.o(installedChunks, chunkId)) {\n\t\t\t\t\t\t\tinstalledChunkData = installedChunks[chunkId];\n\t\t\t\t\t\t\tif(installedChunkData !== 0) installedChunks[chunkId] = undefined;\n\t\t\t\t\t\t\tif(installedChunkData) {\n\t\t\t\t\t\t\t\tvar errorType = event && (event.type === 'load' ? 'missing' : event.type);\n\t\t\t\t\t\t\t\tvar realSrc = event && event.target && event.target.src;\n\t\t\t\t\t\t\t\terror.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';\n\t\t\t\t\t\t\t\terror.name = 'ChunkLoadError';\n\t\t\t\t\t\t\t\terror.type = errorType;\n\t\t\t\t\t\t\t\terror.request = realSrc;\n\t\t\t\t\t\t\t\tinstalledChunkData[1](error);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\t__webpack_require__.l(url, loadingEnded, \"chunk-\" + chunkId, chunkId);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n};\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n// no on chunks loaded\n\n// install a JSONP callback for chunk loading\nvar webpackJsonpCallback = (parentChunkLoadingFunction, data) => {\n\tvar [chunkIds, moreModules, runtime] = data;\n\t// add \"moreModules\" to the modules object,\n\t// then flag all \"chunkIds\" as loaded and fire callback\n\tvar moduleId, chunkId, i = 0;\n\tif(chunkIds.some((id) => (installedChunks[id] !== 0))) {\n\t\tfor(moduleId in moreModules) {\n\t\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t\t}\n\t\t}\n\t\tif(runtime) var result = runtime(__webpack_require__);\n\t}\n\tif(parentChunkLoadingFunction) parentChunkLoadingFunction(data);\n\tfor(;i < chunkIds.length; i++) {\n\t\tchunkId = chunkIds[i];\n\t\tif(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {\n\t\t\tinstalledChunks[chunkId][0]();\n\t\t}\n\t\tinstalledChunks[chunkId] = 0;\n\t}\n\n}\n\nvar chunkLoadingGlobal = self[\"webpackChunk$rdf\"] = self[\"webpackChunk$rdf\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));","import ClassOrder from './class-order'\nimport Node from './node-internal'\nimport IndexedFormula from './store'\nimport { BlankNodeTermType } from './types'\nimport { BlankNode as TFBlankNode } from './tf-types'\n\n/**\n * An RDF blank node is a Node without a URI\n * @link https://rdf.js.org/data-model-spec/#blanknode-interface\n */\nexport default class BlankNode extends Node implements TFBlankNode {\n  termType: typeof BlankNodeTermType = BlankNodeTermType;\n  /**\n   * The next unique identifier for blank nodes\n   */\n  static nextId: number = 0;\n  static NTAnonymousNodePrefix: '_:' = '_:'\n\n  private static getId (id: string | unknown): string {\n    if (id) {\n      if (typeof id !== 'string') {\n        throw new Error('Bad id argument to new blank node: ' + id)\n      }\n\n      if (id.includes('#')) {\n        // Is a URI with hash fragment\n        let fragments = id.split('#')\n        return fragments[fragments.length - 1]\n      }\n\n      return id\n    }\n\n    return 'n' + BlankNode.nextId++\n  }\n\n  classOrder = ClassOrder.BlankNode\n  /** Whether this is a blank node */\n  isBlank: number = 1\n  /**\n   * This type of node is a variable.\n   *\n   * Note that the existence of this property already indicates that it is a variable.\n   */\n  isVar = 1\n\n  /**\n   * Initializes this node\n   * @param [id] The identifier for the blank node\n   */\n  constructor (id?: string | unknown) {\n    super(BlankNode.getId(id))\n  }\n\n  /**\n   * The identifier for the blank node\n   */\n  public get id (): string {\n    return this.value\n  }\n\n  public set id (value: string) {\n    this.value = value\n  }\n\n  compareTerm (other: BlankNode): number {\n    if (this.classOrder < other.classOrder) {\n      return -1\n    }\n    if (this.classOrder > other.classOrder) {\n      return +1\n    }\n    if (this.id < other.id) {\n      return -1\n    }\n    if (this.id > other.id) {\n      return +1\n    }\n    return 0\n  }\n\n  /**\n   * Gets a copy of this blank node in the specified formula\n   * @param formula The formula\n   */\n  copy (formula: IndexedFormula): BlankNode { // depends on the formula\n    var bnodeNew = new BlankNode()\n    formula.copyTo(this, bnodeNew)\n    return bnodeNew\n  }\n\n  toCanonical () {\n    return BlankNode.NTAnonymousNodePrefix + this.value\n  }\n\n  toString () {\n    return BlankNode.NTAnonymousNodePrefix + this.id\n  }\n}\n","import NamedNode from './named-node';\n\nexport default {\n  boolean: new NamedNode('http://www.w3.org/2001/XMLSchema#boolean'),\n  dateTime: new NamedNode('http://www.w3.org/2001/XMLSchema#dateTime'),\n  decimal: new NamedNode('http://www.w3.org/2001/XMLSchema#decimal'),\n  double: new NamedNode('http://www.w3.org/2001/XMLSchema#double'),\n  integer: new NamedNode('http://www.w3.org/2001/XMLSchema#integer'),\n  langString: new NamedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString'),\n  string: new NamedNode('http://www.w3.org/2001/XMLSchema#string'),\n}\n","import ClassOrder from './class-order'\nimport RDFlibNamedNode from './named-node'\nimport Node from './node-internal'\nimport {\n  FromValueReturns,\n  LiteralTermType,\n  ValueType\n} from './types'\nimport { isLiteral } from './utils/terms'\nimport XSD from './xsd-internal'\nimport { Literal as TFLiteral, Term } from './tf-types'\n\n/**\n * An RDF literal, containing some value which isn't expressed as an IRI.\n * @link https://rdf.js.org/data-model-spec/#literal-interface\n */\nexport default class Literal extends Node implements TFLiteral {\n  termType: typeof LiteralTermType = LiteralTermType\n\n  classOrder = ClassOrder.Literal\n\n  /**\n   * The literal's datatype as a named node\n   */\n  datatype: RDFlibNamedNode = XSD.string\n\n  isVar = 0\n\n  /**\n   * The language for the literal\n   */\n  language: string = ''\n\n  /**\n   * Initializes a literal\n   * @param value - The literal's lexical value\n   * @param language - The language for the literal. Defaults to ''.\n   * @param datatype - The literal's datatype as a named node. Defaults to xsd:string.\n   */\n  constructor (value: string, language?: string | null, datatype?) {\n    super(value)\n\n    if (language) {\n      this.language = language\n      this.datatype = XSD.langString\n    } else if (datatype) {\n      this.datatype = RDFlibNamedNode.fromValue(datatype)\n    } else {\n      this.datatype = XSD.string\n    }\n  }\n\n  /**\n   * Gets a copy of this literal\n   */\n  copy (): Literal {\n    return new Literal(this.value, this.lang, this.datatype)\n  }\n\n  /**\n   * Gets whether two literals are the same\n   * @param other The other statement\n   */\n  equals (other: Term): boolean {\n    if (!other) {\n      return false\n    }\n\n    return (this.termType === other.termType) &&\n      (this.value === other.value) &&\n      (this.language === (other as Literal).language) &&\n      ((!this.datatype && !(other as Literal).datatype) ||\n        (this.datatype && this.datatype.equals((other as Literal).datatype)))\n  }\n\n  /**\n   * The language for the literal\n   * @deprecated use {language} instead\n   */\n  get lang (): string {\n    return this.language\n  }\n\n  set lang (language: string) {\n    this.language = language || ''\n  }\n\n  toNT(): string {\n    return Literal.toNT(this)\n  }\n\n  /** Serializes a literal to an N-Triples string */\n  static toNT (literal: Literal): string {\n    if (typeof literal.value === 'number') {\n      return '' + literal.value\n    } else if (typeof literal.value !== 'string') {\n      throw new Error('Value of RDF literal is not string or number: ' +\n        literal.value)\n    }\n    var str = literal.value\n    // #x22 (\"), #x5C (\\), #x0A (\\n) and #xD (\\r) are disallowed and need to be replaced\n    // see https://www.w3.org/TR/n-triples/#grammar-production-STRING_LITERAL_QUOTE\n    str = str.replace(/\\\\/g, '\\\\\\\\')\n    str = str.replace(/\\\"/g, '\\\\\"')\n    str = str.replace(/\\n/g, '\\\\n')\n    str = str.replace(/\\r/g, '\\\\r')\n    str = '\"' + str + '\"'\n\n    if (literal.language) {\n      str += '@' + literal.language\n    } else if (!literal.datatype.equals(XSD.string)) {\n      // Only add datatype if it's not a string\n      str += '^^' + literal.datatype.toCanonical()\n    }\n    return str\n  }\n\n  toString () {\n    return '' + this.value\n  }\n\n  /**\n   * Builds a literal node from a boolean value\n   * @param value - The value\n   */\n  static fromBoolean (value: boolean): Literal {\n    let strValue = value ? '1' : '0'\n    return new Literal(strValue, null, XSD.boolean)\n  }\n\n  /**\n   * Builds a literal node from a date value\n   * @param value The value\n   */\n  static fromDate(value: Date): Literal {\n    if (!(value instanceof Date)) {\n      throw new TypeError('Invalid argument to Literal.fromDate()')\n    }\n    let d2 = function (x) {\n      return ('' + (100 + x)).slice(1, 3)\n    }\n    let date = '' + value.getUTCFullYear() + '-' + d2(value.getUTCMonth() + 1) +\n      '-' + d2(value.getUTCDate()) + 'T' + d2(value.getUTCHours()) + ':' +\n      d2(value.getUTCMinutes()) + ':' + d2(value.getUTCSeconds()) + 'Z'\n    return new Literal(date, null, XSD.dateTime)\n  }\n\n  /**\n   * Builds a literal node from a number value\n   * @param value - The value\n   */\n  static fromNumber(value: number): Literal {\n    if (typeof value !== 'number') {\n      throw new TypeError('Invalid argument to Literal.fromNumber()')\n    }\n    let datatype: RDFlibNamedNode\n    const strValue = value.toString()\n    if (strValue.indexOf('e') < 0 && Math.abs(value) <= Number.MAX_SAFE_INTEGER) {\n      datatype = Number.isInteger(value) ? XSD.integer : XSD.decimal\n    } else {\n      datatype = XSD.double\n    }\n    return new Literal(strValue, null, datatype)\n  }\n\n  /**\n   * Builds a literal node from an input value\n   * @param value - The input value\n   */\n  static fromValue<T extends FromValueReturns>(value: ValueType): T {\n    if (isLiteral(value)) {\n      return value as unknown as T\n    }\n    switch (typeof value) {\n      case 'object':\n        if (value instanceof Date) {\n          return Literal.fromDate(value) as unknown as T\n        }\n      case 'boolean':\n        return Literal.fromBoolean(value as boolean) as unknown as T\n      case 'number':\n        return Literal.fromNumber(value as number) as unknown as T\n      case 'string':\n        return new Literal(value) as unknown as T\n    }\n\n    throw new Error(\"Can't make literal from \" + value + ' of type ' +\n      typeof value)\n  }\n}\n","import RdflibBlankNode from './blank-node'\nimport ClassOrder from './class-order'\nimport Literal from './literal'\nimport Node from './node-internal'\nimport {\n  Bindings,\n  CollectionTermType,\n  FromValueReturns,\n  ValueType\n} from './types'\nimport Variable from './variable'\nimport { isTerm } from './utils/terms'\nimport { Term } from './tf-types'\n\n/**\n * Creates an RDF Node from a native javascript value.\n * RDF Nodes are returned unchanged, undefined returned as itself.\n * Arrays return Collections.\n * Strings, numbers and booleans return Literals.\n * @param value {Node|Date|String|Number|Boolean|Undefined}\n * @return {Node|Collection}\n */\nexport function fromValue <T extends FromValueReturns<C> = any, C extends Node = any>(value: ValueType): T {\n  if (typeof value === 'undefined' || value === null) {\n    return value as T\n  }\n\n  if (isTerm(value)) {  // a Node subclass or a Collection\n    return value as T\n  }\n\n  if (Array.isArray(value)) {\n    return new Collection<C>(value) as T\n  }\n\n  return Literal.fromValue<any>(value)\n}\n\n/**\n * A collection of other RDF nodes\n *\n * Use generic T to control the contents of the array.\n */\nexport default class Collection<\n  T extends Node = Node | RdflibBlankNode | Collection<any> | Literal | Variable\n> extends Node implements Term {\n  static termType: typeof CollectionTermType = CollectionTermType\n  termType: typeof CollectionTermType = CollectionTermType\n\n  classOrder = ClassOrder.Collection\n  closed: boolean = false\n  compareTerm = RdflibBlankNode.prototype.compareTerm\n  /**\n   * The nodes in this collection\n   */\n  elements: T[] = []\n  isVar = 0\n\n  constructor (initial?: ReadonlyArray<ValueType>) {\n    super((RdflibBlankNode.nextId++).toString())\n\n    if (initial && initial.length > 0) {\n      initial.forEach(element => {\n        this.elements.push(fromValue<T>(element))\n      })\n    }\n  }\n\n  public get id (): string {\n    return this.value\n  }\n\n  public set id (value) {\n    this.value = value\n  }\n\n  /**\n   * Appends an element to this collection\n   * @param element - The new element\n   */\n  append (element: T): number {\n    return this.elements.push(element)\n  }\n\n  /**\n   * Closes this collection\n   */\n  close (): boolean {\n    this.closed = true\n    return this.closed\n  }\n\n  /**\n   * Removes the first element from the collection (and return it)\n   */\n  shift (): T | undefined {\n    return this.elements.shift()\n  }\n\n  /**\n   * Creates a new Collection with the substituting bindings applied\n   * @param bindings - The bindings to substitute\n   */\n  substitute (bindings: Bindings) {\n    const elementsCopy = this.elements.map((ea) => ea.substitute(bindings))\n\n    return new Collection(elementsCopy) as Collection<Node | Collection<any> | Literal | Variable>\n  }\n\n  toNT () {\n    return Collection.toNT(this)\n  }\n\n  static toNT (collection) {\n    // return '(' + collection.elements.map(x => x.toNT()).join(' ') + ')'\n    // As lists are not in NT and toNT() must be a reversible function, we kludge it for a list\n    return RdflibBlankNode.NTAnonymousNodePrefix + collection.id\n  }\n\n  /**\n   * Serializes the collection to a string.\n   * Surrounded by (parentheses) and separated by spaces.\n   */\n  toString () {\n    return '(' + this.elements.join(' ') + ')'\n  }\n\n  /**\n   * Prepends the specified element to the collection's front\n   * @param element - The element to prepend\n   */\n  unshift (element: T): number {\n    return this.elements.unshift(element)\n  }\n}\n","import Node from './node-internal'\nimport { EmptyTermType } from './types'\nimport { Term } from './tf-types'\n\n/**\n* An empty node\n*/\nexport default class Empty extends Node implements Term {\n  termType: typeof EmptyTermType = EmptyTermType\n\n  constructor () {\n    super('')\n  }\n\n  toString () {\n    return '()'\n  }\n}\n","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\nexport default function _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n      args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n      _next(undefined);\n    });\n  };\n}","// Prevents circular dependencies between data-factory-internal and statement\n\nimport NamedNode from '../named-node'\n\nexport const defaultGraphURI = 'chrome:theSession'\nexport const defaultGraphNode = new NamedNode(defaultGraphURI)\n","import Node from './node-internal'\nimport { DefaultGraphTermType } from './types'\nimport { DefaultGraph as TFDefaultGraph } from './tf-types'\nimport { defaultGraphURI } from './utils/default-graph-uri'\n\n/** The RDF default graph */\nexport default class DefaultGraph extends Node implements TFDefaultGraph {\n  value: '' = '';\n  termType: typeof DefaultGraphTermType = DefaultGraphTermType;\n  uri = defaultGraphURI\n\n  constructor () {\n    super('')\n  }\n\n  toCanonical () {\n    return this.value\n  }\n\n  toString () {\n    return 'DefaultGraph';\n  }\n}\n\nexport function isDefaultGraph(object: any): object is DefaultGraph {\n  return !!object && object.termType === DefaultGraphTermType;\n}\n","import Node from './node-internal'\nimport {\n  Bindings,\n  GraphType,\n  ObjectType,\n  PredicateType,\n  SubjectType,\n  DefaultGraphTermType,\n} from './types'\nimport DefaultGraphNode, { isDefaultGraph } from './default-graph'\nimport { Quad, DefaultGraph } from './tf-types'\n\nconst defaultGraph = new DefaultGraphNode()\n\n/** A Statement represents an RDF Triple or Quad. */\nexport default class Statement<\n    S extends SubjectType = SubjectType,\n    P extends PredicateType = PredicateType,\n    O extends ObjectType = ObjectType,\n    G extends GraphType = GraphType\n  >\n  implements Quad<S, P, O, G | DefaultGraph> {\n\n  /** The subject of the triple.  What the Statement is about. */\n  subject: S\n\n  /** The relationship which is asserted between the subject and object */\n  predicate: P\n\n  /** The thing or data value which is asserted to be related to the subject */\n  object: O\n\n  /**\n   * The graph param is a named node of the document in which the triple when\n   *  it is stored on the web.\n   */\n  graph: G | DefaultGraph\n\n  /**\n   * Construct a new statement\n   *\n   * @param subject - The subject of the triple.  What the fact is about\n   * @param predicate - The relationship which is asserted between the subject and object\n   * @param object - The thing or data value which is asserted to be related to the subject\n   * @param {NamedNode} graph - The document where the triple is or was or will be stored on the web.\n   *\n   * The graph param is a named node of the document in which the triple when it is stored\n   *  on the web. It exists because when you have read data from various places in the web,\n   *  the “graph” tells you _why_ you have the triple. (At the moment, it is just the\n   *  document, in future it could be an inference step)\n   *\n   * When you do UpdateManager.update() then the graph’s of all the statements must be the same,\n   *  and give the document you are patching. In future, we may have a more\n   *  powerful update() which can update more than one document.\n   */\n  constructor (\n    subject: S,\n    predicate: P,\n    object: O,\n    graph?: G | DefaultGraph,\n  ) {\n    this.subject = Node.fromValue(subject)\n    this.predicate = Node.fromValue(predicate)\n    this.object = Node.fromValue(object)\n    this.graph = graph == undefined ? defaultGraph : Node.fromValue(graph) // property currently used by rdflib\n  }\n\n  /** Alias for graph, favored by Tim */\n  get why () {\n    return this.graph\n  }\n\n  set why (g) {\n    this.graph = g\n  }\n\n  /**\n   * Checks whether two statements are the same\n   * @param other - The other statement\n   */\n  equals (other: Quad): boolean {\n    return (\n      other.subject.equals(this.subject) &&\n      other.predicate.equals(this.predicate) &&\n      other.object.equals(this.object) &&\n      other.graph.equals(this.graph)\n    )\n  }\n\n  /**\n   * Creates a statement with the bindings substituted\n   * @param bindings The bindings\n   */\n  substitute (bindings: Bindings): Statement {\n    const y = new Statement(\n      this.subject.substitute(bindings),\n      this.predicate.substitute(bindings),\n      this.object.substitute(bindings),\n      isDefaultGraph(this.graph) ? this.graph :\n        (this.graph as G).substitute(bindings)\n    ) // 2016\n    // console.log('@@@ statement substitute:' + y)\n    return y\n  }\n\n  /** Creates a canonical string representation of this statement. */\n  toCanonical (): string {\n    let terms = [\n      this.subject.toCanonical(),\n      this.predicate.toCanonical(),\n      this.object.toCanonical()\n    ]\n    if (this.graph && this.graph.termType !== DefaultGraphTermType) {\n        terms.push(this.graph.toCanonical())\n    }\n    return terms.join(' ') + ' .'\n  }\n\n  /** Creates a n-triples string representation of this statement */\n  toNT (): string {\n    return [\n      this.subject.toNT(),\n      this.predicate.toNT(),\n      this.object.toNT(),\n    ].join(' ') + ' .'\n  }\n\n  /** Creates a n-quads string representation of this statement */\n  toNQ (): string {\n    return [\n      this.subject.toNT(),\n      this.predicate.toNT(),\n      this.object.toNT(),\n      isDefaultGraph(this.graph) ? '' : (this.graph as G).toNT()\n    ].join(' ') + ' .'\n  }\n\n  /** Creates a string representation of this statement */\n  toString (): string {\n    /*\n    return [\n      this.subject.toString(),\n      this.predicate.toString(),\n      this.object.toString(),\n    ].join(' ') + ' .'\n    */\n    return this.toNT()\n  }\n}\n","import ClassOrder from './class-order'\nimport Node from './node-internal'\nimport { VariableTermType } from './types'\nimport * as Uri from './uri'\nimport { Variable as TFVariable } from './tf-types'\n\n/**\n* Variables are placeholders used in patterns to be matched.\n* In cwm they are symbols which are the formula's list of quantified variables.\n* In sparql they are not visibly URIs.  Here we compromise, by having\n* a common special base URI for variables. Their names are uris,\n* but the ? notation has an implicit base uri of 'varid:'\n*/\nexport default class Variable extends Node implements TFVariable {\n  termType: typeof VariableTermType = VariableTermType\n\n  /** The base string for a variable's name */\n  base = 'varid:'\n  classOrder = ClassOrder.Variable\n  isVar = 1\n  /** The unique identifier of this variable */\n  uri: string\n\n  /**\n   * Initializes this variable\n   * @param name The variable's name\n   */\n  constructor (name = '') {\n    super(name)\n    this.base = 'varid:'\n    this.uri = Uri.join(name, this.base)\n  }\n\n  equals (other) {\n    if (!other) {\n      return false\n    }\n\n    return (this.termType === other.termType) && (this.value === other.value)\n  }\n\n  hashString () {\n    return this.toString()\n  }\n\n  substitute (bindings) {\n    var ref\n    return (ref = bindings[this.toNT()]) != null ? ref : this\n  }\n\n  toString () {\n    return Variable.toString(this)\n  }\n\n  static toString (variable) {\n    if (variable.uri.slice(0, variable.base.length) === variable.base) {\n      return `?${variable.uri.slice(variable.base.length)}`\n    }\n\n    return `?${variable.uri}`\n  }\n}\n","import Literal from '../literal'\nimport Statement from '../statement'\nimport NamedNode from '../named-node'\nimport BlankNode from '../blank-node'\nimport Variable from '../variable'\nimport DefaultGraph from '../default-graph'\nimport {\n  BlankNode as TFBlankNode,\n  RdfJsDataFactory,\n  Literal as TFLiteral,\n  NamedNode as TFNamedNode,\n  Quad,\n  Term,\n  Variable as TFVariable,\n} from '../tf-types'\n\nexport type Comparable = Term | TFNamedNode | TFBlankNode | TFLiteral | Quad | undefined | null\n\nexport type DefaultFactoryTypes = NamedNode | BlankNode | Literal | Variable | Statement\n\nexport type Indexable = number | string\n\nexport type Namespace = (term:string) => TFNamedNode\n\n/** A set of features that may be supported by a Data Factory */\nexport type SupportTable = Record<Feature, boolean>\n\nexport type TFIDFactoryTypes = TFNamedNode | TFBlankNode | TFLiteral | Quad | TFVariable | Term\n\nexport enum Feature {\n  /** Whether the factory supports termType:Collection terms */\n  collections = \"COLLECTIONS\",\n  /** Whether the factory supports termType:DefaultGraph terms */\n  defaultGraphType = \"DEFAULT_GRAPH_TYPE\",\n  /** Whether the factory supports equals on produced instances */\n  equalsMethod = \"EQUALS_METHOD\",\n  /** Whether the factory can create a unique idempotent identifier for the given term. */\n  id = \"ID\",\n  /**\n   * Whether the factory will return the same instance for subsequent calls.\n   * This implies `===`, which means methods like `indexOf` can be used.\n   */\n  identity = \"IDENTITY\",\n  /** Whether the factory supports mapping ids back to instances (should adhere to the identity setting) */\n  reversibleId = \"REVERSIBLE_ID\",\n  /** Whether the factory supports termType:Variable terms */\n  variableType = \"VARIABLE_TYPE\",\n}\n\n/**\n * Defines a DataFactory as used in rdflib, based on the RDF/JS: Data model specification,\n * but with additional extensions\n *\n * bnIndex is optional but useful.\n */\nexport interface DataFactory<\n  FactoryTypes = DefaultFactoryTypes,\n  IndexType = Indexable\n> extends RdfJsDataFactory {\n  /**\n   * BlankNode index\n   * @private\n  */\n  bnIndex?: number\n\n  supports: SupportTable\n\n  namedNode(value: string): NamedNode\n\n  blankNode(value?: string): BlankNode\n\n  literal(value: string, languageOrDatatype?: string | TFNamedNode): Literal\n\n  variable(value: string): Variable,\n\n  defaultGraph(): DefaultGraph,\n\n  isQuad(obj: any): obj is Statement\n\n  equals(a: Comparable, b: Comparable): boolean\n\n  toNQ(term: Term | FactoryTypes): string\n\n  quad(\n    subject: Term,\n    predicate: Term,\n    object: Term,\n    graph?: Term,\n  ): Statement;\n\n  quadToNQ(term: Statement | Quad): string\n\n  termToNQ(term: Term): string\n\n  /**\n   * Generates a unique session-idempotent identifier for the given object.\n   *\n   * @example NQ serialization (reversible from value)\n   * @example MD5 hash of termType + value (irreversible from value, map needed)\n   *\n   * @return {Indexable} A unique value which must also be a valid JS object key type.\n   */\n  id(obj: Term | FactoryTypes): IndexType\n}\n","import BlankNode from '../blank-node'\nimport Literal from '../literal'\nimport NamedNode from '../named-node'\nimport Statement from '../statement'\nimport Variable from '../variable'\nimport {\n  SubjectType,\n  PredicateType,\n  ObjectType,\n  GraphType,\n  EmptyTermType,\n  DefaultGraphTermType,\n  VariableTermType,\n  BlankNodeTermType,\n  LiteralTermType,\n  NamedNodeTermType,\n  CollectionTermType,\n  GraphTermType,\n} from '../types'\nimport DefaultGraph from '../default-graph'\nimport {\n  Comparable,\n  DataFactory,\n  DefaultFactoryTypes,\n  Feature,\n} from './factory-types'\nimport { isQuad, isTerm } from '../utils/terms'\nimport { NamedNode as TFNamedNode, Quad, Term } from '../tf-types'\nimport Collection from \"../collection\";\n\nexport { defaultGraphURI } from '../utils/default-graph-uri'\n\n/**\n * Gets the default graph\n */\nconst defaultGraph = new DefaultGraph()\n\n/** A basic internal RDFlib datafactory, which does not support Collections  */\nconst CanonicalDataFactory: DataFactory = {\n\n  supports: {\n    [Feature.collections]: false,\n    [Feature.defaultGraphType]: false,\n    [Feature.equalsMethod]: true,\n    [Feature.identity]: false,\n    [Feature.id]: true,\n    [Feature.reversibleId]: false,\n    [Feature.variableType]: true,\n  },\n\n  /**\n   * Creates a new blank node\n   * @param value - The blank node's identifier\n   */\n  blankNode(value?: string): BlankNode {\n    return new BlankNode(value)\n  },\n\n  defaultGraph: () => defaultGraph,\n\n  /**\n   * Compares to (rdf) objects for equality.\n   */\n  equals(a: Comparable, b: Comparable): boolean {\n    if (a === b || !a || !b) {\n      return true\n    }\n\n    if (isQuad(a) || isQuad(b)) {\n      if (isQuad(a) && isQuad(b)) {\n        return (\n          this.equals(a.subject, b.subject) &&\n          this.equals(a.predicate, b.predicate) &&\n          this.equals(a.object, b.object) &&\n          this.equals(a.graph, b.graph)\n        )\n      }\n\n      return false\n    }\n\n    if (isTerm(a) && isTerm(b)) {\n      return this.id(a) === this.id(b)\n    }\n\n    return false\n  },\n\n  /**\n   * Generates a uniquely identifiably *idempotent* string for the given {term}.\n   *\n   * Equivalent to [[Term.hashString]]\n   *\n   * @example Use this to associate data with a term in an object\n   *   { obj[id(term)] = \"myData\" }\n   */\n  id (term: Term | Statement | undefined): string {\n    if (!term) {\n      return 'undefined'\n    }\n\n    if (isQuad(term)) {\n      return this.quadToNQ(term)\n    }\n\n    switch (term.termType) {\n      case DefaultGraphTermType:\n        return 'defaultGraph'\n      case VariableTermType:\n        return Variable.toString(term)\n      default:\n        const nq = this.termToNQ(term)\n        if (nq) {\n          return nq\n        }\n\n        throw new Error(`Can't id term with type '${term.termType}'`)\n    }\n  },\n\n  isQuad (obj: any): obj is Statement {\n    return obj instanceof Statement\n  },\n\n  /**\n   * Creates a new literal node. Does some JS literal parsing for ease of use.\n   * @param value - The lexical value\n   * @param languageOrDatatype - Either the language or the datatype\n   */\n  literal(\n    value: string | number | boolean | Date,\n    languageOrDatatype?: string | TFNamedNode\n  ): Literal {\n    if (typeof value !== \"string\" && !languageOrDatatype) {\n      return Literal.fromValue(value)\n    }\n\n    const strValue = typeof value === 'string' ? value : '' + value\n    if (typeof languageOrDatatype === 'string') {\n      if (languageOrDatatype.indexOf(':') === -1) {\n        return new Literal(strValue, languageOrDatatype)\n      } else {\n        return new Literal(strValue, null, this.namedNode(languageOrDatatype))\n      }\n    } else {\n      return new Literal(strValue, null, languageOrDatatype)\n    }\n  },\n\n  /**\n   * Creates a new named node\n   * @param value - The new named node\n   */\n  namedNode(value: string): NamedNode {\n    return new NamedNode(value)\n  },\n\n  /**\n   * Creates a new statement\n   * @param subject - The subject\n   * @param predicate - The predicate\n   * @param object - The object\n   * @param graph - The containing graph\n   */\n  quad<\n    S extends SubjectType = SubjectType,\n    P extends PredicateType = PredicateType,\n    O extends ObjectType = ObjectType,\n    G extends GraphType = GraphType\n  >(subject: S, predicate: P, object: O, graph?: G): Statement<S, P, O, G | DefaultGraph> {\n    return new Statement(subject, predicate, object, graph || defaultGraph)\n  },\n\n  /**\n   * Creates a new statement\n   * @param subject - The subject\n   * @param predicate - The predicate\n   * @param object - The object\n   * @param graph - The containing graph\n   */\n  triple(\n    subject: Term | SubjectType,\n    predicate: Term | PredicateType,\n    object: Term | ObjectType,\n    graph?: Term | GraphType\n  ): Statement {\n    return this.quad(subject, predicate, object, graph)\n  },\n\n  quadToNQ(q: Statement | Quad): string {\n    return `${this.termToNQ(q.subject)} ${this.termToNQ(q.predicate)} ${this.termToNQ(q.object)} ${this.termToNQ(q.graph)} .`;\n  },\n\n  /** Stringify a {term} to n-quads serialization. */\n  termToNQ(term: Term): string {\n    switch (term.termType) {\n      case BlankNodeTermType:\n        return '_:' + term.value\n      case DefaultGraphTermType:\n        return ''\n      case EmptyTermType:\n        return '<http://www.w3.org/1999/02/22-rdf-syntax-ns#nil>'\n      case LiteralTermType:\n        return Literal.toNT(term as Literal)\n      case GraphTermType:\n      case NamedNodeTermType:\n        return '<' + term.value + '>'\n      case CollectionTermType:\n        return '(' + (term as Collection).elements.map(t => this.termToNQ(t)).join(' ') + ')'\n      default:\n        throw new Error(`Can't serialize nonstandard term type (was '${term.termType}')`)\n    }\n  },\n\n  /** Convert an rdf object (term or quad) to n-quads serialization. */\n  toNQ (term: Term | (DefaultFactoryTypes & Variable)): string {\n    if (this.isQuad(term)) {\n      return this.quadToNQ(term);\n    }\n\n    return this.termToNQ(term);\n  },\n\n  /**\n   * Creates a new variable\n   * @param name - The name for the variable\n   */\n  variable(name?: string): Variable {\n    return new Variable(name)\n  },\n}\n\n/** Contains the factory methods as defined in the spec, plus id */\nexport default CanonicalDataFactory\n","import RDFlibNamedNode from './named-node'\nimport { RdfJsDataFactory, NamedNode } from './tf-types'\n\n/**\n * Gets a namespace for the specified namespace's URI\n * @param nsuri - The URI for the namespace\n * @param [factory] - The factory for creating named nodes with\n */\nexport default function Namespace (nsuri: string, factory?: RdfJsDataFactory): (ln: string) => NamedNode {\n  const dataFactory = factory || { namedNode: (value) => new RDFlibNamedNode(value) as NamedNode }\n\n  return function (ln: string): NamedNode {\n    return dataFactory.namedNode(nsuri + (ln || ''))\n  }\n}\n","import CanonicalDataFactory from \"./factories/canonical-data-factory\";\n\nexport function createXSD(localFactory = CanonicalDataFactory) {\n  return {\n    boolean: localFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#boolean\"),\n    dateTime: localFactory.namedNode(\n      \"http://www.w3.org/2001/XMLSchema#dateTime\"\n    ),\n    decimal: localFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#decimal\"),\n    double: localFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#double\"),\n    integer: localFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#integer\"),\n    langString: localFactory.namedNode(\n      \"http://www.w3.org/1999/02/22-rdf-syntax-ns#langString\"\n    ),\n    string: localFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#string\"),\n  };\n}\n\nconst defaultXSD = createXSD(CanonicalDataFactory);\n\nexport default defaultXSD;\n","/*      Serialization of RDF Graphs\n**\n** Tim Berners-Lee 2006\n** This is was http://dig.csail.mit.edu/2005/ajar/ajaw/js/rdf/serialize.js\n** This is or was https://github.com/linkeddata/rdflib.js/blob/main/src/serializer.js\n** Licence: MIT\n*/\nimport NamedNode from './named-node'\nimport BlankNode from './blank-node'\nimport * as Uri from './uri'\nimport * as Util from './utils-js'\nimport CanonicalDataFactory from './factories/canonical-data-factory'\nimport { createXSD } from './xsd'\nimport solidNs from 'solid-namespace'\nimport * as ttl2jsonld from '@frogcat/ttl2jsonld'\n\n\nexport default function createSerializer(store) {\n  return new Serializer(store);\n};\n\nexport class Serializer {\n  constructor(store) {\n    this.flags = ''\n    this.base = null\n\n    this.prefixes = [] // suggested prefixes\n    this.namespaces = [] // complementary\n    const nsKeys = Object.keys(solidNs())\n    for (const i in nsKeys) {\n      const uri = solidNs()[nsKeys[i]]('')\n      const prefix = nsKeys[i]\n      this.prefixes[uri] = prefix\n      this.namespaces[prefix] = uri\n    }\n\n    this.suggestPrefix('rdf', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#') // XML code assumes this!\n    this.suggestPrefix('xml', 'reserved:reservedForFutureUse') // XML reserves xml: in the spec.\n\n    this.namespacesUsed = [] // Count actually used and so needed in @prefixes\n    this.keywords = ['a'] // The only one we generate at the moment\n    this.prefixchars = 'abcdefghijklmnopqustuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'\n    this.incoming = null // Array not calculated yet\n    this.formulas = [] // remembering original formulae from hashes\n    this.store = store\n    this.rdfFactory = store.rdfFactory || CanonicalDataFactory\n    this.xsd = createXSD(this.rdfFactory)\n  }\n\n  setBase(base) {\n    this.base = base;\n    return this\n  }\n\n  setFlags(flags) {\n    this.flags = flags || '';\n    return this\n  }\n\n  toStr(x) {\n    var s = x.toNT()\n    if (x.termType === 'Graph') {\n      this.formulas[s] = x // remember as reverse does not work\n    }\n    return s\n  }\n\n  fromStr(s) {\n    if (s[0] === '{') {\n      var x = this.formulas[s]\n      if (!x) console.log('No formula object for ' + s)\n      return x\n    }\n    return this.store.fromNT(s)\n  }\n\n  /**\n   * Defines a set of [prefix, namespace] pairs to be used by this Serializer instance.\n   * Overrides previous prefixes if any\n   * @param namespaces\n   * @return {Serializer}\n   */\n  setNamespaces(namespaces) {\n    for (var px in namespaces) {\n      this.setPrefix(px, namespaces[px])\n    }\n    return this\n  }\n\n  /**\n   * Defines a namespace prefix, overriding any existing prefix for that URI\n   * @param prefix\n   * @param uri\n   */\n  setPrefix(prefix, uri) {\n    if (prefix.slice(0, 7) === 'default') return // Try to weed these out\n    if (prefix.slice(0, 2) === 'ns') return //  From others inferior algos\n    if (!prefix || !uri) return // empty strings not suitable\n\n    // remove any existing prefix targeting this uri\n    // for (let existingPrefix in this.namespaces) {\n    //   if (this.namespaces[existingPrefix] == uri)\n    //     delete this.namespaces[existingPrefix];\n    // }\n\n    // remove any existing mapping for this prefix\n    for (let existingNs in this.prefixes) {\n      if (this.prefixes[existingNs] == prefix)\n        delete this.prefixes[existingNs];\n    }\n\n    this.prefixes[uri] = prefix\n    this.namespaces[prefix] = uri\n  }\n\n\n  /* Accumulate Namespaces\n  **\n  ** These are only hints.  If two overlap, only one gets used\n  ** There is therefore no guarantee in general.\n  */\n  suggestPrefix(prefix, uri) {\n    if (prefix.slice(0, 7) === 'default') return // Try to weed these out\n    if (prefix.slice(0, 2) === 'ns') return //  From others inferior algos\n    if (!prefix || !uri) return // empty strings not suitable\n    if (prefix in this.namespaces || uri in this.prefixes) return // already used\n    this.prefixes[uri] = prefix\n    this.namespaces[prefix] = uri\n  }\n\n  // Takes a namespace -> prefix map\n  suggestNamespaces(namespaces) {\n    for (var px in namespaces) {\n      this.suggestPrefix(px, namespaces[px])\n    }\n    return this\n  }\n\n  checkIntegrity() {\n    var p, ns\n    for (p in this.namespaces) {\n      if (this.prefixes[this.namespaces[p]] !== p) {\n        throw new Error('Serializer integity error 1: ' + p + ', ' +\n          this.namespaces[p] + ', ' + this.prefixes[this.namespaces[p]] + '!')\n      }\n    }\n    for (ns in this.prefixes) {\n      if (this.namespaces[this.prefixes[ns]] !== ns) {\n        throw new Error('Serializer integity error 2: ' + ns + ', ' +\n          this.prefixs[ns] + ', ' + this.namespaces[this.prefixes[ns]] + '!')\n      }\n    }\n  }\n\n  // Make up an unused prefix for a random namespace\n  makeUpPrefix(uri) {\n    var p = uri\n    function canUseMethod (pp) {\n      if (!this.validPrefix.test(pp)) return false // bad format\n      if (pp === 'ns') return false // boring\n      if (pp in this.namespaces) return false // already used\n      this.prefixes[uri] = pp\n      this.namespaces[pp] = uri\n      return pp\n    }\n    var canUse = canUseMethod.bind(this)\n\n    if ('#/'.indexOf(p[p.length - 1]) >= 0) p = p.slice(0, -1)\n    var slash = p.lastIndexOf('/')\n    if (slash >= 0) p = p.slice(slash + 1)\n    var i = 0\n    while (i < p.length) {\n      if (this.prefixchars.indexOf(p[i])) {\n        i++\n      } else {\n        break\n      }\n    }\n    p = p.slice(0, i)\n\n    if (p.length < 6 && (canUse(p))) return p // exact is best\n    if (canUse(p.slice(0, 3))) return p.slice(0, 3)\n    if (canUse(p.slice(0, 2))) return p.slice(0, 2)\n    if (canUse(p.slice(0, 4))) return p.slice(0, 4)\n    if (canUse(p.slice(0, 1))) return p.slice(0, 1)\n    if (canUse(p.slice(0, 5))) return p.slice(0, 5)\n    if (!this.validPrefix.test(p)) {\n      p = 'n' // Otherwise the loop below may never termimnate\n    }\n    for (var j = 0; ; j++) if (canUse(p.slice(0, 3) + j)) return p.slice(0, 3) + j\n  }\n\n  rootSubjects(sts) {\n    var incoming = {}\n    var subjects = {}\n    var allBnodes = {}\n\n    /* This scan is to find out which nodes will have to be the roots of trees\n    ** in the serialized form. This will be any symbols, and any bnodes\n    ** which hve more or less than one incoming arc, and any bnodes which have\n    ** one incoming arc but it is an uninterrupted loop of such nodes back to itself.\n    ** This should be kept linear time with repect to the number of statements.\n    ** Note it does not use any indexing of the store.\n    */\n    for (var i = 0; i < sts.length; i++) {\n      var st = sts[i]\n      var checkMentions = function (x) {\n        if (!incoming.hasOwnProperty(x)) incoming[x] = []\n        incoming[x].push(st.subject) // List of things which will cause this to be printed\n      }\n      var st2 = [st.subject, st.predicate, st.object]\n      st2.map(function (y) {\n        if (y.termType === 'BlankNode') {\n          allBnodes[y.toNT()] = true\n        } else if (y.termType === 'Collection') {\n          y.elements.forEach(function (z) {\n            checkMentions(z) // bnodes in collections important\n          })\n        }\n      })\n      checkMentions(sts[i].object)\n      var ss = subjects[this.toStr(st.subject)] // Statements with this as subject\n      if (!ss) ss = []\n      ss.push(st)\n      subjects[this.toStr(st.subject)] = ss // Make hash. @@ too slow for formula?\n    }\n\n    var roots = []\n    for (var xNT in subjects) {\n      if (!subjects.hasOwnProperty(xNT)) continue\n      var y = this.fromStr(xNT)\n      if ((y.termType !== 'BlankNode') || !incoming[y] || (incoming[y].length !== 1)) {\n        roots.push(y)\n        continue\n      }\n    }\n    this.incoming = incoming // Keep for serializing @@ Bug for nested formulas\n\n    // Now do the scan using existing roots\n    var rootsHash = {}\n    for (var k = 0; k < roots.length; k++) {\n      rootsHash[roots[k].toNT()] = true\n    }\n    return {'roots': roots, 'subjects': subjects,\n    'rootsHash': rootsHash, 'incoming': incoming}\n  }\n\n  // //////////////////////////////////////////////////////\n\n  toN3(f) {\n    return this.statementsToN3(f.statements)\n  }\n\n  _notQNameChars = '\\t\\r\\n !\"#$%&\\'()*.,+/;<=>?@[\\\\]^`{|}~'\n  _notNameChars =\n    (this._notQNameChars + ':')\n\n  explicitURI(uri) {\n    if (this.flags.indexOf('r') < 0 && this.base) {\n      uri = Uri.refTo(this.base, uri)\n    } else if (this.flags.indexOf('u') >= 0) { // Unicode encoding NTriples style\n      uri = backslashUify(uri)\n    } else {\n      uri = hexify(decodeURI(uri))\n    }\n    return '<' + uri + '>'\n  }\n\n  statementsToNTriples(sts) {\n    var sorted = sts.slice()\n    sorted.sort()\n    var str = ''\n    var rdfns = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'\n    var self = this\n    var kb = this.store\n    var factory = this.rdfFactory\n    var termToNT = function (x) {\n      if (x.termType !== 'Collection') {\n        return self.atomicTermToN3(x)\n      }\n      var list = x.elements\n      var rest = kb.sym(rdfns + 'nill')\n      for (var i = list.length - 1; i >= 0; i--) {\n        var bnode = factory.blankNode()\n        str += termToNT(bnode) + ' ' + termToNT(kb.sym(rdfns + 'first')) + ' ' + termToNT(list[i]) + '.\\n'\n        str += termToNT(bnode) + ' ' + termToNT(kb.sym(rdfns + 'rest')) + ' ' + termToNT(rest) + '.\\n'\n        rest = bnode\n      }\n      return self.atomicTermToN3(rest)\n    }\n    for (var i = 0; i < sorted.length; i++) {\n      var st = sorted[i]\n      var s = ''\n      s += termToNT(st.subject) + ' '\n      s += termToNT(st.predicate) + ' '\n      s += termToNT(st.object) + ' '\n      if (this.flags.indexOf('q') >= 0) { // Do quads not nrtiples\n        s += termToNT(st.why) + ' '\n      }\n      s += '.\\n'\n      str += s\n    }\n    return str\n  }\n\n  statementsToN3(sts) {\n    var indent = 4\n    var width = 80\n    var kb = this.store\n    // A URI Map alows us to put the type statemnts at the top.\n    var uriMap = {'http://www.w3.org/1999/02/22-rdf-syntax-ns#type': 'aaa:00'}\n    var SPO = function (x, y) { // Do limited canonicalization of bnodes\n      return Util.heavyCompareSPO(x, y, kb, uriMap)\n    }\n    sts.sort(SPO)\n\n    if (this.base && !this.defaultNamespace){\n      this.defaultNamespace = this.base + '#'\n    }\n\n    var predMap = {}\n    if (this.flags.indexOf('s') < 0) {\n      predMap['http://www.w3.org/2002/07/owl#sameAs'] = '='\n    }\n    if (this.flags.indexOf('t') < 0) {\n      predMap['http://www.w3.org/1999/02/22-rdf-syntax-ns#type'] = 'a'\n    }\n    if (this.flags.indexOf('i') < 0) {\n      predMap['http://www.w3.org/2000/10/swap/log#implies'] = '=>'\n    }\n    // //////////////////////// Arrange the bits of text\n\n    var spaces = function (n) {\n      var s = ''\n      for (var i = 0; i < n; i++) s += ' '\n      return s\n    }\n\n    var treeToLine = function (tree) {\n      var str = ''\n      for (var i = 0; i < tree.length; i++) {\n        var branch = tree[i]\n        var s2 = (typeof branch === 'string') ? branch : treeToLine(branch)\n        // Note the space before the dot in case statement ends with 123 or colon. which is in fact allowed but be conservative.\n        if (i !== 0) {\n          var ch = str.slice(-1) || ' '\n          if (s2 === ',' || s2 === ';') {\n            // no gap\n          } else if (s2 === '.' && !('0123456789.:'.includes(ch))) { // no gap except after number and colon\n            // no gap\n          } else {\n            str += ' ' // separate from previous token\n          }\n        }\n        str += s2\n      }\n      return str\n    }\n\n    // Convert a nested tree of lists and strings to a string\n    var treeToString = function (tree, level) {\n      var str = ''\n      var lastLength = 100000\n      if (level === undefined) level = -1\n      for (var i = 0; i < tree.length; i++) {\n        var branch = tree[i]\n        if (typeof branch !== 'string') {\n          var substr = treeToString(branch, level + 1)\n          if (\n            substr.length < 10 * (width - indent * level) &&\n              substr.indexOf('\"\"\"') < 0) { // Don't mess up multiline strings\n            var line = treeToLine(branch)\n            if (line.length < (width - indent * level)) {\n              branch = line //   Note! treat as string below\n              substr = ''\n            }\n          }\n          if (substr) lastLength = 10000\n          str += substr\n        }\n        if (typeof branch === 'string') {\n          if (branch.length === 1 && str.slice(-1) === '\\n') {\n            if (',.;'.indexOf(branch) >= 0) {\n              str = str.slice(0, -1)\n              // be conservative and ensure a whitespace between some chars and a final dot, as in treeToLine above\n              if (branch == '.' && '0123456789.:'.includes(str.charAt(str.length-1))) {\n                str += ' '\n                lastLength += 1\n              }\n              str += branch + '\\n' //  slip punct'n on end\n              lastLength += 1\n              continue\n            }\n          }\n          if (lastLength < (indent * level + 4) ||  // if new line not necessary\n            lastLength + branch.length + 1 < width && ';.'.indexOf(str[str.length - 2]) < 0) { // or the string fits on last line\n            str = str.slice(0, -1) + ' ' + branch + '\\n' // then continue on this line\n            lastLength += branch.length + 1\n          } else {\n            let line = spaces(indent * level) + branch\n            str += line + '\\n'\n            lastLength = line.length\n            if (level < 0) {\n              str += '\\n' // extra blank line\n              lastLength = 100000 // don't touch\n            }\n          }\n        }\n      }\n      return str\n    }\n\n    // //////////////////////////////////////////// Structure for N3\n    // Convert a set of statements into a nested tree of lists and strings\n    function statementListToTreeMethod (statements) {\n      var stats = this.rootSubjects(statements)\n      var roots = stats.roots\n      var results = []\n      for (var i = 0; i < roots.length; i++) {\n        var root = roots[i]\n        results.push(subjectTree(root, stats))\n      }\n      return results\n    }\n    var statementListToTree = statementListToTreeMethod.bind(this)\n\n    // The tree for a subject\n    function subjectTree (subject, stats) {\n      if (subject.termType === 'BlankNode' && !stats.incoming[subject]) {\n        return objectTree(subject, stats, true).concat(['.']) // Anonymous bnode subject\n      }\n      return [ termToN3(subject, stats) ].concat([propertyTree(subject, stats)]).concat(['.'])\n    }\n    // The property tree for a single subject or anonymous node\n    function propertyTreeMethod (subject, stats) {\n      var results = []\n      var lastPred = null\n      var sts = stats.subjects[this.toStr(subject)] || [] // relevant statements\n      if (typeof sts === 'undefined') {\n        throw new Error('Cant find statements for ' + subject)\n      }\n\n      var objects = []\n      for (var i = 0; i < sts.length; i++) {\n        var st = sts[i]\n        if (st.predicate.uri === lastPred) {\n          objects.push(',')\n        } else {\n          if (lastPred) {\n            results = results.concat([objects]).concat([';'])\n            objects = []\n          }\n          results.push(predMap[st.predicate.uri]\n            ? predMap[st.predicate.uri] : termToN3(st.predicate, stats))\n        }\n        lastPred = st.predicate.uri\n        objects.push(objectTree(st.object, stats))\n      }\n      results = results.concat([objects])\n      return results\n    }\n\n    var propertyTree = propertyTreeMethod.bind(this)\n\n    function objectTreeMethod(obj, stats, force) {\n      if (obj.termType === 'BlankNode' &&\n        (force || stats.rootsHash[obj.toNT()] === undefined)) {// if not a root\n        if (stats.subjects[this.toStr(obj)]) {\n          return ['[', propertyTree(obj, stats), ']']\n        } else {\n          return '[]'\n        }\n      }\n      return termToN3(obj, stats)\n    }\n\n    var objectTree = objectTreeMethod.bind(this)\n\n    function termToN3Method(expr, stats) { //\n      var i, res\n      switch (expr.termType) {\n        case 'Graph':\n          res = ['{']\n          res = res.concat(statementListToTree(expr.statements))\n          return res.concat(['}'])\n\n        case 'Collection':\n          res = ['(']\n          for (i = 0; i < expr.elements.length; i++) {\n            res.push([ objectTree(expr.elements[i], stats) ])\n          }\n          res.push(')')\n          return res\n\n        default:\n          return this.atomicTermToN3(expr)\n      }\n    }\n    Serializer.prototype.termToN3 = termToN3\n    var termToN3 = termToN3Method.bind(this)\n\n    function prefixDirectivesMethod () {\n      var str = ''\n      if (this.flags.indexOf('d') < 0 && this.defaultNamespace) {\n        str += '@prefix : ' + this.explicitURI(this.defaultNamespace) + '.\\n'\n      }\n      for (var ns in this.prefixes) {\n        if (!this.prefixes.hasOwnProperty(ns)) continue\n        if (!this.namespacesUsed[ns]) continue\n        str += '@prefix ' + this.prefixes[ns] + ': ' + this.explicitURI(ns) +\n          '.\\n'\n      }\n      return str + '\\n'\n    }\n    var prefixDirectives = prefixDirectivesMethod.bind(this)\n    // Body of statementsToN3:\n    var tree = statementListToTree(sts)\n    return prefixDirectives() + treeToString(tree)\n  }\n  // //////////////////////////////////////////// Atomic Terms\n\n  //  Deal with term level things and nesting with no bnode structure\n  atomicTermToN3 (expr, stats) {\n    switch (expr.termType) {\n      case 'BlankNode':\n      case 'Variable':\n        return expr.toNT()\n      case 'Literal':\n        var val = expr.value\n        if (typeof val !== 'string') {\n          throw new TypeError('Value of RDF literal node must be a string')\n        }\n        // var val = expr.value.toString() // should be a string already\n        if (expr.datatype && this.flags.indexOf('x') < 0) { // Supress native numbers\n          switch (expr.datatype.uri) {\n\n            case 'http://www.w3.org/2001/XMLSchema#integer':\n              return val\n\n            case 'http://www.w3.org/2001/XMLSchema#decimal': // In Turtle, must have dot\n              if (val.indexOf('.') < 0) val += '.0'\n              return val\n\n            case 'http://www.w3.org/2001/XMLSchema#double': {\n              // Must force use of 'e'\n              const eNotation = val.toLowerCase().indexOf('e') > 0;\n              if (val.indexOf('.') < 0 && !eNotation) val += '.0'\n              if (!eNotation) val += 'e0'\n              return val\n            }\n\n            case 'http://www.w3.org/2001/XMLSchema#boolean':\n              return expr.value === '1' ? 'true' : 'false'\n          }\n        }\n        var str = this.stringToN3(expr.value)\n        if (expr.language) {\n          str += '@' + expr.language\n        } else if (!expr.datatype.equals(this.xsd.string)) {\n          str += '^^' + this.atomicTermToN3(expr.datatype, stats)\n        }\n        return str\n      case 'NamedNode':\n        return this.symbolToN3(expr)\n      case 'DefaultGraph':\n        return '';\n      default:\n        throw new Error('Internal: atomicTermToN3 cannot handle ' + expr + ' of termType: ' + expr.termType)\n    }\n  }\n\n  //  stringToN3:  String escaping for N3\n\n  validPrefix = new RegExp(/^[a-zA-Z][a-zA-Z0-9]*$/)\n\n  forbidden1 = new RegExp(/[\\\\\"\\b\\f\\r\\v\\t\\n\\u0080-\\uffff]/gm)\n  forbidden3 = new RegExp(/[\\\\\"\\b\\f\\r\\v\\u0080-\\uffff]/gm)\n  stringToN3(str, flags) {\n    if (!flags) flags = 'e'\n    var res = ''\n    var i, j, k\n    var delim\n    var forbidden\n    if (str.length > 20 && // Long enough to make sense\n        str.slice(-1) !== '\"' && // corner case'\n        flags.indexOf('n') < 0 && // Force single line\n        (str.indexOf('\\n') > 0 || str.indexOf('\"') > 0)) {\n      delim = '\"\"\"'\n      forbidden = this.forbidden3\n    } else {\n      delim = '\"'\n      forbidden = this.forbidden1\n    }\n    for (i = 0; i < str.length;) {\n      forbidden.lastIndex = 0\n      var m = forbidden.exec(str.slice(i))\n      if (m == null) break\n      j = i + forbidden.lastIndex - 1\n      res += str.slice(i, j)\n      var ch = str[j]\n      if (ch === '\"' && delim === '\"\"\"' && str.slice(j, j + 3) !== '\"\"\"') {\n        res += ch\n      } else {\n        k = '\\b\\f\\r\\t\\v\\n\\\\\"'.indexOf(ch) // No escaping of bell (7)?\n        if (k >= 0) {\n          res += '\\\\' + 'bfrtvn\\\\\"'[k]\n        } else {\n          if (flags.indexOf('e') >= 0) { // Unicode escaping in strings not unix style\n            res += '\\\\u' + ('000' +\n              ch.charCodeAt(0).toString(16).toLowerCase()).slice(-4)\n          } else { // no 'e' flag\n            res += ch\n          }\n        }\n      }\n      i = j + 1\n    }\n    return delim + res + str.slice(i) + delim\n  }\n  //  A single symbol, either in  <> or namespace notation\n\n  symbolToN3 (x) { // c.f. symbolString() in notation3.py\n    var uri = x.uri\n    var j = uri.indexOf('#')\n    if (j < 0 && this.flags.indexOf('/') < 0) {\n      j = uri.lastIndexOf('/')\n    }\n    if (j >= 0 && this.flags.indexOf('p') < 0 &&\n      // Can split at namespace but only if http[s]: URI or file: or ws[s] (why not others?)\n      (uri.indexOf('http') === 0 || uri.indexOf('ws') === 0 || uri.indexOf('file') === 0)) {\n      var canSplit = true\n      for (var k = j + 1; k < uri.length; k++) {\n        if (this._notNameChars.indexOf(uri[k]) >= 0) {\n          canSplit = false\n          break\n        }\n      }\n/*\n      if (uri.slice(0, j + 1) === this.base + '#') { // base-relative\n        if (canSplit) {\n          return ':' + uri.slice(j + 1) // assume deafult ns is local\n        } else {\n          return '<#' + uri.slice(j + 1) + '>'\n        }\n      }\n*/\n      if (canSplit) {\n        var localid = uri.slice(j + 1)\n        var namesp = uri.slice(0, j + 1)\n        if (this.defaultNamespace && this.defaultNamespace === namesp &&\n            this.flags.indexOf('d') < 0) { // d -> suppress default\n          if (this.flags.indexOf('k') >= 0 &&\n            this.keyords.indexOf(localid) < 0) {\n            return localid\n          }\n          return ':' + localid\n        }\n        // this.checkIntegrity() //  @@@ Remove when not testing\n        var prefix = this.prefixes[namesp]\n        if (!prefix) prefix = this.makeUpPrefix(namesp)\n        if (prefix) {\n          this.namespacesUsed[namesp] = true\n          return prefix + ':' + localid\n        }\n      // Fall though if can't do qname\n      }\n    }\n    return this.explicitURI(uri)\n  }\n\n  // /////////////////////////// Quad store serialization\n\n  // @para. write  - a function taking a single string to be output\n  //\n  writeStore(write) {\n    var kb = this.store\n    var fetcher = kb.fetcher\n    var session = fetcher && fetcher.appNode\n\n    // The core data\n\n    var sources = this.store.index[3]\n    for (var s in sources) { // -> assume we can use -> as short for log:semantics\n      var source = kb.fromNT(s)\n      if (session && source.equals(session)) continue\n      write('\\n' + this.atomicTermToN3(source) + ' ' +\n        this.atomicTermToN3(kb.sym('http://www.w3.org/2000/10/swap/log#semantics')) +\n          ' { ' + this.statementsToN3(kb.statementsMatching(\n          undefined, undefined, undefined, source)) + ' }.\\n')\n    }\n\n    // The metadata from HTTP interactions:\n\n    kb.statementsMatching(undefined,\n      kb.sym('http://www.w3.org/2007/ont/link#requestedURI')).map(\n      function (st) {\n        write('\\n<' + st.object.value + '> log:metadata {\\n')\n        var sts = kb.statementsMatching(undefined, undefined, undefined, st.subject)\n        write(this.statementsToN3(this.statementsToN3(sts)))\n        write('}.\\n')\n      })\n\n    // Inferences we have made ourselves not attributable to anyone else\n\n    var metaSources = []\n    if (session) metaSources.push(session)\n    var metadata = []\n    metaSources.map(function (source) {\n      metadata = metadata.concat(kb.statementsMatching(undefined, undefined, undefined, source))\n    })\n    write(this.statementsToN3(metadata))\n  }\n\n  // ////////////////////////////////////////////// XML serialization\n\n  statementsToXML(sts) {\n    var indent = 4\n    var width = 80\n\n    var namespaceCounts = [] // which have been used\n    namespaceCounts['http://www.w3.org/1999/02/22-rdf-syntax-ns#'] = true\n\n    var liPrefix = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#_' // prefix for ordered list items\n\n    // //////////////////////// Arrange the bits of XML text\n\n    var spaces = function (n) {\n      var s = ''\n      for (var i = 0; i < n; i++) s += ' '\n      return s\n    }\n\n    var XMLtreeToLine = function (tree) {\n      var str = ''\n      for (var i = 0; i < tree.length; i++) {\n        var branch = tree[i]\n        var s2 = (typeof branch === 'string') ? branch : XMLtreeToLine(branch)\n        str += s2\n      }\n      return str\n    }\n\n    // Convert a nested tree of lists and strings to a string\n    var XMLtreeToString = function (tree, level) {\n      var str = ''\n      var line\n      var lastLength = 100000\n      if (!level) level = 0\n      for (var i = 0; i < tree.length; i++) {\n        var branch = tree[i]\n        if (typeof branch !== 'string') {\n          var substr = XMLtreeToString(branch, level + 1)\n          if (\n            substr.length < 10 * (width - indent * level) &&\n            substr.indexOf('\"\"\"') < 0) { // Don't mess up multiline strings\n            line = XMLtreeToLine(branch)\n            if (line.length < (width - indent * level)) {\n              branch = '   ' + line //   @@ Hack: treat as string below\n              substr = ''\n            }\n          }\n          if (substr) lastLength = 10000\n          str += substr\n        }\n        if (typeof branch === 'string') {\n          if (lastLength < (indent * level + 4)) { // continue\n            str = str.slice(0, -1) + ' ' + branch + '\\n'\n            lastLength += branch.length + 1\n          } else {\n            line = spaces(indent * level) + branch\n            str += line + '\\n'\n            lastLength = line.length\n          }\n        } else { // not string\n        }\n      }\n      return str\n    }\n\n    function statementListToXMLTreeMethod (statements) {\n      this.suggestPrefix('rdf', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#')\n      var stats = this.rootSubjects(statements)\n      var roots = stats.roots\n      var results = []\n      for (var i = 0; i < roots.length; i++) {\n        var root = roots[i]\n        results.push(subjectXMLTree(root, stats))\n      }\n      return results\n    }\n    var statementListToXMLTree = statementListToXMLTreeMethod.bind(this)\n\n    function escapeForXML (str) {\n      if (typeof str === 'undefined') return '@@@undefined@@@@'\n      return str.replace(/[&<\"]/g, function (m) {\n        switch (m[0]) {\n          case '&':\n            return '&amp;'\n          case '<':\n            return '&lt;'\n          case '\"':\n            return '&quot;' // '\n        }\n      })\n    }\n\n    function relURIMethod (term) {\n      return escapeForXML((this.base) ? Util.uri.refTo(this.base, term.uri) : term.uri)\n    }\n    var relURI = relURIMethod.bind(this)\n\n    // The tree for a subject\n    function subjectXMLTreeMethod (subject, stats) {\n      var results = []\n      var type, t, st, pred\n      var sts = stats.subjects[this.toStr(subject)] // relevant statements\n      if (typeof sts === 'undefined') { // empty bnode\n        return propertyXMLTree(subject, stats)\n      }\n\n      // Sort only on the predicate, leave the order at object\n      // level undisturbed.  This leaves multilingual content in\n      // the order of entry (for partner literals), which helps\n      // readability.\n      //\n      // For the predicate sort, we attempt to split the uri\n      // as a hint to the sequence\n      sts.sort(function (a, b) {\n        var ap = a.predicate.uri\n        var bp = b.predicate.uri\n        if (ap.substring(0, liPrefix.length) === liPrefix || bp.substring(0, liPrefix.length) === liPrefix) { // we're only interested in sorting list items\n          return ap.localeCompare(bp)\n        }\n\n        var as = ap.substring(liPrefix.length)\n        var bs = bp.substring(liPrefix.length)\n        var an = parseInt(as, 10)\n        var bn = parseInt(bs, 10)\n        if (isNaN(an) || isNaN(bn) ||\n          an !== as || bn !== bs) { // we only care about integers\n          return ap.localeCompare(bp)\n        }\n\n        return an - bn\n      })\n\n      for (var i = 0; i < sts.length; i++) {\n        st = sts[i]\n        // look for a type\n        if (st.predicate.uri === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type' && !type && st.object.termType === 'NamedNode') {\n          type = st.object\n          continue // don't include it as a child element\n        }\n\n        // see whether predicate can be replaced with \"li\"\n        pred = st.predicate\n        if (pred.uri.substr(0, liPrefix.length) === liPrefix) {\n          var number = pred.uri.substr(liPrefix.length)\n          // make sure these are actually numeric list items\n          var intNumber = parseInt(number, 10)\n          if (number === intNumber.toString()) {\n            // was numeric; don't need to worry about ordering since we've already\n            // sorted the statements\n            pred = this.rdfFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#li')\n          }\n        }\n\n        t = qname(pred)\n        switch (st.object.termType) {\n          case 'BlankNode':\n            if (stats.incoming[st.object].length === 1) { // there should always be something in the incoming array for a bnode\n              results = results.concat(['<' + t + ' rdf:parseType=\"Resource\">',\n                subjectXMLTree(st.object, stats),\n                '</' + t + '>'])\n            } else {\n              results = results.concat(['<' + t + ' rdf:nodeID=\"' +\n                st.object.toNT().slice(2) + '\"/>'])\n            }\n            break\n          case 'NamedNode':\n            results = results.concat(['<' + t + ' rdf:resource=\"' +\n              relURI(st.object) + '\"/>'])\n            break\n          case 'Literal':\n            results = results.concat(['<' + t +\n            (st.object.datatype.equals(this.xsd.string)\n              ? ''\n              : ' rdf:datatype=\"' + escapeForXML(st.object.datatype.uri) + '\"') +\n            (st.object.language ? ' xml:lang=\"' + st.object.language + '\"' : '') +\n            '>' + escapeForXML(st.object.value) +\n            '</' + t + '>'])\n            break\n          case 'Collection':\n            results = results.concat(['<' + t + ' rdf:parseType=\"Collection\">',\n              collectionXMLTree(st.object, stats),\n              '</' + t + '>'])\n            break\n          default:\n            throw new Error(\"Can't serialize object of type \" + st.object.termType + ' into XML')\n        } // switch\n      }\n\n      var tag = type ? qname(type) : 'rdf:Description'\n\n      var attrs = ''\n      if (subject.termType === 'BlankNode') {\n        if (!stats.incoming[subject] || stats.incoming[subject].length !== 1) { // not an anonymous bnode\n          attrs = ' rdf:nodeID=\"' + subject.toNT().slice(2) + '\"'\n        }\n      } else {\n        attrs = ' rdf:about=\"' + relURI(subject) + '\"'\n      }\n\n      return [ '<' + tag + attrs + '>' ].concat([results]).concat(['</' + tag + '>'])\n    }\n\n    var subjectXMLTree = subjectXMLTreeMethod.bind(this)\n\n    function collectionXMLTree (subject, stats) {\n      var res = []\n      for (var i = 0; i < subject.elements.length; i++) {\n        res.push(subjectXMLTree(subject.elements[i], stats))\n      }\n      return res\n    }\n\n    // The property tree for a single subject or anonymos node\n    function propertyXMLTreeMethod (subject, stats) {\n      var results = []\n      var sts = stats.subjects[this.toStr(subject)] // relevant statements\n      if (!sts) return results // No relevant statements\n      sts.sort()\n      for (var i = 0; i < sts.length; i++) {\n        var st = sts[i]\n        switch (st.object.termType) {\n          case 'BlankNode':\n            if (stats.rootsHash[st.object.toNT()]) { // This bnode has been done as a root -- no content here @@ what bout first time\n              results = results.concat(['<' + qname(st.predicate) + ' rdf:nodeID=\"' + st.object.toNT().slice(2) + '\">',\n                '</' + qname(st.predicate) + '>'])\n            } else {\n              results = results.concat(['<' + qname(st.predicate) + ' rdf:parseType=\"Resource\">',\n                propertyXMLTree(st.object, stats),\n                '</' + qname(st.predicate) + '>'])\n            }\n            break\n          case 'NamedNode':\n            results = results.concat(['<' + qname(st.predicate) + ' rdf:resource=\"' +\n              relURI(st.object) + '\"/>'])\n            break\n          case 'Literal':\n            results = results.concat(['<' + qname(st.predicate) +\n              (st.object.datatype.equals(this.xsd.string) ? '' : ' rdf:datatype=\"' + escapeForXML(st.object.datatype.value) + '\"') +\n              (st.object.language ? ' xml:lang=\"' + st.object.language + '\"' : '') +\n              '>' + escapeForXML(st.object.value) +\n              '</' + qname(st.predicate) + '>'])\n            break\n          case 'Collection':\n            results = results.concat(['<' + qname(st.predicate) + ' rdf:parseType=\"Collection\">',\n              collectionXMLTree(st.object, stats),\n              '</' + qname(st.predicate) + '>'])\n            break\n          default:\n            throw new Error(\"Can't serialize object of type \" + st.object.termType + ' into XML')\n        } // switch\n      }\n      return results\n    }\n    var propertyXMLTree = propertyXMLTreeMethod.bind(this)\n\n    function qnameMethod (term) {\n      var uri = term.uri\n\n      var j = uri.indexOf('#')\n      if (j < 0 && this.flags.indexOf('/') < 0) {\n        j = uri.lastIndexOf('/')\n      }\n      if (j < 0) throw new Error('Cannot make qname out of <' + uri + '>')\n\n      for (var k = j + 1; k < uri.length; k++) {\n        if (this._notNameChars.indexOf(uri[k]) >= 0) {\n          throw new Error('Invalid character \"' + uri[k] + '\" cannot be in XML qname for URI: ' + uri)\n        }\n      }\n      var localid = uri.slice(j + 1)\n      var namesp = uri.slice(0, j + 1)\n      if (this.defaultNamespace && this.defaultNamespace === namesp &&\n        this.flags.indexOf('d') < 0) { // d -> suppress default\n        return localid\n      }\n      var prefix = this.prefixes[namesp]\n      if (!prefix) prefix = this.makeUpPrefix(namesp)\n      namespaceCounts[namesp] = true\n      return prefix + ':' + localid\n    }\n    var qname = qnameMethod.bind(this)\n\n    // Body of toXML:\n\n    var tree = statementListToXMLTree(sts)\n    var str = '<rdf:RDF'\n    if (this.defaultNamespace) {\n      str += ' xmlns=\"' + escapeForXML(this.defaultNamespace) + '\"'\n    }\n    for (var ns in namespaceCounts) {\n      if (!namespaceCounts.hasOwnProperty(ns)) continue\n      // Rel uris in xml ns is not strictly allowed in the XMLNS spec but needed in practice often\n      var ns2 = (this.base && this.flags.includes('z')) ? Util.uri.refTo(this.base, ns) : ns\n      str += '\\n xmlns:' + this.prefixes[ns] + '=\"' + escapeForXML(ns2) + '\"'\n    }\n    str += '>'\n\n    var tree2 = [str, tree, '</rdf:RDF>'] // @@ namespace declrations\n    return XMLtreeToString(tree2, -1)\n  } // End @@ body\n\n  statementsToJsonld (sts) {\n    // ttl2jsonld creates context keys for all ttl prefix\n    // context keys must be absolute IRI ttl2jsonld@0.0.8\n    /* function findId (itemObj) {\n      if (itemObj['@id']) {\n        const item = itemObj['@id'].split(':')\n        if (keys[item[0]]) itemObj['@id'] = jsonldObj['@context'][item[0]] + item[1]\n      }\n      const itemValues = Object.values(itemObj)\n      for (const i in itemValues) {\n        if (typeof itemValues[i] !== 'string') { // @list contains array\n          findId(itemValues[i])\n        }\n      }\n    } */\n    const turtleDoc = this.statementsToN3(sts)\n    const jsonldObj = ttl2jsonld.parse(turtleDoc)\n    return JSON.stringify(jsonldObj, null, 2)\n  }\n\n}\n\n// String escaping utilities\n\nfunction hexify (str) { // also used in parser\n  return encodeURI(str)\n}\n\nfunction backslashUify (str) {\n  var res = ''\n  var k\n  for (var i = 0; i < str.length; i++) {\n    k = str.charCodeAt(i)\n    if (k > 65535) {\n      res += '\\\\U' + ('00000000' + k.toString(16)).slice(-8) // convert to upper?\n    } else if (k > 126) {\n      res += '\\\\u' + ('0000' + k.toString(16)).slice(-4)\n    } else {\n      res += str[i]\n    }\n  }\n  return res\n}\n","import Formula from './formula'\nimport Serializer from './serializer'\nimport {\n  ContentType,\n  JSONLDContentType,\n  N3ContentType,\n  N3LegacyContentType,\n  NQuadsAltContentType,\n  NQuadsContentType,\n  NTriplesContentType,\n  RDFXMLContentType,\n  TurtleContentType,\n  TurtleLegacyContentType,\n} from './types'\nimport IndexedFormula from './store'\nimport { BlankNode, NamedNode } from './tf-types'\n\n/**\n * Serialize to the appropriate format\n */\nexport default function serialize (\n  /** The graph or nodes that should be serialized */\n  target: Formula | NamedNode | BlankNode | null,\n  /** The store */\n  kb: Formula,\n  base?: unknown,\n  /**\n   * The mime type.\n   * Defaults to Turtle.\n   */\n  contentType?: string | ContentType,\n  callback?: (err: Error | undefined | null, result?: string) => any,\n  options?: {\n    /**\n     * A string of letters, each of which set an options\n     * e.g. `deinprstux`\n     */\n    flags?: string,\n    /**\n     * A set of [prefix, uri] pairs that define namespace prefixes\n     */\n    namespaces?: Record<string, string>\n  }\n): string | undefined {\n  base = base || target?.value\n  const opts = options || {}\n  contentType = contentType || TurtleContentType // text/n3 if complex?\n  var documentString: string | undefined = undefined\n  try {\n    var sz = Serializer(kb)\n    if ((opts as any).flags) sz.setFlags((opts as any).flags)\n    var newSts = kb!.statementsMatching(undefined, undefined, undefined, target as NamedNode)\n\n    // If an IndexedFormula, use the namespaces from the given graph as suggestions\n    if ('namespaces' in kb) {\n      sz.suggestNamespaces( (kb as IndexedFormula).namespaces);\n    }\n\n    // use the provided options.namespaces are mandatory prefixes\n    if (opts.namespaces) {\n      sz.setNamespaces( opts.namespaces);\n    }\n\n    sz.setBase(base)\n    switch (contentType) {\n      case RDFXMLContentType:\n        documentString = sz.statementsToXML(newSts)\n        return executeCallback(null, documentString)\n      case N3ContentType:\n      case N3LegacyContentType:\n        documentString = sz.statementsToN3(newSts)\n        return executeCallback(null, documentString)\n      case TurtleContentType:\n      case TurtleLegacyContentType:\n        sz.setFlags('si') // Suppress = for sameAs and => for implies\n        documentString = sz.statementsToN3(newSts)\n        return executeCallback(null, documentString)\n      case NTriplesContentType:\n        sz.setFlags('deinprstux') // Suppress nice parts of N3 to make ntriples\n        documentString = sz.statementsToNTriples(newSts)\n        return executeCallback(null, documentString)\n      case JSONLDContentType:\n        sz.setFlags('si dr') // turtle + dr (means no default, no relative prefix)\n        documentString = sz.statementsToJsonld(newSts) // convert via turtle\n        return executeCallback(null, documentString)\n      case NQuadsContentType:\n      case NQuadsAltContentType: // @@@ just outpout the quads? Does not work for collections\n        sz.setFlags('deinprstux q') // Suppress nice parts of N3 to make ntriples\n        documentString = sz.statementsToNTriples(newSts) // q in flag means actually quads\n        return executeCallback(null, documentString)\n      default:\n        throw new Error('Serialize: Content-type ' + contentType + ' not supported for data write.')\n    }\n  } catch (err) {\n    if (callback) {\n      // @ts-ignore\n      return callback(err, undefined)\n    }\n    throw err // Don't hide problems from caller in sync mode\n  }\n\n  function executeCallback (err: Error | null | undefined, result: string | undefined): string | undefined {\n    if (callback) {\n      callback(err, result)\n      return\n    } else {\n      return result as string\n    }\n  }\n}\n","import Fetcher from './fetcher'\nimport log from './log'\nimport { docpart } from './uri'\nimport { string_startswith } from './utils-js'\nimport { RdfJsDataFactory, Quad, Quad_Subject, Term } from './tf-types'\n\n/** RDF/JS spec Typeguards */\n\n/**\n * Loads ontologies of the data we load (this is the callback from the kb to\n * the fetcher).\n */\nexport function AJAR_handleNewTerm (kb: { fetcher: Fetcher }, p, requestedBy) {\n  var sf: Fetcher | null = null\n  if (typeof kb.fetcher !== 'undefined') {\n    sf = kb.fetcher\n  } else {\n    return\n  }\n  if (p.termType !== 'NamedNode') return\n  var docuri = docpart(p.uri)\n  var fixuri\n  if (p.uri.indexOf('#') < 0) { // No hash\n    // @@ major hack for dbpedia Categories, which spread indefinitely\n    if (string_startswith(p.uri, 'http://dbpedia.org/resource/Category:')) return\n\n    /*\n      if (string_startswith(p.uri, 'http://xmlns.com/foaf/0.1/')) {\n      fixuri = \"http://dig.csail.mit.edu/2005/ajar/ajaw/test/foaf\"\n      // should give HTTP 303 to ontology -- now is :-)\n      } else\n    */\n    if (string_startswith(p.uri,\n            'http://purl.org/dc/elements/1.1/') ||\n          string_startswith(p.uri, 'http://purl.org/dc/terms/')) {\n      fixuri = 'http://dublincore.org/2005/06/13/dcq'\n    // dc fetched multiple times\n    } else if (string_startswith(p.uri, 'http://xmlns.com/wot/0.1/')) {\n      fixuri = 'http://xmlns.com/wot/0.1/index.rdf'\n    } else if (string_startswith(p.uri, 'http://web.resource.org/cc/')) {\n      //            log.warn(\"creative commons links to html instead of rdf. doesn't seem to content-negotiate.\")\n      fixuri = 'http://web.resource.org/cc/schema.rdf'\n    }\n  }\n  if (fixuri) {\n    docuri = fixuri\n  }\n  if (sf && (sf as Fetcher).getState(docuri) !== 'unrequested') return\n\n  if (fixuri) { // only give warning once: else happens too often\n    log.warn('Assuming server still broken, faking redirect of <' + p.uri +\n      '> to <' + docuri + '>')\n  }\n\n  return (sf as any).fetch(docuri, { referringTerm: requestedBy })\n}\n\nexport const appliedFactoryMethods = [\n  'blankNode',\n  'defaultGraph',\n  'literal',\n  'namedNode',\n  'quad',\n  'variable',\n  'supports',\n]\n\nconst rdf = {\n  first: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#first',\n  rest: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#rest',\n  nil: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil'\n}\n\n/**\n * Expands an array of Terms to a set of statements representing the rdf:list.\n * @param rdfFactory - The factory to use\n * @param subject - The iri of the first list item.\n * @param data - The terms to expand into the list.\n * @return The {data} as a set of statements.\n */\nexport function arrayToStatements(\n  rdfFactory: RdfJsDataFactory,\n  subject: Quad_Subject,\n  data: Term[]\n): Quad[] {\n  const statements: Quad[] = []\n\n  data.reduce<Quad_Subject>((id, _listObj, i, listData) => {\n    statements.push(rdfFactory.quad(id, rdfFactory.namedNode(rdf.first), listData[i]))\n\n    let nextNode\n    if (i < listData.length - 1) {\n      nextNode = rdfFactory.blankNode()\n      statements.push(rdfFactory.quad(id, rdfFactory.namedNode(rdf.rest), nextNode))\n    } else {\n      statements.push(rdfFactory.quad(id, rdfFactory.namedNode(rdf.rest), rdfFactory.namedNode(rdf.nil)))\n    }\n\n    return nextNode\n  }, subject)\n\n  return statements\n}\n\nexport function ArrayIndexOf (arr, item, i: number = 0) {\n  var length = arr.length\n  if (i < 0) i = length + i\n  for (; i < length; i++) {\n    if (arr[i] === item) {\n      return i\n    }\n  }\n  return -1\n}\n","import ClassOrder from './class-order'\nimport Collection from './collection'\nimport CanonicalDataFactory from './factories/canonical-data-factory'\nimport log from './log'\nimport RDFlibNamedNode from './named-node'\nimport Namespace from './namespace'\nimport Node from './node-internal'\nimport serialize from './serialize'\nimport Statement from './statement'\nimport {\n  Bindings,\n  GraphTermType,\n} from './types'\nimport { isStatement } from './utils/terms'\nimport Variable from './variable'\nimport {\n  Indexable,\n  TFIDFactoryTypes,\n} from './factories/factory-types'\nimport { appliedFactoryMethods, arrayToStatements } from './utils'\nimport {\n  RdfJsDataFactory,\n  Quad_Graph,\n  Quad_Object,\n  Quad_Predicate,\n  Quad,\n  Quad_Subject,\n  Term,\n} from './tf-types'\nimport Fetcher from './fetcher'\nimport BlankNode from './blank-node'\nimport NamedNode from './named-node'\n\nexport interface FormulaOpts {\n  dataCallback?: (q: Quad) => void\n  rdfArrayRemove?: (arr: Quad[], q: Quad) => void\n  rdfFactory?: RdfJsDataFactory\n}\n\ninterface BooleanMap {\n  [uri: string]: boolean;\n}\n\ninterface MembersMap {\n  [uri: string]: Quad;\n}\n\ninterface UriMap {\n  [uri: string]: string;\n}\n\n/**\n * A formula, or store of RDF statements\n */\nexport default class Formula extends Node {\n  termType: typeof GraphTermType = GraphTermType\n\n  classOrder = ClassOrder.Graph\n\n  /**\n   * The accompanying fetcher instance.\n   *\n   * Is set by the fetcher when initialized.\n   */\n  fetcher?: Fetcher\n\n  isVar = 0\n\n  /**\n   * A namespace for the specified namespace's URI\n   * @param nsuri The URI for the namespace\n   */\n  ns = Namespace\n\n  /** The factory used to generate statements and terms */\n  rdfFactory: any\n\n  /**\n   * Initializes this formula\n   * @constructor\n   * @param statements - Initial array of statements\n   * @param constraints - initial array of constraints\n   * @param initBindings - initial bindings used in Query\n   * @param optional - optional\n   * @param opts\n   * @param opts.rdfFactory - The rdf factory that should be used by the store\n*/\n  constructor (\n    public statements: Array<Statement> = [],\n    public constraints: ReadonlyArray<any> = [],\n    public initBindings: ReadonlyArray<any> = [],\n    public optional: ReadonlyArray<any> = [],\n    opts: FormulaOpts = {}\n    ) {\n    super('')\n\n    this.rdfFactory = (opts && opts.rdfFactory) || CanonicalDataFactory\n    // Enable default factory methods on this while preserving factory context.\n    for(const factoryMethod of appliedFactoryMethods) {\n      this[factoryMethod] = (...args) => this.rdfFactory[factoryMethod](...args)\n    }\n  }\n\n  /** Add a statement from its parts\n   * @param subject - the first part of the statement\n   * @param predicate - the second part of the statement\n   * @param object - the third part of the statement\n   * @param graph - the last part of the statement\n   */\n  add (\n    subject: Quad_Subject | Quad | Quad[],\n    predicate?: Quad_Predicate,\n    object?: Term | string,\n    graph?: Quad_Graph\n  ): Statement | null | this | number {\n    if (arguments.length === 1) {\n      (subject as Quad[]).forEach(st => this.add(st.subject, st.predicate, st.object, st.graph))\n    }\n    return this.statements.push(this.rdfFactory.quad(subject, predicate, object, graph))\n  }\n\n  /** Add a statment object\n   * @param {Statement} statement - An existing constructed statement to add\n   */\n  addStatement (statement: Quad): Statement | null | this | number {\n    return this.add(statement)\n  }\n\n  /**\n   * Shortcut for adding blankNodes\n   * @param [id]\n   */\n  bnode (id?: string): BlankNode {\n    return this.rdfFactory.blankNode(id)\n  }\n\n  /**\n   * Adds all the statements to this formula\n   * @param statements - A collection of statements\n   */\n  addAll (statements: Quad[]): void {\n    statements.forEach(quad => {\n      this.add(quad.subject, quad.predicate, quad.object, quad.graph)\n    })\n  }\n\n  /** Follow link from one node, using one wildcard, looking for one\n  *\n  * For example, any(me, knows, null, profile)  - a person I know accoring to my profile .\n  * any(me, knows, null, null)  - a person I know accoring to anything in store .\n  * any(null, knows, me, null)  - a person who know me accoring to anything in store .\n  *\n  * @param s - A node to search for as subject, or if null, a wildcard\n  * @param p - A node to search for as predicate, or if null, a wildcard\n  * @param o - A node to search for as object, or if null, a wildcard\n  * @param g - A node to search for as graph, or if null, a wildcard\n  * @returns A node which match the wildcard position, or null\n  */\n  any(\n    s?: Quad_Subject | null,\n    p?: Quad_Predicate | null,\n    o?: Quad_Object | null,\n    g?: Quad_Graph | null\n  ): Node | null {\n    const st = this.anyStatementMatching(s, p, o, g)\n    if (st == null) {\n      return null\n    } else if (s == null) {\n      return st.subject\n    } else if (p == null) {\n      return st.predicate\n    } else if (o == null) {\n      return st.object\n    }\n\n    return null\n  }\n\n  /**\n   * Gets the value of a node that matches the specified pattern\n   * @param s The subject\n   * @param p The predicate\n   * @param o The object\n   * @param g The graph that contains the statement\n   */\n  anyValue(\n    s?: Quad_Subject | null,\n    p?: Quad_Predicate | null,\n    o?: Quad_Object | null,\n    g?: Quad_Graph | null\n  ): string | void {\n    const y = this.any(s, p, o, g)\n    return y ? y.value : void 0\n  }\n\n  /**\n   * Gets the first JavaScript object equivalent to a node based on the specified pattern\n   * @param s The subject\n   * @param p The predicate\n   * @param o The object\n   * @param g The graph that contains the statement\n   */\n  anyJS(\n    s?: Quad_Subject | null,\n    p?: Quad_Predicate | null,\n    o?: Quad_Object | null,\n    g?: Quad_Graph | null\n  ): any {\n    const y = this.any(s, p, o, g)\n    return y ? Node.toJS(y) : void 0\n  }\n\n  /**\n   * Gets the first statement that matches the specified pattern\n   */\n  anyStatementMatching(\n    s?: Quad_Subject | null,\n    p?: Quad_Predicate | null,\n    o?: Quad_Object | null,\n    g?: Quad_Graph | null\n  ): Statement | undefined {\n    let x = this.statementsMatching(s, p, o, g, true)\n    if (!x || x.length === 0) {\n      return undefined\n    }\n\n    return x[0]\n  }\n\n  /**\n   * Returns a unique index-safe identifier for the given term.\n   *\n   * Falls back to the rdflib hashString implementation if the given factory doesn't support id.\n   */\n  id (term: TFIDFactoryTypes): Indexable {\n    return this.rdfFactory.id(term)\n  }\n\n  /**\n   * Search the Store\n   * This is really a teaching method as to do this properly you would use IndexedFormula\n   *\n   * @param s - A node to search for as subject, or if null, a wildcard\n   * @param p - A node to search for as predicate, or if null, a wildcard\n   * @param o - A node to search for as object, or if null, a wildcard\n   * @param g - A node to search for as graph, or if null, a wildcard\n   * @param justOne - flag - stop when found one rather than get all of them?\n   * @returns {Array<Node>} - An array of nodes which match the wildcard position\n   */\n  statementsMatching<JustOne extends boolean = false>(\n    s?: Quad_Subject | null,\n    p?: Quad_Predicate | null,\n    o?: Quad_Object | null,\n    g?: Quad_Graph | null,\n    justOne?: boolean\n  ): Statement[] {\n    const sts = this.statements.filter(st =>\n      (!s || s.equals(st.subject)) &&\n      (!p || p.equals(st.predicate)) &&\n      (!o || o.equals(st.object)) &&\n      (!g || g.equals(st.graph))\n    )\n\n    if (justOne) {\n      return sts.length === 0 ? [] : [sts[0]]\n    }\n\n    return sts\n  }\n\n  /**\n   * Finds the types in the list which have no *stored* subtypes\n   * These are a set of classes which provide by themselves complete\n   * information -- the other classes are redundant for those who\n   * know the class DAG.\n   * @param types A map of the types\n   */\n  bottomTypeURIs (types) {\n    let bots\n    let bottom\n    let elt\n    let i\n    let len\n    let ref\n    let subs\n    let v\n    bots = []\n    for (let k in types) {\n      if (!types.hasOwnProperty(k)) continue\n      v = types[k]\n      subs = this.each(\n        void 0,\n        this.rdfFactory.namedNode('http://www.w3.org/2000/01/rdf-schema#subClassOf'),\n        this.rdfFactory.namedNode(k)\n      )\n      bottom = true\n      i = 0\n      for (len = subs.length; i < len; i++) {\n        elt = subs[i]\n        ref = elt.uri\n        if (ref in types) { // the subclass is one we know\n          bottom = false\n          break\n        }\n      }\n      if (bottom) {\n        bots[k] = v\n      }\n    }\n    return bots\n  }\n\n  /** Creates a new collection */\n  collection (): Collection {\n    return new Collection()\n  }\n\n  /** Follow links from one node, using one wildcard.\n  *\n  * For example, each(me, knows, null, profile)  - people I know accoring to my profile .\n  * each(me, knows, null, null)  - people I know accoring to anything in store .\n  * each(null, knows, me, null)  - people who know me accoring to anything in store .\n  *\n  * @param s - A node to search for as subject, or if null, a wildcard\n  * @param p - A node to search for as predicate, or if null, a wildcard\n  * @param o - A node to search for as object, or if null, a wildcard\n  * @param g - A node to search for as graph, or if null, a wildcard\n  * @returns {Array<Node>} - An array of nodes which match the wildcard position\n  */\n  each(\n    s?: Quad_Subject | null,\n    p?: Quad_Predicate | null,\n    o?: Quad_Object | null,\n    g?: Quad_Graph | null\n  ): Node[] {\n    const results: Node[] = []\n    let sts = this.statementsMatching(s, p, o, g, false)\n    if (s == null) {\n      for (let i = 0, len = sts.length; i < len; i++) {\n        results.push(sts[i].subject)\n      }\n    } else if (p == null) {\n      for (let l = 0, len1 = sts.length; l < len1; l++) {\n        results.push(sts[l].predicate)\n      }\n    } else if (o == null) {\n      for (let m = 0, len2 = sts.length; m < len2; m++) {\n        results.push(sts[m].object)\n      }\n    } else if (g == null) {\n      for (let q = 0, len3 = sts.length; q < len3; q++) {\n        results.push(new NamedNode(sts[q].graph.value))\n      }\n    }\n\n    return results\n  }\n\n  /**\n   * Test whether this formula is equals to {other}\n   * @param other - The other formula\n   */\n  equals(other: Formula): boolean {\n    if (!other) {\n      return false\n    }\n    return this.hashString() === other.hashString()\n  }\n\n  /**\n   * For thisClass or any subclass, anything which has it is its type\n   * or is the object of something which has the type as its range, or subject\n   * of something which has the type as its domain\n   * We don't bother doing subproperty (yet?)as it doesn't seeem to be used\n   * much.\n   * Get all the Classes of which we can RDFS-infer the subject is a member\n   * @return a hash of URIs\n   */\n  findMembersNT (thisClass) {\n    let len2: number\n    let len4: number\n    let m: number\n    let members: MembersMap\n    let pred: Quad_Predicate\n    let ref\n    let ref1: Quad[]\n    let ref2: Term[]\n    let ref3: Quad[]\n    let ref4: Term[]\n    let ref5: Quad[]\n    let seeds\n    let st\n    let u: number\n    seeds = {}\n    seeds[thisClass.toNT()] = true\n    members = {}\n    ref = this.transitiveClosure(seeds, this.rdfFactory.namedNode('http://www.w3.org/2000/01/rdf-schema#subClassOf'), true)\n    for (let t in ref) {\n      if (!ref.hasOwnProperty(t)) continue\n      ref1 = this.statementsMatching(void 0,\n        this.rdfFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'),\n        this.fromNT(t))\n      for (let i = 0, len = ref1.length; i < len; i++) {\n        st = ref1[i]\n        members[st.subject.toNT()] = st\n      }\n      ref2 = this.each(void 0,\n        this.rdfFactory.namedNode('http://www.w3.org/2000/01/rdf-schema#domain'),\n        this.fromNT(t))\n      for (let l = 0, len1 = ref2.length; l < len1; l++) {\n        pred = ref2[l] as Quad_Predicate\n        ref3 = this.statementsMatching(void 0, pred)\n        for (m = 0, len2 = ref3.length; m < len2; m++) {\n          st = ref3[m]\n          members[st.subject.toNT()] = st\n        }\n      }\n      ref4 = this.each(void 0,\n        this.rdfFactory.namedNode('http://www.w3.org/2000/01/rdf-schema#range'),\n        this.fromNT(t))\n      for (let q = 0, len3 = ref4.length; q < len3; q++) {\n        pred = ref4[q] as Quad_Predicate\n        ref5 = this.statementsMatching(void 0, pred)\n        for (u = 0, len4 = ref5.length; u < len4; u++) {\n          st = ref5[u]\n          members[st.object.toNT()] = st\n        }\n      }\n    }\n\n    return members\n  }\n\n  /**\n   * For thisClass or any subclass, anything which has it is its type\n   * or is the object of something which has the type as its range, or subject\n   * of something which has the type as its domain\n   * We don't bother doing subproperty (yet?)as it doesn't seeem to be used\n   * much.\n   * Get all the Classes of which we can RDFS-infer the subject is a member\n   * @param subject - A named node\n   */\n  findMemberURIs(subject: Node): UriMap {\n    return this.NTtoURI(this.findMembersNT(subject))\n  }\n\n  /**\n   * Get all the Classes of which we can RDFS-infer the subject is a superclass\n   * Returns a hash table where key is NT of type and value is statement why we\n   * think so.\n   * Does NOT return terms, returns URI strings.\n   * We use NT representations in this version because they handle blank nodes.\n   */\n  findSubClassesNT(subject: Node): { [uri: string]: boolean } {\n    let types = {}\n    types[subject.toNT()] = true\n    return this.transitiveClosure(\n      types,\n      this.rdfFactory.namedNode('http://www.w3.org/2000/01/rdf-schema#subClassOf'),\n      true\n    )\n  }\n\n  /**\n   * Get all the Classes of which we can RDFS-infer the subject is a subclass\n   * @param {RDFlibNamedNode} subject - The thing whose classes are to be found\n   * @returns a hash table where key is NT of type and value is statement why we\n   * think so.\n   * Does NOT return terms, returns URI strings.\n   * We use NT representations in this version because they handle blank nodes.\n   */\n  findSuperClassesNT(subject: Node): { [uri: string]: boolean } {\n    let types = {}\n    types[subject.toNT()] = true\n    return this.transitiveClosure(types,\n      this.rdfFactory.namedNode('http://www.w3.org/2000/01/rdf-schema#subClassOf'), false)\n  }\n\n  /**\n   * Get all the Classes of which we can RDFS-infer the subject is a member\n   * todo: This will loop is there is a class subclass loop (Sublass loops are\n   * not illegal)\n   * @param {RDFlibNamedNode} subject - The thing whose classes are to be found\n   * @returns a hash table where key is NT of type and value is statement why we think so.\n   * Does NOT return terms, returns URI strings.\n   * We use NT representations in this version because they handle blank nodes.\n   */\n  findTypesNT (subject) {\n    let domain\n    let range\n    let rdftype\n    let ref\n    let ref1\n    let ref2\n    let ref3\n    let st\n    let types\n    rdftype = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type'\n    types = []\n    ref = this.statementsMatching(subject, void 0, void 0)\n    for (let i = 0, len = ref.length; i < len; i++) {\n      st = ref[i]\n      if (st.predicate.uri === rdftype) {\n        types[st.object.toNT()] = st\n      } else {\n        ref1 = this.each(\n          st.predicate,\n          this.rdfFactory.namedNode('http://www.w3.org/2000/01/rdf-schema#domain')\n        )\n        for (let l = 0, len1 = ref1.length; l < len1; l++) {\n          range = ref1[l]\n          types[range.toNT()] = st\n        }\n      }\n    }\n    ref2 = this.statementsMatching(void 0, void 0, subject)\n    for (let m = 0, len2 = ref2.length; m < len2; m++) {\n      st = ref2[m]\n      ref3 = this.each(\n        st.predicate,\n        this.rdfFactory.namedNode('http://www.w3.org/2000/01/rdf-schema#range')\n      )\n      for (let q = 0, len3 = ref3.length; q < len3; q++) {\n        domain = ref3[q]\n        types[domain.toNT()] = st\n      }\n    }\n    return this.transitiveClosure(\n      types,\n      this.rdfFactory.namedNode('http://www.w3.org/2000/01/rdf-schema#subClassOf'),\n      false\n    )\n  }\n\n  /**\n   * Get all the Classes of which we can RDFS-infer the subject is a member\n   * todo: This will loop is there is a class subclass loop (Sublass loops are\n   * not illegal)\n   * Returns a hash table where key is NT of type and value is statement why we\n   * think so.\n   * Does NOT return terms, returns URI strings.\n   * We use NT representations in this version because they handle blank nodes.\n   * @param subject - A subject node\n   */\n  findTypeURIs(subject: Quad_Subject): UriMap {\n    return this.NTtoURI(this.findTypesNT(subject))\n  }\n\n  /** Trace statements which connect directly, or through bnodes\n   *\n   * @param subject - The node to start looking for statments\n   * @param doc - The document to be searched, or null to search all documents\n   * @returns an array of statements, duplicate statements are suppresssed.\n   */\n  connectedStatements(\n    subject: Quad_Subject,\n    doc: Quad_Graph,\n    excludePredicateURIs?: ReadonlyArray<string>\n  ): Statement[] {\n    excludePredicateURIs = excludePredicateURIs || []\n    let todo = [subject]\n    let done: { [k: string]: boolean } = {}\n    let doneArcs: { [k: string]: boolean }  = {}\n    let result: Statement[] = []\n    let self = this\n    let follow = function (x) {\n      let queue = function (x) {\n        if (x.termType === 'BlankNode' && !done[x.value]) {\n          done[x.value] = true\n          todo.push(x)\n        }\n      }\n      let sts = self.statementsMatching(null, null, x, doc)\n        .concat(self.statementsMatching(x, null, null, doc))\n      sts = sts.filter(function (st): boolean {\n        if (excludePredicateURIs![st.predicate.value]) return false\n        let hash = (st as Statement).toNT()\n        if (doneArcs[hash]) return false\n        doneArcs[hash] = true\n        return true\n      }\n      )\n      sts.forEach(function (st) {\n        queue(st.subject)\n        queue(st.object)\n      })\n      result = result.concat(sts)\n    }\n    while (todo.length) {\n      follow(todo.shift())\n    }\n    return result\n  }\n\n  /**\n   * Creates a new empty formula\n   *\n   * @param _features - Not applicable, but necessary for typing to pass\n   */\n  formula(_features?: ReadonlyArray<string>): Formula {\n    return new Formula()\n  }\n\n  /**\n   * Transforms an NTriples string format into a Node.\n   * The blank node bit should not be used on program-external values; designed\n   * for internal work such as storing a blank node id in an HTML attribute.\n   * This will only parse the strings generated by the various toNT() methods.\n   */\n  fromNT (str) {\n    let dt, k, lang\n    switch (str[0]) {\n      case '<':\n        return this.sym(str.slice(1, -1))\n      case '\"':\n        lang = void 0\n        dt = void 0\n        k = str.lastIndexOf('\"')\n        if (k < str.length - 1) {\n          if (str[k + 1] === '@') {\n            lang = str.slice(k + 2)\n          } else if (str.slice(k + 1, k + 3) === '^^') {\n            dt = this.fromNT(str.slice(k + 3))\n          } else {\n            throw new Error(\"Can't convert string from NT: \" + str)\n          }\n        }\n        str = str.slice(1, k)\n        str = str.replace(/\\\\\"/g, '\"')\n        str = str.replace(/\\\\n/g, '\\n')\n        str = str.replace(/\\\\\\\\/g, '\\\\')\n        return this.rdfFactory.literal(str, lang || dt)\n      case '_':\n        return this.rdfFactory.blankNode(str.slice(2))\n      case '?':\n        return new Variable(str.slice(1))\n    }\n    throw new Error(\"Can't convert from NT: \" + str)\n  }\n\n  /** Returns true if this formula holds the specified statement(s) */\n  holds (s: any | any[], p?, o?, g?): boolean {\n    let i\n    if (arguments.length === 1) {\n      if (!s) {\n        return true\n      }\n      if (s instanceof Array) {\n        for (i = 0; i < s.length; i++) {\n          if (!this.holds(s[i])) {\n            return false\n          }\n        }\n        return true\n      } else if (isStatement(s)) {\n        return this.holds(s.subject, s.predicate, s.object, s.graph)\n      } else if (s.statements) {\n        return this.holds(s.statements)\n      }\n    }\n\n    let st = this.anyStatementMatching(s, p, o, g)\n    return st != null\n  }\n\n  /**\n   * Returns true if this formula holds the specified {statement}\n   */\n  holdsStatement (statement) {\n    return this.holds(\n      statement.subject,\n      statement.predicate,\n      statement.object,\n      statement.graph,\n    )\n  }\n\n  /**\n   * Used by the n3parser to generate list elements\n   * @param values - The values of the collection\n   * @param context - The store\n   * @return {BlankNode|Collection} - The term for the statement\n   */\n  list (values, context) {\n    if (context.rdfFactory.supports[\"COLLECTIONS\"]) {\n      const collection = context.rdfFactory.collection()\n      values.forEach(function (val) {\n        collection.append(val)\n      })\n      return collection\n    } else {\n      const node = context.rdfFactory.blankNode()\n      const statements = arrayToStatements(context.rdfFactory, node, values)\n      context.addAll(statements)\n      return node\n    }\n  }\n\n  /**\n   * Transform a collection of NTriple URIs into their URI strings\n   * @param t - Some iterable collection of NTriple URI strings\n   * @return A collection of the URIs as strings\n   * todo: explain why it is important to go through NT\n   */\n  NTtoURI (t) {\n    let k, v\n    let uris = {}\n    for (k in t) {\n      if (!t.hasOwnProperty(k)) continue\n      v = t[k]\n      if (k[0] === '<') {\n        uris[k.slice(1, -1)] = v\n      }\n    }\n    return uris\n  }\n\n  /**\n   * Serializes this formula\n   * @param base - The base string\n   * @param contentType - The content type of the syntax to use\n   * @param provenance - The provenance URI\n   * @param options  - options to pass to the serializer, as defined in serialize method\n   */\n  serialize (base, contentType, provenance, options?) {\n    // delegate the graph serialization to the implementation in ./serialize\n    return serialize(provenance, this, base, contentType, undefined, options);\n  }\n\n  /**\n   * Creates a new formula with the substituting bindings applied\n   * @param bindings - The bindings to substitute\n   */\n  substitute<T extends Node = Formula>(bindings: Bindings): T {\n    let statementsCopy = this.statements.map(function (ea) {\n      return (ea as Statement).substitute(bindings)\n    })\n    // console.log('Formula subs statmnts:' + statementsCopy)\n    const y = new Formula()\n    y.addAll(statementsCopy as Quad[])\n    // console.log('indexed-form subs formula:' + y)\n    return y as unknown as T\n  }\n\n  sym (uri: string, name?): NamedNode {\n    if (name) {\n      throw new Error('This feature (kb.sym with 2 args) is removed. Do not assume prefix mappings.')\n    }\n    return this.rdfFactory.namedNode(uri)\n  }\n\n  /**\n   * Gets the node matching the specified pattern. Throws when no match could be made.\n   * @param s - The subject\n   * @param p - The predicate\n   * @param o - The object\n   * @param g - The graph that contains the statement\n   */\n  the (\n    s?: Quad_Subject | null,\n    p?: Quad_Predicate | null,\n    o?: Quad_Object | null,\n    g?: Quad_Graph | null\n  ): Node | null | undefined {\n    let x = this.any(s, p, o, g)\n    if (x == null) {\n      log.error('No value found for the() {' + s + ' ' + p + ' ' + o + '}.')\n    }\n\n    return x\n  }\n\n  /**\n   * RDFS Inference\n   * These are hand-written implementations of a backward-chaining reasoner\n   * over the RDFS axioms.\n   * @param seeds - A hash of NTs of classes to start with\n   * @param predicate - The property to trace though\n   * @param inverse - Trace inverse direction\n   */\n  transitiveClosure(\n    seeds: BooleanMap,\n    predicate: Quad_Predicate,\n    inverse?: boolean\n  ): {\n    [uri: string]: boolean;\n  } {\n    let elt, i, len, s, sups, t\n    let agenda = {}\n    Object.assign(agenda, seeds)  // make a copy\n    let done = {}  // classes we have looked up\n    while (true) {\n      t = (function () {\n        for (let p in agenda) {\n          if (!agenda.hasOwnProperty(p)) continue\n          return p\n        }\n      })()\n      if (t == null) {\n        return done\n      }\n      sups = inverse ?\n        this.each(void 0, predicate, this.fromNT(t))\n        : this.each(this.fromNT(t) as Quad_Predicate, predicate)\n      for (i = 0, len = sups.length; i < len; i++) {\n        elt = sups[i]\n        s = elt.toNT()\n        if (s in done) {\n          continue\n        }\n        if (s in agenda) {\n          continue\n        }\n        agenda[s] = agenda[t]\n      }\n      done[t] = agenda[t]\n      delete agenda[t]\n    }\n  }\n\n  /**\n   * Finds the types in the list which have no *stored* supertypes\n   * We exclude the universal class, owl:Things and rdf:Resource, as it is\n   * information-free.\n   * @param types - The types\n   */\n  topTypeURIs(types: {\n    [id: string]: string | RDFlibNamedNode;\n  }): {\n    [id: string]: string | RDFlibNamedNode;\n  } {\n    let i\n    let j\n    let k\n    let len\n    let n\n    let ref\n    let tops\n    let v\n    tops = []\n    for (k in types) {\n      if (!types.hasOwnProperty(k)) continue\n      v = types[k]\n      n = 0\n      ref = this.each(\n        this.rdfFactory.namedNode(k),\n        this.rdfFactory.namedNode('http://www.w3.org/2000/01/rdf-schema#subClassOf')\n      )\n      for (i = 0, len = ref.length; i < len; i++) {\n        j = ref[i]\n        if (j.uri !== 'http://www.w3.org/2000/01/rdf-schema#Resource') {\n          n++\n          break\n        }\n      }\n      if (!n) {\n        tops[k] = v\n      }\n    }\n    if (tops['http://www.w3.org/2000/01/rdf-schema#Resource']) {\n      delete tops['http://www.w3.org/2000/01/rdf-schema#Resource']\n    }\n    if (tops['http://www.w3.org/2002/07/owl#Thing']) {\n      delete tops['http://www.w3.org/2002/07/owl#Thing']\n    }\n    return tops\n  }\n\n  /**\n   * Serializes this formula to a string\n   */\n  toString(): string {\n    return '{' + this.statements.join('\\n') + '}'\n  }\n\n  /**\n   * Gets a new variable\n   * @param name - The variable's name\n   */\n  public variable(name: string): Variable {\n    return new Variable(name)\n  }\n\n  /**\n   * Gets the number of statements in this formula that matches the specified pattern\n   * @param s - The subject\n   * @param p - The predicate\n   * @param o - The object\n   * @param g - The graph that contains the statement\n   */\n  whether(\n    s?: Quad_Subject | null,\n    p?: Quad_Predicate | null,\n    o?: Quad_Object | null,\n    g?: Quad_Graph | null\n  ): number {\n    return this.statementsMatching(s, p, o, g, false).length\n  }\n}\n","// This file attaches all functionality to Node\n// that would otherwise require circular dependencies.\nimport { fromValue } from './collection'\nimport Node from './node-internal'\nimport Namespace from './namespace'\nimport { isCollection, isLiteral } from './utils/terms'\nimport { Term } from './tf-types'\n\n/**\n * Creates an RDF Node from a native javascript value.\n * RDF Nodes are returned unchanged, undefined returned as itself.\n * @method fromValue\n * @static\n * @param value {Node|Date|String|Number|Boolean|Undefined}\n * @return {Node|Collection}\n */\nNode.fromValue = fromValue;\n\nexport default Node\n\nconst ns = { xsd: Namespace('http://www.w3.org/2001/XMLSchema#') }\n\n/**\n * Gets the javascript object equivalent to a node\n * @param term The RDF node\n */\nNode.toJS = function (term: Term): Term | boolean | number | Date | string | any[] {\n  if (isCollection(term)) {\n    return term.elements.map(Node.toJS) // Array node (not standard RDFJS)\n  }\n  if (!isLiteral(term)) return term\n  if (term.datatype.equals(ns.xsd('boolean'))) {\n    return term.value === '1' || term.value === 'true'\n  }\n  if (term.datatype.equals(ns.xsd('dateTime')) ||\n    term.datatype.equals(ns.xsd('date'))) {\n    return new Date(term.value)\n  }\n  if (\n    term.datatype.equals(ns.xsd('integer')) ||\n    term.datatype.equals(ns.xsd('float')) ||\n    term.datatype.equals(ns.xsd('decimal'))\n  ) {\n    return Number(term.value)\n  }\n  return term.value\n}\n","// Matching a formula against another formula\n// Assync as well as Synchronously\n//\n// W3C open source licence 2005.\n//\n// This builds on term.js, match.js (and identity.js?)\n// to allow a query of a formula.\n//\n// Here we introduce for the first time a subclass of term: variable.\n//\n// SVN ID: $Id: query.js 25116 2008-11-15 16:13:48Z timbl $\n\n//  Variable\n//\n// Compare with BlankNode.  They are similar, but a variable\n// stands for something whose value is to be returned.\n// Also, users name variables and want the same name back when stuff is printed\n/* jsl:option explicit */ // Turn on JavaScriptLint variable declaration checking\n\nimport IndexedFormula  from './store'\nimport { defaultGraphURI as defaultDocumentURI } from './utils/default-graph-uri'\nimport log from './log'\nimport { docpart } from './uri'\n\n/**\n * Query class, for tracking queries the user has in the UI.\n */\nexport class Query {\n  constructor (name, id) {\n    this.pat = new IndexedFormula() // The pattern to search for\n    this.vars = [] // Used by UI code but not in query.js\n    //    this.orderBy = [] // Not used yet\n    this.name = name\n    this.id = id\n  }\n}\n\n/**\n * This function will match a pattern to the current Store\n *\n * The callback function is called whenever a match is found\n * When fetcher is supplied this will be called to load from the web\n * any new nodes as they are discovered.  This will cause the query to traverse the\n * graph of linked data, sometimes called \"Link Following Query\"\n *\n * @param myQuery - a knowledgebase containing a pattern to use as query\n * @param callback - whenever the pattern in myQuery is met this is called with\n *  the new bindings as parameter\n * @param fetcher? - If and only if,  you want link following, give a fetcher\n *                which has been created for the quadstore being queried.\n * @param onDone -  callback when query finished\n */\nexport function indexedFormulaQuery (myQuery, callback, fetcher, onDone) {\n  /** Debug strings\n  */\n  function bindingDebug (b) {\n    var str = ''\n    var v\n    for (v in b) {\n      if (b.hasOwnProperty(v)) {\n        str += '    ' + v + ' -> ' + b[v]\n      }\n    }\n    return str\n  }\n\n  function bindingsDebug (nbs) {\n    var str = 'Bindings: '\n    var i\n    var n = nbs.length\n    for (i = 0; i < n; i++) {\n      str += bindingDebug(nbs[i][0]) + ';\\n\\t'\n    }\n    return str\n  } // bindingsDebug\n\n  /** Unification\n   *\n   * Unification finds all bindings such that when the binding is applied\n   * to one term it is equal to the other.\n   * @returns {Arrray}-  a list of bindings, where a binding is an associative array\n   *  mapping variuable to value.\n   */\n  function unifyTerm (self, other, bindings, formula) {\n    var actual = bindings[self]\n    if (actual === undefined) { // Not mapped\n      if (self.isVar) {\n        var b = []\n        b[self] = other\n        return [[ b, null ]] // Match\n      }\n      actual = self\n    }\n    if (!actual.complexType) {\n      if (formula.redirections[actual]) {\n        actual = formula.redirections[actual]\n      }\n      if (formula.redirections[other]) {\n        other = formula.redirections[other]\n      }\n      if (actual.equals(other) || (actual.uri && actual.uri === defaultDocumentURI)) { // Used to mean 'any graph' in a query\n        return [[ [], null ]]\n      }\n      return []\n    }\n    if (self instanceof Array) {\n      if (!(other instanceof Array)) {\n        return []\n      }\n      return unifyContents(self, other, bindings)\n    }\n    throw new Error('query.js: oops - code not written yet')\n  // return undefined;  // for lint - no jslint objects to unreachables\n  //    return actual.unifyContents(other, bindings)\n  } // unifyTerm\n\n  function unifyContents (self, other, bindings, formula) {\n    var nbs2\n    if (self.length !== other.length) {\n      return [] // no way\n    }\n    if (!self.length) {\n      return [[ [], null ]] // Success\n    }\n    var nbs = unifyTerm(self[0], other[0], bindings, formula)\n    if (nbs.length === 0) {\n      return nbs\n    }\n    var res = []\n    var i\n    var n = nbs.length\n    var nb\n    var j\n    var m\n    var v\n    var nb2\n    var bindings2\n    for (i = 0; i < n; i++) { // for each possibility from the first term\n      nb = nbs[i][0] // new bindings\n      bindings2 = []\n      for (v in nb) {\n        if (nb.hasOwnProperty(v)) {\n          bindings2[v] = nb[v] // copy\n        }\n      }\n      for (v in bindings) {\n        if (bindings.hasOwnProperty(v)) {\n          bindings2[v] = bindings[v] // copy\n        }\n      }\n      nbs2 = unifyContents(self.slice(1), other.slice(1), bindings2, formula)\n      m = nbs2.length\n      for (j = 0; j < m; j++) {\n        nb2 = nbs2[j][0] // @@@@ no idea whether this is used or right\n        for (v in nb) {\n          if (nb.hasOwnProperty(v)) {\n            nb2[v] = nb[v]\n          }\n        }\n        res.push([nb2, null])\n      }\n    }\n    return res\n  } // unifyContents\n\n  //  Matching\n  //\n  // Matching finds all bindings such that when the binding is applied\n  // to one term it is equal to the other term.  We only match formulae.\n\n  /** if x is not in the bindings array, return the var; otherwise, return the bindings **/\n  function bind (x, binding) {\n    var y = binding[x]\n    if (y === undefined) {\n      return x\n    }\n    return y\n  }\n\n  // When there are OPTIONAL clauses, we must return bindings without them if none of them\n  // succeed. However, if any of them do succeed, we should not.  (This is what branchCount()\n  // tracked. The problem currently is (2011/7) that when several optionals exist, and they\n  // all match, multiple sets of bindings are returned, each with one optional filled in.)\n\n  function union (a, b) {\n    var c = {}\n    var x\n    for (x in a) {\n      if (a.hasOwnProperty(x)) {\n        c[x] = a[x]\n      }\n    }\n    for (x in b) {\n      if (b.hasOwnProperty(x)) {\n        c[x] = b[x]\n      }\n    }\n    return c\n  }\n\n  function OptionalBranchJunction (originalCallback, trunkBindings) {\n    this.trunkBindings = trunkBindings\n    this.originalCallback = originalCallback\n    this.branches = []\n    // this.results = []; // result[i] is an array of bindings for branch i\n    // this.done = {};  // done[i] means all/any results are in for branch i\n    // this.count = {}\n    return this\n  }\n\n  OptionalBranchJunction.prototype.checkAllDone = function () {\n    var i\n    for (i = 0; i < this.branches.length; i++) {\n      if (!this.branches[i].done) {\n        return\n      }\n    }\n    log.debug('OPTIONAL BIDNINGS ALL DONE:')\n    this.doCallBacks(this.branches.length - 1, this.trunkBindings)\n  }\n  // Recrursively generate the cross product of the bindings\n  OptionalBranchJunction.prototype.doCallBacks = function (b, bindings) {\n    var j\n    if (b < 0) {\n      return this.originalCallback(bindings)\n    }\n    for (j = 0; j < this.branches[b].results.length; j++) {\n      this.doCallBacks(b - 1, union(bindings, this.branches[b].results[j]))\n    }\n  }\n\n  // A mandatory branch is the normal one, where callbacks\n  // are made immediately and no junction is needed.\n  // Might be useful for onFinsihed callback for query API.\n  function MandatoryBranch (callback, onDone) {\n    this.count = 0\n    this.success = false\n    this.done = false\n    // this.results = []\n    this.callback = callback\n    this.onDone = onDone\n    // this.junction = junction\n    // junction.branches.push(this)\n    return this\n  }\n\n  MandatoryBranch.prototype.reportMatch = function (bindings) {\n    // log.error(\"@@@@ query.js 1\"); // @@\n    this.callback(bindings)\n    this.success = true\n  }\n\n  MandatoryBranch.prototype.reportDone = function () {\n    this.done = true\n    log.info('Mandatory query branch finished.***')\n    if (this.onDone !== undefined) {\n      this.onDone()\n    }\n  }\n\n  // An optional branch hoards its results.\n  var OptionalBranch = function (junction) {\n    this.count = 0\n    this.done = false\n    this.results = []\n    this.junction = junction\n    junction.branches.push(this)\n    return this\n  }\n\n  OptionalBranch.prototype.reportMatch = function (bindings) {\n    this.results.push(bindings)\n  }\n\n  OptionalBranch.prototype.reportDone = function () {\n    log.debug('Optional branch finished - results.length = ' + this.results.length)\n    if (this.results.length === 0) { // This is what optional means: if no hits,\n      this.results.push({}) // mimic success, but with no bindings\n      log.debug(\"Optional branch FAILED - that's OK.\")\n    }\n    this.done = true\n    this.junction.checkAllDone()\n  }\n\n  /** prepare -- sets the index of the item to the possible matches\n   * @param f - formula\n   * @param item - an Statement, possibly w/ vars in it\n   * @param bindings - Bindings so far\n   * @returns false if the query fails -- there are no items that match\n  */\n  function prepare (f, item, bindings) {\n    var terms, termIndex, i, ind\n    item.nvars = 0\n    item.index = null\n    // if (!f.statements) log.warn(\"@@@ prepare: f is \"+f)\n    //    log.debug(\"Prepare: f has \"+ f.statements.length)\n    // log.debug(\"Prepare: Kb size \"+f.statements.length+\" Preparing \"+item)\n\n    terms = [item.subject, item.predicate, item.object, item.why]\n    ind = [f.subjectIndex, f.predicateIndex, f.objectIndex, f.whyIndex]\n    for (i = 0; i < 4; i++) {\n      let t = terms[i]\n      // console.log(\"  Prepare (\" + t + \") \"+(t in bindings))\n      if (t.uri && t.uri === defaultDocumentURI) { // chrome:session\n        // console.log('     query: Ignoring slot ' + i)\n      } else if (t.isVar && !(bindings[t] !== undefined)) {\n        item.nvars++\n      } else {\n        t = bind(terms[i], bindings) // returns the RDF binding if bound, otherwise itself\n        // if (terms[i]!=bind(terms[i],bindings) alert(\"Term: \"+terms[i]+\"Binding: \"+bind(terms[i], bindings))\n        if (f.redirections[f.id(t)]) {\n          t = f.redirections[f.id(t)] // redirect\n        }\n        termIndex = ind[i][f.id(t)]\n\n        if (!termIndex) {\n          item.index = []\n          return false // Query line cannot match\n        }\n        if ((item.index === null) || (item.index.length > termIndex.length)) { // Find smallest index\n          item.index = termIndex\n        }\n      }\n    }\n\n    if (item.index === null) { // All 4 are variables?\n      item.index = f.statements\n    }\n    return true\n  } // prepare\n\n  /** sorting function -- negative if self is easier **/\n  // We always prefer to start with a URI to be able to browse a graph\n  // this is why we put off items with more variables till later.\n  function easiestQuery (self, other) {\n    if (self.nvars !== other.nvars) {\n      return self.nvars - other.nvars\n    }\n    return self.index.length - other.index.length\n  }\n\n  var matchIndex = 0 // index\n  /** matches a pattern formula against the knowledge base, e.g. to find matches for table-view\n  *\n  * @param f - knowledge base formula\n  * @param g - pattern formula (may have vars)\n  * @param bindingsSoFar  - bindings accumulated in matching to date\n  * @param level - spaces to indent stuff also lets you know what level of recursion you're at\n  * @param fetcher - function (term, requestedBy) If you want link following\n  * @param localCallback - function(bindings, pattern, branch) called on sucess\n  * @returns nothing\n  *\n  * Will fetch linked data from the web iff the knowledge base an associated source fetcher (f.fetcher)\n  ***/\n  var match = function (f, g, bindingsSoFar, level, fetcher, localCallback, branch) {\n    log.debug('Match begins, Branch count now: ' + branch.count + ' for ' + branch.pattern_debug)\n\n    // log.debug(\"match: f has \"+f.statements.length+\", g has \"+g.statements.length)\n    var pattern = g.statements\n    if (pattern.length === 0) { // when it's satisfied all the pattern triples\n      log.debug('FOUND MATCH WITH BINDINGS:' + bindingDebug(bindingsSoFar))\n      if (g.optional.length === 0) {\n        branch.reportMatch(bindingsSoFar)\n      } else {\n        log.debug('OPTIONAL: ' + g.optional)\n        var junction = new OptionalBranchJunction(callback, bindingsSoFar) // @@ won't work with nested optionals? nest callbacks\n        var br = []\n        var b\n        for (b = 0; b < g.optional.length; b++) {\n          br[b] = new OptionalBranch(junction) // Allocate branches to prevent premature ending\n          br[b].pattern_debug = g.optional[b] // for diagnotics only\n        }\n        for (b = 0; b < g.optional.length; b++) {\n          br[b].count = br[b].count + 1 // Count how many matches we have yet to complete\n          match(f, g.optional[b], bindingsSoFar, '', fetcher, callback, br[b])\n        }\n      }\n      branch.count--\n      log.debug('Match ends -- success , Branch count now: ' + branch.count + ' for ' + branch.pattern_debug)\n      return // Success\n    }\n\n    var item\n    var i\n    var n = pattern.length\n    // log.debug(level + \"Match \"+n+\" left, bs so far:\"+bindingDebug(bindingsSoFar))\n\n    // Follow links from variables in query\n    if (fetcher) { // Fetcher is used to fetch URIs, function first term is a URI term, second is the requester\n      var id = 'match' + matchIndex++\n      var fetchResource = function (requestedTerm, id) {\n        var docuri = requestedTerm.uri.split('#')[0]\n        fetcher.nowOrWhenFetched(docuri, undefined, function (ok, body, xhr) {\n          if (!ok) {\n            console.log('Error following link to <' + requestedTerm.uri + '> in query: ' + body)\n          }\n          match(f, g, bindingsSoFar, level, fetcher, // match not match2 to look up any others necessary.\n            localCallback, branch)\n        })\n      }\n      for (i = 0; i < n; i++) {\n        item = pattern[i] // for each of the triples in the query\n        if (bindingsSoFar[item.subject] !== undefined &&\n            bindingsSoFar[item.subject].uri && fetcher &&\n            fetcher.getState(docpart(bindingsSoFar[item.subject].uri)) === 'unrequested') {\n          // fetch the subject info and return to id\n          fetchResource(bindingsSoFar[item.subject], id)\n          return // only look up one per line this time, but we will come back again though match\n        }\n        if (bindingsSoFar[item.object] !== undefined &&\n            bindingsSoFar[item.object].uri && fetcher &&\n            fetcher.getState(docpart(bindingsSoFar[item.object].uri)) === 'unrequested') {\n          fetchResource(bindingsSoFar[item.object], id)\n          return\n        }\n      }\n    } // if fetcher\n    match2(f, g, bindingsSoFar, level, fetcher, localCallback, branch)\n  } // match\n\n  var constraintsSatisfied = function (bindings, constraints) {\n    var res = true\n    var x\n    var test\n    for (x in bindings) {\n      if (bindings.hasOwnProperty(x)) {\n        if (constraints[x]) {\n          test = constraints[x].test\n          if (test && !test(bindings[x])) {\n            res = false\n          }\n        }\n      }\n    }\n    return res\n  }\n\n  /** match2 -- stuff after the fetch **/\n  var match2 = function (f, g, bindingsSoFar, level, fetcher, callback, branch) { // post fetch\n    var pattern = g.statements\n    var n = pattern.length\n    var i\n    var k\n    var nk\n    var v\n    var bindings2\n    var newBindings1\n    var item\n    for (i = 0; i < n; i++) { // For each statement left in the query, run prepare\n      item = pattern[i]\n      // log.info('match2: item=' + item + ', bindingsSoFar=' + bindingDebug(bindingsSoFar))\n      prepare(f, item, bindingsSoFar)\n      // if (item.index) console.log('     item.index.length ' + item.index.length)\n    }\n    pattern.sort(easiestQuery)\n    item = pattern[0]\n    // log.debug(\"Sorted pattern:\\n\"+pattern)\n    var rest = f.formula()\n    rest.optional = g.optional\n    rest.constraints = g.constraints\n    rest.statements = pattern.slice(1) // No indexes: we will not query g.\n    log.debug(level + 'match2 searching ' + item.index.length + ' for ' + item +\n      '; bindings so far=' + bindingDebug(bindingsSoFar))\n    // var results = []\n    var c\n    var nc = item.index.length\n    var nbs1\n    var st\n    var onward = 0\n    // var x\n    for (c = 0; c < nc; c++) { // For each candidate statement\n      st = item.index[c] // for each statement in the item's index, spawn a new match with that binding\n      nbs1 = unifyContents(\n        [item.subject, item.predicate, item.object, item.why],\n        [st.subject, st.predicate, st.object, st.why], bindingsSoFar, f)\n      log.info(level + ' From first: ' + nbs1.length + ': ' + bindingsDebug(nbs1))\n      nk = nbs1.length\n      // branch.count += nk\n      // log.debug(\"Branch count bumped \"+nk+\" to: \"+branch.count)\n      for (k = 0; k < nk; k++) { // For each way that statement binds\n        bindings2 = []\n        newBindings1 = nbs1[k][0]\n        if (!constraintsSatisfied(newBindings1, g.constraints)) {\n          // branch.count--\n          log.debug('Branch count CS: ' + branch.count)\n        } else {\n          for (v in newBindings1) {\n            if (newBindings1.hasOwnProperty(v)) {\n              bindings2[v] = newBindings1[v] // copy\n            }\n          }\n          for (v in bindingsSoFar) {\n            if (bindingsSoFar.hasOwnProperty(v)) {\n              bindings2[v] = bindingsSoFar[v] // copy\n            }\n          }\n\n          branch.count++ // Count how many matches we have yet to complete\n          onward++\n          match(f, rest, bindings2, level + '  ', fetcher, callback, branch) // call match\n        }\n      }\n    }\n    branch.count--\n    if (onward === 0) {\n      log.debug('Match2 fails completely on ' + item)\n    }\n    log.debug('Match2 ends, Branch count: ' + branch.count + ' for ' + branch.pattern_debug)\n    if (branch.count === 0) {\n      log.debug('Branch finished.')\n      branch.reportDone()\n    }\n  } // match2\n  // ////////////////////////// Body of query()  ///////////////////////\n  var f = this\n  log.debug('Query on ' + this.statements.length)\n  var trunck = new MandatoryBranch(callback, onDone)\n  trunck.count++ // count one branch to complete at the moment\n  if (myQuery.sync) {\n    match(f, myQuery.pat, myQuery.pat.initBindings, '', fetcher, callback, trunck)\n  } else { // Give up thread: Allow other activities to run\n    setTimeout(function () {\n      match(f, myQuery.pat, myQuery.pat.initBindings, '', fetcher, callback, trunck)\n    }, 0)\n  }\n\n   // returns nothing; callback does the work\n} // query\n","/*  Identity management and indexing for RDF\n *\n * This file provides  IndexedFormula a formula (set of triples) which\n * indexed by predicate, subject and object.\n *\n * It \"smushes\"  (merges into a single node) things which are identical\n * according to owl:sameAs or an owl:InverseFunctionalProperty\n * or an owl:FunctionalProperty\n *\n *\n *  2005-10 Written Tim Berners-Lee\n *  2007    Changed so as not to munge statements from documents when smushing\n *  2019    Converted to typescript\n *\n *\n*/\n\n/** @module store */\n\nimport ClassOrder from './class-order'\nimport { defaultGraphURI } from './factories/canonical-data-factory'\nimport Formula, { FormulaOpts } from './formula'\nimport { ArrayIndexOf } from './utils'\nimport { RDFArrayRemove } from './utils-js'\nimport {\n  isRDFlibSubject,\n  isRDFlibPredicate,\n  isRDFlibObject,\n  isStore,\n  isGraph,\n  // isPredicate,\n  isQuad,\n  // isSubject\n} from './utils/terms'\nimport Node from './node'\nimport Variable from './variable'\nimport { Query, indexedFormulaQuery } from './query'\nimport UpdateManager from './update-manager'\nimport {\n  Bindings, BlankNodeTermType, CollectionTermType, DefaultGraphTermType, EmptyTermType, GraphTermType, LiteralTermType, NamedNodeTermType, VariableTermType\n} from './types'\nimport Statement from './statement'\nimport { Indexable } from './factories/factory-types'\nimport NamedNode from './named-node'\nimport Fetcher from './fetcher'\nimport {\n  Quad_Graph,\n  Literal as TFLiteral,\n  NamedNode as TFNamedNode,\n  Quad_Object,\n  Quad_Predicate,\n  Quad,\n  Quad_Subject,\n  Term,\n} from './tf-types'\nimport { namedNode } from './index'\nimport serialize from \"./serialize\";\nimport BlankNode from './blank-node'\nimport DefaultGraph from './default-graph'\nimport Empty from './empty'\nimport Literal from './literal'\nimport Collection from './collection'\n\nconst owlNamespaceURI = 'http://www.w3.org/2002/07/owl#'\n\ntype FeaturesType = Array<('sameAs' | 'InverseFunctionalProperty' | 'FunctionalProperty')> | undefined\n\nexport { defaultGraphURI }\n// var link_ns = 'http://www.w3.org/2007/ont/link#'\n\n// Handle Functional Property\nfunction handleFP (\n  formula: IndexedFormula,\n  subj: Quad_Subject,\n  pred: Quad_Predicate,\n  obj: Quad_Object\n): boolean {\n  var o1 = formula.any(subj, pred, undefined)\n  if (!o1) {\n    return false // First time with this value\n  }\n  // log.warn(\"Equating \"+o1.uri+\" and \"+obj.uri + \" because FP \"+pred.uri);  //@@\n  formula.equate(o1, obj)\n  return true\n} // handleFP\n\n// Handle Inverse Functional Property\nfunction handleIFP (\n  formula: IndexedFormula,\n  subj: Quad_Subject,\n  pred: Quad_Predicate,\n  obj: Quad_Object\n): boolean {\n  var s1 = formula.any(undefined, pred, obj)\n  if (!s1) {\n    return false // First time with this value\n  }\n  // log.warn(\"Equating \"+s1.uri+\" and \"+subj.uri + \" because IFP \"+pred.uri);  //@@\n  formula.equate(s1, subj)\n  return true\n} // handleIFP\n\nfunction handleRDFType (\n  formula: IndexedFormula,\n  subj: Quad_Subject,\n  pred: Quad_Predicate,\n  obj: Quad_Object,\n  why: Quad_Graph\n) {\n  //@ts-ignore this method does not seem to exist in this library\n  if (formula.typeCallback) {\n    (formula as any).typeCallback(formula, obj, why)\n  }\n\n  var x = formula.classActions[formula.id(obj)]\n  var done = false\n  if (x) {\n    for (var i = 0; i < x.length; i++) {\n      done = done || x[i](formula, subj, pred, obj, why)\n    }\n  }\n  return done // statement given is not needed if true\n}\n\n/**\n * Indexed Formula aka Store\n */\nexport default class IndexedFormula extends Formula { // IN future - allow pass array of statements to constructor\n  /**\n   * An UpdateManager initialised to this store\n   */\n  updater?: UpdateManager\n\n  /**\n   * Dictionary of namespace prefixes\n   */\n  namespaces: {[key: string]: string}\n\n  /** Map of iri predicates to functions to call when adding { s type X } */\n  classActions: { [k: string]: Function[] }\n  /** Map of iri predicates to functions to call when getting statement with {s X o} */\n  propertyActions: { [k: string]: Function[] }\n  /** Redirect to lexically smaller equivalent symbol */\n  redirections: any[]\n  /** Reverse mapping to redirection: aliases for this */\n  aliases: any[]\n  /** Redirections we got from HTTP */\n  HTTPRedirects: Statement[]\n  /** Array of statements with this X as subject */\n  subjectIndex: Statement[]\n  /** Array of statements with this X as predicate */\n  predicateIndex: Statement[]\n  /** Array of statements with this X as object */\n  objectIndex: Statement[]\n  /** Array of statements with X as provenance */\n  whyIndex: Statement[]\n  index: [\n    Statement[],\n    Statement[],\n    Statement[],\n    Statement[]\n  ]\n  features: FeaturesType\n  static handleRDFType: Function\n  _universalVariables?: NamedNode[]\n  _existentialVariables?: BlankNode[]\n\n  /** Function to remove quads from the store arrays with */\n  private rdfArrayRemove: (arr: Quad[], q: Quad) => void\n  /** Callbacks which are triggered after a statement has been added to the store */\n  private dataCallbacks?: Array<(q: Quad) => void>\n\n  /**\n   * Creates a new formula\n   * @param features - What sort of automatic processing to do? Array of string\n   * @param features.sameAs - Smush together A and B nodes whenever { A sameAs B }\n   * @param opts\n   * @param [opts.rdfFactory] - The data factory that should be used by the store\n   * @param [opts.rdfArrayRemove] - Function which removes statements from the store\n   * @param [opts.dataCallback] - Callback when a statement is added to the store, will not trigger when adding duplicates\n   */\n  constructor (features?: FeaturesType, opts: FormulaOpts = {}) {\n    super(undefined, undefined, undefined, undefined, opts)\n\n    this.propertyActions = {}\n    this.classActions = {}\n    this.redirections = []\n    this.aliases = []\n    this.HTTPRedirects = []\n    this.subjectIndex = []\n    this.predicateIndex = []\n    this.objectIndex = []\n    this.whyIndex = []\n    this.index = [\n      this.subjectIndex,\n      this.predicateIndex,\n      this.objectIndex,\n      this.whyIndex\n    ]\n    this.namespaces = {} // Dictionary of namespace prefixes\n    this.features = features || [ // By default, devs do not expect these features.\n// See https://github.com/linkeddata/rdflib.js/issues/458\n//      'sameAs',\n//      'InverseFunctionalProperty',\n//      'FunctionalProperty',\n    ]\n    this.rdfArrayRemove = opts.rdfArrayRemove || RDFArrayRemove\n    if (opts.dataCallback) {\n      this.dataCallbacks = [opts.dataCallback]\n    }\n\n    this.initPropertyActions(this.features)\n  }\n\n  /**\n   * Gets the URI of the default graph\n   */\n  static get defaultGraphURI(): string {\n    return defaultGraphURI\n  }\n\n  /**\n   * Gets this graph with the bindings substituted\n   * @param bindings The bindings\n   */\n  substitute <T extends Node = IndexedFormula>(bindings: Bindings): T {\n    var statementsCopy = this.statements.map(function (ea: Quad) {\n      return (ea as Statement).substitute(bindings)\n    })\n    var y = new IndexedFormula()\n    y.add(statementsCopy)\n    return y as unknown as T\n  }\n\n  /**\n   * Add a callback which will be triggered after a statement has been added to the store.\n   * @param cb\n   */\n  addDataCallback(cb: (q: Quad) => void): void {\n    if (!this.dataCallbacks) {\n      this.dataCallbacks = []\n    }\n    this.dataCallbacks.push(cb)\n  }\n\n  /**\n   * Apply a set of statements to be deleted and to be inserted\n   *\n   * @param patch - The set of statements to be deleted and to be inserted\n   * @param target - The name of the document to patch\n   * @param patchCallback - Callback to be called when patching is complete\n   */\n  applyPatch(\n    patch: {\n        delete?: ReadonlyArray<Statement>,\n        patch?: ReadonlyArray<Statement>,\n        where?: any\n    },\n    target: TFNamedNode,\n    patchCallback: (errorString?: string) => void\n  ): void {\n    var targetKB = this\n    var ds\n    var binding: Bindings | null = null\n\n    function doPatch (onDonePatch: (errorString?: string) => void) {\n      if (patch['delete']) {\n        ds = patch['delete']\n        // console.log(bindingDebug(binding))\n        // console.log('ds before substitute: ' + ds)\n        if (binding) ds = ds.substitute(binding)\n        // console.log('applyPatch: delete: ' + ds)\n        ds = ds.statements as Statement[]\n        var bad: Quad[] = []\n        var ds2 = ds.map(function (st: Quad) { // Find the actual statements in the store\n          var sts = targetKB.statementsMatching(st.subject, st.predicate, st.object, target)\n          if (sts.length === 0) {\n            // log.info(\"NOT FOUND deletable \" + st)\n            bad.push(st)\n            return null\n          } else {\n            // log.info(\"Found deletable \" + st)\n            return sts[0]\n          }\n        })\n        if (bad.length) {\n          // console.log('Could not find to delete ' + bad.length + 'statements')\n          // console.log('despite ' + targetKB.statementsMatching(bad[0].subject, bad[0].predicate)[0])\n          return patchCallback('Could not find to delete: ' + bad.join('\\n or '))\n        }\n        ds2.map(function (st: Quad) {\n          targetKB.remove(st)\n        })\n      }\n      if (patch['insert']) {\n        // log.info(\"doPatch insert \"+patch['insert'])\n        ds = patch['insert']\n        if (binding) ds = ds.substitute(binding)\n        ds = ds.statements\n        ds.map(function (st: Quad) {\n          st.graph = target\n          targetKB.add(st.subject, st.predicate, st.object, st.graph)\n        })\n      }\n      onDonePatch()\n    }\n    if (patch.where) {\n      // log.info(\"Processing WHERE: \" + patch.where + '\\n')\n      var query = new Query('patch')\n      query.pat = patch.where\n      query.pat.statements.map(function (st) {\n        st.graph = namedNode(target.value)\n      })\n      //@ts-ignore TODO: add sync property to Query when converting Query to typescript\n      query.sync = true\n\n      var bindingsFound: Bindings[] = []\n\n      targetKB.query(\n        query,\n        function onBinding (binding) {\n        bindingsFound.push(binding)\n        // console.log('   got a binding: ' + bindingDebug(binding))\n      },\n        targetKB.fetcher,\n        function onDone () {\n          if (bindingsFound.length === 0) {\n            return patchCallback('No match found to be patched:' + patch.where)\n          }\n          if (bindingsFound.length > 1) {\n            return patchCallback('Patch ambiguous. No patch done.')\n          }\n          binding = bindingsFound[0]\n          doPatch(patchCallback)\n        })\n    } else {\n      doPatch(patchCallback)\n    }\n  }\n\n  /**\n   * N3 allows for declaring blank nodes, this function enables that support\n   *\n   * @param x The blank node to be declared, supported in N3\n   */\n  declareExistential(x: BlankNode): BlankNode {\n    if (!this._existentialVariables) this._existentialVariables = []\n    this._existentialVariables.push(x)\n    return x\n  }\n\n  /**\n   * @param features\n   */\n  initPropertyActions(features: FeaturesType) {\n    // If the predicate is #type, use handleRDFType to create a typeCallback on the object\n    this.propertyActions[this.rdfFactory.id(this.rdfFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'))] =\n      [ handleRDFType ]\n\n    // Assumption: these terms are not redirected @@fixme\n    if (ArrayIndexOf(features, 'sameAs') >= 0) {\n      this.propertyActions[this.rdfFactory.id(this.rdfFactory.namedNode(`${owlNamespaceURI}sameAs`))] = [\n        function (formula, subj, pred, obj, why) {\n          // log.warn(\"Equating \"+subj.uri+\" sameAs \"+obj.uri);  //@@\n          formula.equate(subj, obj)\n          return true // true if statement given is NOT needed in the store\n        }\n      ] // sameAs -> equate & don't add to index\n    }\n    if (ArrayIndexOf(features, 'InverseFunctionalProperty') >= 0) {\n      this.classActions[this.rdfFactory.id(this.rdfFactory.namedNode(`${owlNamespaceURI}InverseFunctionalProperty`))] = [\n        function (formula, subj, pred, obj, addFn) {\n          // yes subj not pred!\n          return formula.newPropertyAction(subj, handleIFP)\n        }\n      ] // IFP -> handleIFP, do add to index\n    }\n    if (ArrayIndexOf(features, 'FunctionalProperty') >= 0) {\n      this.classActions[this.rdfFactory.id(this.rdfFactory.namedNode(`${owlNamespaceURI}FunctionalProperty`))] = [\n        function (formula, subj, proj, obj, addFn) {\n          return formula.newPropertyAction(subj, handleFP)\n        }\n      ] // FP => handleFP, do add to index\n    }\n  }\n\n  /** @deprecated Use {add} instead */\n  addStatement (st: Quad): number {\n    this.add(st.subject, st.predicate, st.object, st.graph)\n    return this.statements.length\n  }\n\n  /**\n   * Adds a triple (quad) to the store.\n   *\n   * @param subj - The thing about which the fact a relationship is asserted.\n   *        Also accepts a statement or an array of Statements.\n   * @param pred - The relationship which is asserted\n   * @param obj - The object of the relationship, e.g. another thing or a value. If passed a string, this will become a literal.\n   * @param why - The document in which the triple (S,P,O) was or will be stored on the web\n   * @returns The statement added to the store, or the store\n   */\n  add (\n    subj: Quad_Subject | Quad | Quad[] | Statement | Statement[],\n    pred?: Quad_Predicate,\n    obj?: Term | string,\n    why?: Quad_Graph\n  ): Statement | null | this | number {\n    var i: number\n    if (arguments.length === 1) {\n      if (subj instanceof Array) {\n        for (i = 0; i < subj.length; i++) {\n          this.add(subj[i])\n        }\n      } else if (isQuad(subj)) {\n        this.add(subj.subject, subj.predicate, subj.object, subj.graph)\n      } else if (isStore(subj)) {\n        this.add((subj as any).statements)\n      }\n      return this\n    }\n    var actions: Function[]\n    var st: Statement\n    if (!why) {\n      // system generated\n      why = this.fetcher ? this.fetcher.appNode : this.rdfFactory.defaultGraph()\n    }\n    if (typeof subj == 'string') {\n      subj = this.rdfFactory.namedNode(subj)\n    }\n    pred = Node.fromValue(pred)\n    const objNode = Node.fromValue(obj) as Term\n    why = Node.fromValue(why)\n    if (!isRDFlibSubject(subj)) {\n      throw new Error('Subject is not a subject type')\n    }\n    if (!isRDFlibPredicate(pred)) {\n      throw new Error(`Predicate ${pred} is not a predicate type`)\n    }\n    if (!isRDFlibObject(objNode)) {\n      throw new Error(`Object ${objNode} is not an object type`)\n    }\n    if (!isGraph(why)) {\n      throw new Error(\"Why is not a graph type\")\n    }\n    //@ts-ignore This is not used internally\n    if (this.predicateCallback) {\n      //@ts-ignore This is not used internally\n      this.predicateCallback(this, pred, why)\n    }\n    // Action return true if the statement does not need to be added\n    var predHash = this.id(this.canon(pred!))\n    actions = this.propertyActions[predHash] // Predicate hash\n    var done = false\n    if (actions) {\n      // alert('type: '+typeof actions +' @@ actions='+actions)\n      for (i = 0; i < actions.length; i++) {\n        done = done || actions[i](this, subj, pred, objNode, why)\n      }\n    }\n    if (this.holds(subj, pred, objNode, why)) { // Takes time but saves duplicates\n      // console.log('rdflib: Ignoring dup! {' + subj + ' ' + pred + ' ' + obj + ' ' + why + '}')\n      return null // @@better to return self in all cases?\n    }\n    // If we are tracking provenance, every thing should be loaded into the store\n    // if (done) return this.rdfFactory.quad(subj, pred, obj, why)\n    // Don't put it in the store\n    // still return this statement for owl:sameAs input\n    var hash = [\n      this.id(this.canon(subj)),\n      predHash,\n      this.id(this.canon(objNode)),\n      this.id(this.canon(why))\n    ]\n    // @ts-ignore this will fail if you pass a collection and the factory does not allow Collections\n    st = this.rdfFactory.quad(subj, pred, objNode, why)\n    for (i = 0; i < 4; i++) {\n      var ix = this.index[i]\n      var h = hash[i]\n      if (!ix[h]) {\n        ix[h] = []\n      }\n      ix[h].push(st) // Set of things with this as subject, etc\n    }\n\n    // log.debug(\"ADDING    {\"+subj+\" \"+pred+\" \"+objNode+\"} \"+why)\n    this.statements.push(st)\n\n    if (this.dataCallbacks) {\n      for (const callback of this.dataCallbacks) {\n        callback(st)\n      }\n    }\n\n    return st\n  }\n\n  /**\n   * Returns the symbol with canonical URI as smushed\n   * @param term - An RDF node\n   */\n  canon(term?: Term): Node {\n    if (!term) {\n      // @@ TODO Should improve this to return proper value - doing this to keep it backward compatible\n      return term as unknown as Node\n    }\n    const y = this.redirections[this.id(term)]\n    if (y) {\n      return y\n    }\n    switch (term.termType) {\n      case BlankNodeTermType:\n        return new BlankNode(term.value)\n      case CollectionTermType:\n        return term as Collection // non-RDF/JS type, should just need to cast\n      case DefaultGraphTermType:\n        return new DefaultGraph()\n      case EmptyTermType: // non-RDF/JS type, should just need to cast\n        return term as Empty\n      case GraphTermType: // non-RDF/JS type, should just need to cast\n        return term as IndexedFormula\n      case LiteralTermType:\n        return new Literal(term.value, (term as TFLiteral).language, (term as TFLiteral).datatype)\n      case NamedNodeTermType:\n        return new NamedNode(term.value)\n      case VariableTermType:\n        return new Variable(term.value)\n      default:\n        throw new Error(`Term Type not recognized for canonization: ${term.termType}`)\n    }\n  }\n\n\n  /**\n   * Checks this formula for consistency\n   */\n  check(): void {\n    this.checkStatementList(this.statements)\n    for (var p = 0; p < 4; p++) {\n      var ix = this.index[p]\n      for (var key in ix) {\n        if (ix.hasOwnProperty(key)) {\n          // @ts-ignore should this pass an array or a single statement? checkStateMentsList expects an array.\n          this.checkStatementList(ix[key], p)\n        }\n      }\n    }\n  }\n\n  /**\n   * Checks a list of statements for consistency\n   * @param sts - The list of statements to check\n   * @param from - An index with the array ['subject', 'predicate', 'object', 'why']\n   */\n  checkStatementList(\n    sts: ReadonlyArray<Quad>,\n    from?: number\n  ): boolean | void {\n    if (from === undefined) {\n      from = 0\n    }\n    var names = ['subject', 'predicate', 'object', 'why']\n    var origin = ' found in ' + names[from] + ' index.'\n    var st: Quad\n    for (var j = 0; j < sts.length; j++) {\n      st = sts[j]\n      var term = [ st.subject, st.predicate, st.object, st.graph ]\n      var arrayContains = function (a: Array<any>, x: Quad) {\n        for (var i = 0; i < a.length; i++) {\n          if (a[i].subject.equals(x.subject) &&\n            a[i].predicate.equals(x.predicate) &&\n            a[i].object.equals(x.object) &&\n            a[i].why.equals(x.graph)) {\n            return true\n          }\n        }\n      }\n      for (var p = 0; p < 4; p++) {\n        var c = this.canon(term[p])\n        var h = this.id(c)\n        if (!this.index[p][h]) {\n          // throw new Error('No ' + name[p] + ' index for statement ' + st + '@' + st.why + origin)\n        } else {\n          if (!arrayContains(this.index[p][h], st)) {\n            // throw new Error('Index for ' + name[p] + ' does not have statement ' + st + '@' + st.why + origin)\n          }\n        }\n      }\n      if (!arrayContains(this.statements, st)) {\n        throw new Error('Statement list does not statement ' + st + '@' + st.graph + origin)\n      }\n    }\n  }\n\n  /**\n   * Closes this formula (and return it)\n   */\n  close(): IndexedFormula {\n    return this\n  }\n\n  compareTerms(u1: Term, u2: Term): number {\n    // Keep compatibility with downstream classOrder changes\n    if (Object.prototype.hasOwnProperty.call(u1, \"compareTerm\")) {\n      return (u1 as Node).compareTerm(u2 as Node)\n    }\n    if (ClassOrder[u1.termType] < ClassOrder[u2.termType]) {\n      return -1\n    }\n    if (ClassOrder[u1.termType] > ClassOrder[u2.termType]) {\n      return +1\n    }\n    if (u1.value < u2.value) {\n      return -1\n    }\n    if (u1.value > u2.value) {\n      return +1\n    }\n    return 0\n  }\n\n\n  /**\n   * replaces @template with @target and add appropriate triples\n   * removes no triples by default and is a one-direction replication\n   * @param template node to copy\n   * @param target node to copy to\n   * @param flags Whether or not to do a two-directional copy and/or delete triples\n   */\n  copyTo(\n    template: Quad_Subject,\n    target: Quad_Subject,\n    flags?: Array<('two-direction' | 'delete')>\n  ): void {\n    if (!flags) flags = []\n    var statList = this.statementsMatching(template)\n    if (ArrayIndexOf(flags, 'two-direction') !== -1) {\n      statList.concat(this.statementsMatching(undefined, undefined, template))\n    }\n    for (var i = 0; i < statList.length; i++) {\n      var st = statList[i]\n      switch (st.object.termType) {\n        case 'NamedNode':\n          this.add(target, st.predicate, st.object)\n          break\n        case 'Literal':\n        case 'BlankNode':\n        // @ts-ignore Collections can appear here\n        case 'Collection':\n          // @ts-ignore Possible bug: copy is not available on Collections\n          this.add(target, st.predicate, st.object.copy(this))\n      }\n      if (ArrayIndexOf(flags, 'delete') !== -1) {\n        this.remove(st)\n      }\n    }\n  }\n\n  /**\n   * Simplify graph in store when we realize two identifiers are equivalent\n   * We replace the bigger with the smaller.\n   * @param u1in The first node\n   * @param u2in The second node\n   */\n  equate(u1in: Term, u2in : Term): boolean {\n    // log.warn(\"Equating \"+u1+\" and \"+u2); // @@\n    // @@JAMBO Must canonicalize the uris to prevent errors from a=b=c\n    // 03-21-2010\n    const u1 = this.canon(u1in) as Quad_Subject\n    const u2 = this.canon(u2in) as Quad_Subject\n    var d = this.compareTerms(u1, u2)\n    if (!d) {\n      return true // No information in {a = a}\n    }\n    // var big\n    // var small\n    if (d < 0) { // u1 less than u2\n      return this.replaceWith(u2, u1)\n    } else {\n      return this.replaceWith(u1, u2)\n    }\n  }\n\n  /**\n   * Creates a new empty indexed formula\n   * Only applicable for IndexedFormula, but TypeScript won't allow a subclass to override a property\n   * @param features The list of features\n   */\n  formula(features: FeaturesType): IndexedFormula {\n    return new IndexedFormula(features)\n  }\n\n  /**\n   * Returns the number of statements contained in this IndexedFormula.\n   * (Getter proxy to this.statements).\n   * Usage:\n   *    ```\n   *    var kb = rdf.graph()\n   *    kb.length  // -> 0\n   *    ```\n   * @returns {Number}\n   */\n  get length (): number {\n    return this.statements.length\n  }\n\n  /**\n   * Returns any quads matching the given arguments.\n   * Standard RDFJS spec method for Source objects, implemented as an\n   * alias to `statementsMatching()`\n   * @param subject The subject\n   * @param predicate The predicate\n   * @param object The object\n   * @param graph The graph that contains the statement\n   */\n  match(\n    subject?: Quad_Subject | null,\n    predicate?: Quad_Predicate | null,\n    object?: Quad_Object | null,\n    graph?: Quad_Graph | null\n  ): Quad[] {\n    return this.statementsMatching(\n      Node.fromValue(subject),\n      Node.fromValue(predicate),\n      Node.fromValue(object),\n      Node.fromValue(graph)\n    )\n  }\n\n  /**\n   * Find out whether a given URI is used as symbol in the formula\n   * @param uri The URI to look for\n   */\n  mentionsURI(uri: string): boolean {\n    var hash = '<' + uri + '>'\n    return (!!this.subjectIndex[hash] ||\n    !!this.objectIndex[hash] ||\n    !!this.predicateIndex[hash])\n  }\n\n  /**\n   * Existentials are BNodes - something exists without naming\n   * @param uri An URI\n   */\n  newExistential(uri: string): Term {\n    if (!uri) return this.bnode()\n    var x = this.sym(uri)\n    // @ts-ignore x should be blanknode, but is namedNode.\n    return this.declareExistential(x)\n  }\n\n  /**\n   * Adds a new property action\n   * @param pred the predicate that the function should be triggered on\n   * @param action the function that should trigger\n   */\n  newPropertyAction(\n    pred: Quad_Predicate,\n    action: (\n      store: IndexedFormula,\n      subject: Quad_Subject,\n      predicate: Quad_Predicate,\n      object: Quad_Object\n    ) => boolean\n  ): boolean {\n    // log.debug(\"newPropertyAction:  \"+pred)\n    var hash = this.id(pred)\n    if (!this.propertyActions[hash]) {\n      this.propertyActions[hash] = []\n    }\n    this.propertyActions[hash].push(action)\n    // Now apply the function to to statements already in the store\n    var toBeFixed = this.statementsMatching(undefined, pred, undefined)\n    var done = false\n    for (var i = 0; i < toBeFixed.length; i++) { // NOT optimized - sort toBeFixed etc\n      done = done || action(this, toBeFixed[i].subject, pred, toBeFixed[i].object)\n    }\n    return done\n  }\n\n  /**\n   * Creates a new universal node\n   * Universals are Variables\n   * @param uri An URI\n   */\n  newUniversal(uri: string): TFNamedNode {\n    var x = this.sym(uri)\n    if (!this._universalVariables) this._universalVariables = []\n    this._universalVariables.push(x)\n    return x\n  }\n\n  // convenience function used by N3 parser\n  variable (name: string) {\n    return new Variable(name)\n  }\n\n  /**\n   * Find an unused id for a file being edited: return a symbol\n   * (Note: Slow iff a lot of them -- could be O(log(k)) )\n   * @param doc A document named node\n   */\n  nextSymbol(doc: TFNamedNode): TFNamedNode {\n    for (var i = 0; ;i++) {\n      var uri = doc.value + '#n' + i\n      if (!this.mentionsURI(uri)) return this.sym(uri)\n    }\n  }\n\n  /**\n   * Query this store asynchronously, return bindings in callback\n   *\n   * @param myQuery The query to be run\n   * @param callback Function to call when bindings\n   * @param Fetcher | null  If you want the query to do link following\n   * @param onDone OBSOLETE - do not use this // @@ Why not ?? Called when query complete\n   */\n  query(\n    myQuery: Query,\n    callback: (bindings: Bindings) => void,\n    fetcher?: Fetcher | null,\n    onDone?: () => void\n  ): void {\n    return indexedFormulaQuery.call(this, myQuery, callback, fetcher, onDone)\n  }\n\n  /**\n   * Query this store synchronously and return bindings\n   *\n   * @param myQuery The query to be run\n   */\n  querySync(myQuery: Query): any[] {\n    var results: Bindings[] = []\n    function saveBinginds (bindings: Bindings) {\n      results.push(bindings)\n    }\n    function onDone () {\n      done = true\n    }\n    var done = false\n    // @ts-ignore TODO: Add .sync to Query\n    myQuery.sync = true\n\n    indexedFormulaQuery.call(this, myQuery, saveBinginds, null, onDone)\n    if (!done) {\n      throw new Error('Sync query should have called done function')\n    }\n    return results\n  }\n\n  /**\n   * Removes one or multiple statement(s) from this formula\n   * @param st - A Statement or array of Statements to remove\n   */\n  remove(st: Quad | Quad[]): IndexedFormula {\n    if (st instanceof Array) {\n      for (var i = 0; i < st.length; i++) {\n        this.remove(st[i])\n      }\n      return this\n    }\n    if (isStore(st)) {\n      return this.remove(st.statements)\n    }\n    var sts = this.statementsMatching(st.subject, st.predicate, st.object, st.graph)\n    if (!sts.length) {\n      throw new Error('Statement to be removed is not on store: ' + st)\n    }\n    this.removeStatement(sts[0])\n    return this\n  }\n\n  /**\n   * Removes all statements in a doc, along with the related metadata including request/response/status\n   * @param doc - The document / graph\n   */\n  removeDocument(doc: Quad_Graph): IndexedFormula {\n    this.removeMetadata(doc)\n    // remove document\n    var sts: Quad[] = this.statementsMatching(undefined, undefined, undefined, doc).slice() // Take a copy as this is the actual index\n    for (var i = 0; i < sts.length; i++) {\n      this.removeStatement(sts[i])\n    }\n    this.removeMatches(doc as Quad_Subject, null, null)\n    return this\n  }\n\n  removeMetadata(doc: Quad_Graph): IndexedFormula {\n    const meta = this.sym('chrome://TheCurrentSession') // or this.rdfFactory.namedNode('chrome://TheCurrentSession')\n    const linkNamespaceURI = 'http://www.w3.org/2007/ont/link#'\n    // remove status/response/request metadata\n    const requests = this.statementsMatching(undefined, this.sym(`${linkNamespaceURI}requestedURI`), this.rdfFactory.literal(doc.value), meta).map(st => st.subject)\n    for (var r = 0; r < requests.length; r++) {\n      const request = requests[r]\n      if (request != undefined) {\n        // removeMatches unresolved issue with collection https://github.com/linkeddata/rdflib.js/issues/631\n        let sts: Quad[]\n        // status collection\n        const status = this.any(request, this.sym(`${linkNamespaceURI}status`), null, meta) as Quad_Subject\n        if (status != undefined) {\n          sts = this.statementsMatching(status, this.sym(`${linkNamespaceURI}status`), null, meta).slice()\n          for (var i = 0; i < sts.length; i++) {\n            this.removeStatement(sts[i])\n          }\n        }\n        // response items list\n        const response = this.any(request, this.sym(`${linkNamespaceURI}response`), null, meta) as Quad_Subject\n        if (response != undefined) {\n          sts = this.statementsMatching(response, null, null, meta).slice()\n          for (var i = 0; i < sts.length; i++) {\n            this.removeStatement(sts[i])\n          }\n        }\n        // request triples\n        sts = this.statementsMatching(request, null, null, meta).slice()\n        for (var i = 0; i < sts.length; i++) {\n          this.removeStatement(sts[i])\n        }\n\n      }\n    }\n    this.removeMatches(this.sym(doc.value), null, null, meta) // content-type\n    return this\n  }\n\n  /**\n   * Remove all statements matching args (within limit) *\n   * @param subj The subject\n   * @param pred The predicate\n   * @param obj The object\n   * @param why The graph that contains the statement\n   * @param limit The number of statements to remove\n   */\n  removeMany(\n    subj?: Quad_Subject | null,\n    pred?: Quad_Predicate | null,\n    obj?: Quad_Object | null,\n    why?: Quad_Graph | null,\n    limit?: number\n  ): void {\n    // log.debug(\"entering removeMany w/ subj,pred,obj,why,limit = \" + subj +\", \"+ pred+\", \" + obj+\", \" + why+\", \" + limit)\n    var sts = this.statementsMatching(subj, pred, obj, why, false)\n    // This is a subtle bug that occurred in updateCenter.js too.\n    // The fact is, this.statementsMatching returns this.whyIndex instead of a copy of it\n    // but for perfromance consideration, it's better to just do that\n    // so make a copy here.\n    var statements: Quad[] = []\n    for (var i = 0; i < sts.length; i++) statements.push(sts[i])\n    if (limit) statements = statements.slice(0, limit)\n    for (i = 0; i < statements.length; i++) this.remove(statements[i])\n  }\n\n  /**\n   * Remove all matching statements\n   * @param subject The subject\n   * @param predicate The predicate\n   * @param object The object\n   * @param graph The graph that contains the statement\n   */\n  removeMatches(\n    subject?: Quad_Subject | null,\n    predicate?: Quad_Predicate | null,\n    object?: Quad_Object | null,\n    graph?: Quad_Graph | null\n  ): IndexedFormula {\n    this.removeMany(subject, predicate, object, graph)\n    return this\n  }\n\n  /**\n   * Remove a particular statement object from the store\n   *\n   * @param st - a statement which is already in the store and indexed.\n   *        Make sure you only use this for these.\n   *        Otherwise, you should use remove() above.\n   */\n  removeStatement(st: Quad): IndexedFormula {\n    // log.debug(\"entering remove w/ st=\" + st)\n    var term = [ st.subject, st.predicate, st.object, st.graph ]\n    for (var p = 0; p < 4; p++) {\n      var c = this.canon(term[p])\n      var h = this.id(c)\n      if (!this.index[p][h]) {\n        // log.warn (\"Statement removal: no index '+p+': \"+st)\n      } else {\n        this.rdfArrayRemove(this.index[p][h], st)\n      }\n    }\n    this.rdfArrayRemove(this.statements, st)\n    return this\n  }\n\n  /**\n   * Removes statements\n   * @param sts The statements to remove\n   */\n  removeStatements(sts: ReadonlyArray<Quad>): IndexedFormula {\n    for (var i = 0; i < sts.length; i++) {\n      this.remove(sts[i])\n    }\n    return this\n  }\n\n  /**\n   * Replace big with small, obsoleted with obsoleting.\n   */\n  replaceWith (big: Quad_Subject, small: Quad_Subject): boolean {\n    // log.debug(\"Replacing \"+big+\" with \"+small) // this.id(@@\n    var oldhash = this.id(big)\n    var newhash = this.id(small)\n    var moveIndex = function (ix) {\n      var oldlist = ix[oldhash]\n      if (!oldlist) {\n        return // none to move\n      }\n      var newlist = ix[newhash]\n      if (!newlist) {\n        ix[newhash] = oldlist\n      } else {\n        ix[newhash] = oldlist.concat(newlist)\n      }\n      delete ix[oldhash]\n    }\n    // the canonical one carries all the indexes\n    for (var i = 0; i < 4; i++) {\n      moveIndex(this.index[i])\n    }\n    this.redirections[oldhash] = small\n    if (big.value) {\n      // @@JAMBO: must update redirections,aliases from sub-items, too.\n      if (!this.aliases[newhash]) {\n        this.aliases[newhash] = []\n      }\n      this.aliases[newhash].push(big) // Back link\n      if (this.aliases[oldhash]) {\n        for (i = 0; i < this.aliases[oldhash].length; i++) {\n          this.redirections[this.id(this.aliases[oldhash][i])] = small\n          this.aliases[newhash].push(this.aliases[oldhash][i])\n        }\n      }\n      this.add(small, this.sym('http://www.w3.org/2007/ont/link#uri'), big)\n      // If two things are equal, and one is requested, we should request the other.\n      if (this.fetcher) {\n        this.fetcher.nowKnownAs(big, small)\n      }\n    }\n    moveIndex(this.classActions)\n    moveIndex(this.propertyActions)\n    // log.debug(\"Equate done. \"+big+\" to be known as \"+small)\n    return true // true means the statement does not need to be put in\n  }\n\n  /**\n   * Return all equivalent URIs by which this is known\n   * @param x A named node\n   */\n  allAliases(x: NamedNode): NamedNode[] {\n    var a = this.aliases[this.id(this.canon(x))] || []\n    a.push(this.canon(x))\n    return a\n  }\n\n  /**\n   * Compare by canonical URI as smushed\n   * @param x A named node\n   * @param y Another named node\n   */\n  sameThings(x: NamedNode, y: NamedNode): boolean {\n    if (x.equals(y)) {\n      return true\n    }\n    var x1 = this.canon(x)\n    //    alert('x1='+x1)\n    if (!x1) return false\n    var y1 = this.canon(y)\n    //    alert('y1='+y1); //@@\n    if (!y1) return false\n    return (x1.value === y1.value)\n  }\n\n  setPrefixForURI (prefix: string, nsuri: string): void {\n    // TODO: This is a hack for our own issues, which ought to be fixed\n    // post-release\n    // See http://dig.csail.mit.edu/cgi-bin/roundup.cgi/$rdf/issue227\n    if (prefix === 'tab' && this.namespaces['tab']) {\n      return\n    } // There are files around with long badly generated prefixes like this\n    if (prefix.slice(0, 2) === 'ns' || prefix.slice(0, 7) === 'default') {\n      return\n    }\n\n    // remove any prefix that currently targets nsuri\n    for (let existingPrefix in this.namespaces) {\n      if (this.namespaces[existingPrefix] == nsuri)\n        delete this.namespaces[existingPrefix];\n    }\n\n    this.namespaces[prefix] = nsuri\n  }\n\n  /** Search the Store\n   *\n   * ALL CONVENIENCE LOOKUP FUNCTIONS RELY ON THIS!\n   * @param subj - A node to search for as subject, or if null, a wildcard\n   * @param pred - A node to search for as predicate, or if null, a wildcard\n   * @param obj - A node to search for as object, or if null, a wildcard\n   * @param why - A node to search for as graph, or if null, a wildcard\n   * @param justOne - flag - stop when found one rather than get all of them?\n   * @returns An array of nodes which match the wildcard position\n   */\n  statementsMatching (\n    subj?: Quad_Subject | null,\n    pred?: Quad_Predicate | null,\n    obj?: Quad_Object | null,\n    why?: Quad_Graph | null,\n    justOne?: boolean\n  ): Statement[] {\n    // log.debug(\"Matching {\"+subj+\" \"+pred+\" \"+obj+\"}\")\n    var pat = [ subj, pred, obj, why ]\n    var pattern: Term[] = []\n    var hash: Indexable[] = []\n    var wild: number[] = [] // wildcards\n    var given: number[] = [] // Not wild\n    var p: number\n    var list\n    for (p = 0; p < 4; p++) {\n      pattern[p] = this.canon(Node.fromValue(pat[p]))\n      if (!pattern[p]) {\n        wild.push(p)\n      } else {\n        given.push(p)\n        hash[p] = this.id(pattern[p])\n      }\n    }\n    if (given.length === 0) {\n      return this.statements\n    }\n    if (given.length === 1) { // Easy too, we have an index for that\n      p = given[0]\n      list = this.index[p][hash[p]]\n      if (list && justOne) {\n        if (list.length > 1) {\n          list = list.slice(0, 1)\n        }\n      }\n      list = list || []\n      return list\n    }\n    // Now given.length is 2, 3 or 4.\n    // We hope that the scale-free nature of the data will mean we tend to get\n    // a short index in there somewhere!\n    var best = 1e10 // really bad\n    var iBest\n    var i\n    for (i = 0; i < given.length; i++) {\n      p = given[i] // Which part we are dealing with\n      list = this.index[p][hash[p]]\n      if (!list) {\n        return [] // No occurrences\n      }\n      if (list.length < best) {\n        best = list.length\n        iBest = i // (not p!)\n      }\n    }\n    // Ok, we have picked the shortest index but now we have to filter it\n    var pBest = given[iBest]\n    var possibles: Statement[] = this.index[pBest][hash[pBest]]\n    var check = given.slice(0, iBest).concat(given.slice(iBest + 1)) // remove iBest\n    var results: Statement[] = []\n    var parts = [ 'subject', 'predicate', 'object', 'why' ]\n    for (var j = 0; j < possibles.length; j++) {\n      var st: Statement | null = possibles[j]\n\n      for (i = 0; i < check.length; i++) { // for each position to be checked\n        p = check[i]\n        if (!this.canon(st[parts[p]]).equals(pattern[p])) {\n          st = null\n          break\n        }\n      }\n      if (st != null) {\n        results.push(st)\n        if (justOne) break\n      }\n    }\n    return results\n  }\n\n  /**\n   * A list of all the URIs by which this thing is known\n   * @param term\n   */\n  uris(term: Quad_Subject): string[] {\n    var cterm = this.canon(term)\n    var terms = this.aliases[this.id(cterm)]\n    if (!cterm.value) return []\n    var res = [ cterm.value ]\n    if (terms) {\n      for (var i = 0; i < terms.length; i++) {\n        res.push(terms[i].uri)\n      }\n    }\n    return res\n  }\n\n  serialize (base, contentType, provenance, options?) {\n\n    // override Formula.serialize to force the serializer namespace prefixes\n    // to those of this IndexedFormula\n\n    // if namespaces are explicitly passed in options, let them override the existing namespaces in this formula\n    const namespaces = options?.namespaces ? {...this.namespaces, ...options.namespaces} : {...this.namespaces};\n\n    options = {\n      ...(options || {}),\n      namespaces\n    }\n    return serialize(provenance, this, base, contentType, undefined, options);\n  }\n}\nIndexedFormula.handleRDFType = handleRDFType\n","/* Lists form conversion\n*/\n\n\n// import DataFactory from './factories/extended-term-factory'\n// import jsonldParser from './jsonldparser'\n// @ts-ignore is this injected?\nimport { Parser as N3jsParser } from 'n3'  // @@ Goal: remove this dependency\n// import N3Parser from './n3parser'\n// import { parseRDFaDOM } from './rdfaparser'\n// import RDFParser from './rdfxmlparser'\n// import sparqlUpdateParser from './patch-parser'\n// import * as Util from './utils-js'\nimport Node from './node-internal'\n// import BlankNode from './blank-node'\n// import NamedNode from './named-node'\nimport Collection from './collection'\nimport Statement from './statement'\n// import Formula from './formula'\nimport Store from './store'\n// import { ContentType, TurtleContentType, N3ContentType, RDFXMLContentType, XHTMLContentType, HTMLContentType, SPARQLUpdateContentType, SPARQLUpdateSingleMatchContentType, JSONLDContentType, NQuadsContentType, NQuadsAltContentType } from './types'\n\n// import { Quad } from './tf-types'\n\nimport {BlankNode, NamedNode, Quad, Term,} from './tf-types'\nimport Namespace from './namespace'\n\nconst RDF  = Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#')\n\n/* Replace a given node with another node throughout a given document\n*\n* we do the predicate as well for complenesss though we don't expect Collections to use it\n*/\nexport function substituteInDoc (store:Store, x:Term, y:Term, doc?: NamedNode ) {\n  // console.log(`substituteInDoc put ${x} for ${y} in ${doc}}`)\n  for (const quad of store.statementsMatching(y as any, null, null, doc as any)) {\n    const newStatement = new Statement(x as any, quad.predicate, quad.object, doc as any)\n    store.remove(quad)\n    store.add(newStatement)\n  }\n  for (const quad of store.statementsMatching(null, y as any, null, doc) as any) {\n    store.remove(quad)\n    // console.log(`  substituteInDoc predicate ${x} in ${quad}}`)\n    store.add(new Statement(quad.subject, x as any, quad.object, doc as any))\n  }\n  for (const quad of store.statementsMatching(null, null, y as any, doc) as any) {\n    store.remove(quad)\n    store.add(new Statement(quad.subject, quad.predicate, x as any, doc as any))\n  }\n}\n\n/* Change all lone rdf:nil nodes into empty Collections\n*/\nexport function substituteNillsInDoc (store:Store, doc?: NamedNode) {\n  const x = RDF('nil')\n  for (const quad of store.statementsMatching(x as any, null, null, doc as any)) {\n    store.remove(quad)\n    const y = new Collection()\n    store.add(new Statement(y as any, quad.predicate, quad.object, doc as any))\n  }\n  for (const quad of store.statementsMatching(null, null, x as any, doc) as any) {\n    if (!quad.predicate.sameTerm(RDF('rest'))) { // If not a tail\n      store.remove(quad)\n      const y = new Collection()\n      store.add(new Statement(quad.subject, quad.predicate, y as any, doc as any))\n    }\n  }\n}\n/**\n * Convert lists reified as rdf:first, rest\n * Normal method is sync.\n * Unfortunately jsdonld is currently written to need to be called async.\n * Hence the mess below with executeCallback.\n * @param store - The quadstore\n * @param doc - The document in which the conversion is done\n */\n\n\nexport function convertFirstRestNil (\n  store: Store,\n  doc: NamedNode | undefined,  // Do whole store?\n) {\n\n  function preceding (ele:BlankNode, listSoFar: Node[], trash: Quad[]): undefined {\n\n    const rests = store.statementsMatching(ele, RDF('rest'), null, doc)\n    if (rests.length !== 1) throw new Error(`Bad list structure: no rest at ${ele}`)\n\n    const firsts = store.statementsMatching(ele, RDF('first'), null, doc)\n    if (firsts.length !== 1) throw new Error(`Bad list structure: rest but ${firsts.length} firsts at ${ele}`)\n    const value = firsts[0].object\n    const total = [value].concat(listSoFar as any)\n    // console.log('  List now is: ', total)\n    const totalTrash =  trash.concat(rests).concat(firsts)\n\n    const pres = store.statementsMatching(null, RDF('rest'), ele, doc)\n    if (pres.length === 0) { // Head of the list\n      const newList  = new Collection(total)\n      store.remove(totalTrash)\n      // Replace old list with new list:\n      substituteInDoc(store, newList, ele, doc)\n      return\n    }\n    if (pres.length !== 1) throw new Error(`Bad list structure: ${pres.length} pres at ${ele}`)\n    const pre = pres[0].subject\n    if (pre.termType !== 'BlankNode')  throw new Error(`Bad list element node ${pre} type: ${pre.termType} `)\n\n    preceding(pre, total, totalTrash)\n    return\n  }\n\n  substituteNillsInDoc(store, doc) // lone ones only\n\n  const tails = store.statementsMatching(null, RDF('rest'), RDF('nil'), doc)\n  tails.forEach(tail => {\n    if (tail.subject.termType !== 'BlankNode')\n      throw new Error(`Bad list element node ${tail.subject} type: ${tail.subject.termType} `)\n    preceding(tail.subject, [], [])\n  })\n\n}\n","/**\n*\n*  UTF-8 data encode / decode\n*  http://www.webtoolkit.info/\n*\n**/\nimport * as Uri from './uri'\nimport { ArrayIndexOf } from './utils'\nimport { convertFirstRestNil } from './lists'\n\nfunction hexify (str) { // also used in parser\n  return encodeURI(str);\n}\n\nvar Utf8 = {\n    // public method for url encoding\n    encode : function (string) {\n        string = string.replace(/\\r\\n/g,\"\\n\");\n        var utftext = \"\";\n\n        for (var n = 0; n < string.length; n++) {\n\n            var c = string.charCodeAt(n);\n\n            if (c < 128) {\n                    utftext += String.fromCharCode(c);\n            }\n            else if((c > 127) && (c < 2048)) {\n                    utftext += String.fromCharCode((c >> 6) | 192);\n                    utftext += String.fromCharCode((c & 63) | 128);\n            }\n            else {\n                    utftext += String.fromCharCode((c >> 12) | 224);\n                    utftext += String.fromCharCode(((c >> 6) & 63) | 128);\n                    utftext += String.fromCharCode((c & 63) | 128);\n            }\n\n        }\n\n        return utftext;\n    },\n    // public method for url decoding\n    decode : function (utftext) {\n        var string = \"\";\n        var i = 0;\n\n        while ( i < utftext.length ) {\n\n                var c = utftext.charCodeAt(i);\n                if (c < 128) {\n                        string += String.fromCharCode(c);\n                        i++;\n                }\n                else if((c > 191) && (c < 224)) {\n                        string += String.fromCharCode(((c & 31) << 6)\n                            | (utftext.charCodeAt(i+1) & 63));\n                        i += 2;\n                }\n                else {\n                        string += String.fromCharCode(((c & 15) << 12)\n                            | ((utftext.charCodeAt(i+1) & 63) << 6)\n                            | (utftext.charCodeAt(i+2) & 63));\n                        i += 3;\n                }\n        }\n        return string;\n    }\n}// Things we need to define to make converted pythn code work in js\n// environment of $rdf\n\nvar RDFSink_forSomeSym = \"http://www.w3.org/2000/10/swap/log#forSome\";\nvar RDFSink_forAllSym = \"http://www.w3.org/2000/10/swap/log#forAll\";\nvar Logic_NS = \"http://www.w3.org/2000/10/swap/log#\";\n\n//  pyjs seems to reference runtime library which I didn't find\n\nvar pyjslib_Tuple = function(theList) { return theList };\n\nvar pyjslib_List = function(theList) { return theList };\n\nvar pyjslib_Dict = function(listOfPairs) {\n    if (listOfPairs.length > 0)\n\tthrow \"missing.js: oops nnonempty dict not imp\";\n    return [];\n}\n\nvar pyjslib_len = function(s) { return s.length }\n\nvar pyjslib_slice = function(str, i, j) {\n    if (typeof str.slice == 'undefined')\n        throw '@@ mising.js: No .slice function for '+str+' of type '+(typeof str)\n    if ((typeof j == 'undefined') || (j ==null)) return str.slice(i);\n    return str.slice(i, j) // @ exactly the same spec?\n}\nvar StopIteration = Error('dummy error stop iteration');\n\nvar pyjslib_Iterator = function(theList) {\n    this.last = 0;\n    this.li = theList;\n    this.next = function() {\n\tif (this.last == this.li.length) throw StopIteration;\n\treturn this.li[this.last++];\n    }\n    return this;\n};\n\nvar ord = function(str) {\n    return str.charCodeAt(0)\n}\n\nvar string_find = function(str, s) {\n    return str.indexOf(s)\n}\n\nvar assertFudge = function(condition, desc) {\n    if (condition) return;\n    if (desc) throw \"python Assertion failed: \"+desc;\n    throw \"(python) Assertion failed.\";\n}\n\n\nvar stringFromCharCode = function(uesc) {\n    return String.fromCharCode(uesc);\n}\n\n\nString.prototype.encode = function(encoding) {\n    if (encoding != 'utf-8') throw \"UTF8_converter: can only do utf-8\"\n    return Utf8.encode(this);\n}\nString.prototype.decode = function(encoding) {\n    if (encoding != 'utf-8') throw \"UTF8_converter: can only do utf-8\"\n    //return Utf8.decode(this);\n    return this;\n}\n\n\n\nvar uripath_join = function(base, given) {\n    return Uri.join(given, base)  // sad but true\n}\n\nvar becauseSubexpression = null; // No reason needed\nvar diag_tracking = 0;\nvar diag_chatty_flag = 0;\nvar diag_progress = function(str) { /*$rdf.log.debug(str);*/ }\n\n// why_BecauseOfData = function(doc, reason) { return doc };\n\n\nvar RDF_type_URI = \"http://www.w3.org/1999/02/22-rdf-syntax-ns#type\";\nvar RDF_nil_URI = \"http://www.w3.org/1999/02/22-rdf-syntax-ns#nil\";\nvar DAML_sameAs_URI = \"http://www.w3.org/2002/07/owl#sameAs\";\n\n/*\nfunction SyntaxError(details) {\n    return new __SyntaxError(details);\n}\n*/\n\nfunction __SyntaxError(details) {\n    this.details = details\n}\n\n/*\n\n$Id: n3parser.js 14561 2008-02-23 06:37:26Z kennyluck $\n\nHAND EDITED FOR CONVERSION TO JAVASCRIPT\n\nThis module implements a Nptation3 parser, and the final\npart of a notation3 serializer.\n\nSee also:\n\nNotation 3\nhttp://www.w3.org/DesignIssues/Notation3\n\nClosed World Machine - and RDF Processor\nhttp://www.w3.org/2000/10/swap/cwm\n\nTo DO: See also \"@@\" in comments\n\n- Clean up interfaces\n______________________________________________\n\nModule originally by Dan Connolly, includeing notation3\nparser and RDF generator. TimBL added RDF stream model\nand N3 generation, replaced stream model with use\nof common store/formula API.  Yosi Scharf developped\nthe module, including tests and test harness.\n\n*/\n\nvar ADDED_HASH = \"#\";\nvar LOG_implies_URI = \"http://www.w3.org/2000/10/swap/log#implies\";\nvar INTEGER_DATATYPE = \"http://www.w3.org/2001/XMLSchema#integer\";\nvar FLOAT_DATATYPE = \"http://www.w3.org/2001/XMLSchema#double\";\nvar DECIMAL_DATATYPE = \"http://www.w3.org/2001/XMLSchema#decimal\";\nvar DATE_DATATYPE = \"http://www.w3.org/2001/XMLSchema#date\";\nvar DATETIME_DATATYPE = \"http://www.w3.org/2001/XMLSchema#dateTime\";\nvar BOOLEAN_DATATYPE = \"http://www.w3.org/2001/XMLSchema#boolean\";\nvar option_noregen = 0;\nvar _notQNameChars = \"\\t\\r\\n !\\\"#$%&'()*.,+/;<=>?@[\\\\]^`{|}~\";\nvar _notNameChars =  ( _notQNameChars + \":\" ) ;\nvar _rdfns = \"http://www.w3.org/1999/02/22-rdf-syntax-ns#\";\nvar N3CommentCharacter = \"#\";\nvar eol = new RegExp(\"^[ \\\\t]*(#[^\\\\n]*)?\\\\r?\\\\n\", 'g');\nvar eof = new RegExp(\"^[ \\\\t]*(#[^\\\\n]*)?$\", 'g');\nvar ws = new RegExp(\"^[ \\\\t]*\", 'g');\nvar signed_integer = new RegExp(\"^[-+]?[0-9]+\", 'g');\nvar number_syntax = new RegExp(\"^([-+]?[0-9]+)(\\\\.[0-9]+)?(e[-+]?[0-9]+)?\", 'g');\nvar datetime_syntax = new RegExp('^[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9](T[0-9][0-9]:[0-9][0-9](:[0-9][0-9](\\\\.[0-9]*)?)?)?Z?');\n\nvar digitstring = new RegExp(\"^[0-9]+\", 'g');\nvar interesting = new RegExp(\"[\\\\\\\\\\\\r\\\\n\\\\\\\"]\", 'g');\nvar langcode = new RegExp(\"^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*\", 'g');\n\nfunction createSinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why) {\n    return new SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why);\n}\n\nexport default createSinkParser;\n\nexport class SinkParser {\n    constructor(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why) {\n        if (typeof openFormula == 'undefined') openFormula=null;\n        if (typeof thisDoc == 'undefined') thisDoc=\"\";\n        if (typeof baseURI == 'undefined') baseURI=null;\n        if (typeof genPrefix == 'undefined') genPrefix=\"\";\n        if (typeof metaURI == 'undefined') metaURI=null;\n        if (typeof flags == 'undefined') flags=\"\";\n        if (typeof why == 'undefined') why=null;\n        /*\n        note: namespace names should *not* end in #;\n        the # will get added during qname processing */\n\n        this._bindings = new pyjslib_Dict([]);\n        this._flags = flags;\n        if ((thisDoc != \"\")) {\n            assertFudge((thisDoc.indexOf(\":\") >= 0),  ( \"Document URI not absolute: \" + thisDoc ) );\n            this._bindings[\"\"] = (  ( thisDoc + \"#\" ) );\n        }\n        this._store = store;\n        if (genPrefix) {\n            store.setGenPrefix(genPrefix);\n        }\n        this._thisDoc = thisDoc;\n        this.source = store.sym(thisDoc);\n        this.lines = 0;\n        this.statementCount = 0;\n        this.hasNil = false;\n        this.startOfLine = 0;\n        this.previousLine = 0;\n        this._genPrefix = genPrefix;\n        this.keywords = new pyjslib_List([\"a\", \"this\", \"bind\", \"has\", \"is\", \"of\", \"true\", \"false\"]);\n        this.keywordsSet = 0;\n        this._anonymousNodes = new pyjslib_Dict([]);\n        this._variables = new pyjslib_Dict([]);\n        this._parentVariables = new pyjslib_Dict([]);\n        this._reason = why;\n        this._reason2 = null;\n        if (diag_tracking) {\n            this._reason2 = why_BecauseOfData(store.sym(thisDoc), this._reason);\n        }\n        if (baseURI) {\n            this._baseURI = baseURI;\n        }\n        else {\n            if (thisDoc) {\n                this._baseURI = thisDoc;\n            }\n            else {\n                this._baseURI = null;\n            }\n        }\n        assertFudge(!(this._baseURI) || (this._baseURI.indexOf(\":\") >= 0));\n        if (!(this._genPrefix)) {\n            if (this._thisDoc) {\n                this._genPrefix =  ( this._thisDoc + \"#_g\" ) ;\n            }\n            else {\n                this._genPrefix = RDFSink_uniqueURI();\n            }\n        }\n        if ((openFormula == null)) {\n            if (this._thisDoc) {\n                this._formula = store.formula( ( thisDoc + \"#_formula\" ) );\n            }\n            else {\n                this._formula = store.formula();\n            }\n        }\n        else {\n            this._formula = openFormula;\n        }\n        this._context = this._formula;\n        this._parentContext = null;\n    }\n\n\n    here(i) {\n        return  (  (  (  ( this._genPrefix + \"_L\" )  + this.lines )  + \"C\" )  +  (  ( i - this.startOfLine )  + 1 )  ) ;\n    };\n    formula() {\n        return this._formula;\n    };\n    loadStream(stream) {\n        return this.loadBuf(stream.read());\n    };\n    loadBuf(buf) {\n        /*\n        Parses a buffer and returns its top level formula*/\n\n        this.startDoc();\n        this.feed(buf);\n        return this.endDoc();\n    };\n    feed(octets) {\n        /*\n        Feed an octet stream tothe parser\n\n        if BadSyntax is raised, the string\n        passed in the exception object is the\n        remainder after any statements have been parsed.\n        So if there is more data to feed to the\n        parser, it should be straightforward to recover.*/\n\n        var str = octets.decode(\"utf-8\");\n        var i = 0;\n        while ((i >= 0)) {\n            var j = this.skipSpace(str, i);\n            if ((j < 0)) {\n                return;\n            }\n            var i = this.directiveOrStatement(str, j);\n            if ((i < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, j, \"expected directive or statement\");\n            }\n        }\n    };\n    directiveOrStatement(str, h) {\n        var i = this.skipSpace(str, h);\n        if ((i < 0)) {\n            return i;\n        }\n        var j = this.directive(str, i);\n        if ((j >= 0)) {\n            return this.checkDot(str, j);\n        }\n        var j = this.statement(str, i);\n        if ((j >= 0)) {\n            return this.checkDot(str, j);\n        }\n        return j;\n    };\n    tok(tok, str, i) {\n        /*\n        Check for keyword.  Space must have been stripped on entry and\n        we must not be at end of file.*/\n        var whitespace = \"\\t\\n\\v\\f\\r \";\n        if ((str.slice( i,  ( i + 1 ) ) == \"@\")) {\n            var i =  ( i + 1 ) ;\n        }\n        else {\n            if ((ArrayIndexOf(this.keywords,tok) < 0)) {\n                return -1;\n            }\n        }\n        var k =  ( i + pyjslib_len(tok) ) ;\n        if ((str.slice( i, k) == tok) && (_notQNameChars.indexOf(str.charAt(k)) >= 0)) {\n            return k;\n        }\n        else {\n            return -1;\n        }\n    };\n    directive(str, i) {\n        var j = this.skipSpace(str, i);\n        if ((j < 0)) {\n            return j;\n        }\n        var res = new pyjslib_List([]);\n        var j = this.tok(\"bind\", str, i);\n        if ((j > 0)) {\n            throw BadSyntax(this._thisDoc, this.lines, str, i, \"keyword bind is obsolete: use @prefix\");\n        }\n        var j = this.tok(\"keywords\", str, i);\n        if ((j > 0)) {\n            var i = this.commaSeparatedList(str, j, res, false);\n            if ((i < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, i, \"'@keywords' needs comma separated list of words\");\n            }\n            this.setKeywords(pyjslib_slice(res, null, null));\n            if ((diag_chatty_flag > 80)) {\n                diag_progress(\"Keywords \", this.keywords);\n            }\n            return i;\n        }\n        var j = this.tok(\"forAll\", str, i);\n        if ((j > 0)) {\n            var i = this.commaSeparatedList(str, j, res, true);\n            if ((i < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, i, \"Bad variable list after @forAll\");\n            }\n\n            var __x = new pyjslib_Iterator(res);\n            try {\n                while (true) {\n                    var x = __x.next();\n\n\n                    if (ArrayIndexOf(this._variables,x) < 0 || (ArrayIndexOf(this._parentVariables,x) >= 0)) {\n                        this._variables[x] = ( this._context.newUniversal(x));\n                    }\n\n                }\n            } catch (e) {\n                if (e != StopIteration) {\n                    throw e;\n                }\n            }\n\n            return i;\n        }\n        var j = this.tok(\"forSome\", str, i);\n        if ((j > 0)) {\n            var i = this.commaSeparatedList(str, j, res, this.uri_ref2);\n            if ((i < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, i, \"Bad variable list after @forSome\");\n            }\n\n            var __x = new pyjslib_Iterator(res);\n            try {\n                while (true) {\n                    var x = __x.next();\n\n\n                    this._context.declareExistential(x);\n\n                }\n            } catch (e) {\n                if (e != StopIteration) {\n                    throw e;\n                }\n            }\n\n            return i;\n        }\n        var j = this.tok(\"prefix\", str, i);\n        if ((j >= 0)) {\n            var t = new pyjslib_List([]);\n            var i = this.qname(str, j, t);\n            if ((i < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, j, \"expected qname after @prefix\");\n            }\n            var j = this.uri_ref2(str, i, t);\n            if ((j < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, i, \"expected <uriref> after @prefix _qname_\");\n            }\n            var ns = t[1].uri;\n            if (this._baseURI) {\n                var ns = uripath_join(this._baseURI, ns);\n            }\n            else {\n                assertFudge((ns.indexOf(\":\") >= 0), \"With no base URI, cannot handle relative URI for NS\");\n            }\n            assertFudge((ns.indexOf(\":\") >= 0));\n            this._bindings[t[0][0]] = ( ns);\n\n            this.bind(t[0][0], hexify(ns));\n            return j;\n        }\n        var j = this.tok(\"base\", str, i);\n        if ((j >= 0)) {\n            var t = new pyjslib_List([]);\n            var i = this.uri_ref2(str, j, t);\n            if ((i < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, j, \"expected <uri> after @base \");\n            }\n            var ns = t[0].uri;\n            if (this._baseURI) {\n                var ns = uripath_join(this._baseURI, ns);\n            }\n            else {\n                throw BadSyntax(this._thisDoc, this.lines, str, j,  (  ( \"With no previous base URI, cannot use relative URI in @base  <\" + ns )  + \">\" ) );\n            }\n            assertFudge((ns.indexOf(\":\") >= 0));\n            this._baseURI = ns;\n            return i;\n        }\n        return -1;\n    };\n    bind(qn, uri) {\n        if ((qn == \"\")) {\n        }\n        else {\n            this._store.setPrefixForURI(qn, uri);\n        }\n    };\n    setKeywords(k) {\n        /*\n        Takes a list of strings*/\n\n        if ((k == null)) {\n            this.keywordsSet = 0;\n        }\n        else {\n            this.keywords = k;\n            this.keywordsSet = 1;\n        }\n    };\n    startDoc() {\n    };\n\n    /* Signal end of document and stop parsing. returns formula */\n    endDoc() {\n        if (this.hasNil && this._store.rdfFactory.supports[\"COLLECTIONS\"]) {\n          convertFirstRestNil(this._store, this.source)\n        }\n        return this._formula;\n    };\n    makeStatement(quad) {\n        quad[0].add(quad[2], quad[1], quad[3], this.source);\n        if ((quad[2].uri && quad[2].uri === RDF_nil_URI)\n        || (quad[3].uri && quad[3].uri === RDF_nil_URI)) {\n          this.hasNil = true\n        }\n        this.statementCount += 1;\n    };\n    statement(str, i) {\n        var r = new pyjslib_List([]);\n        var i = this.object(str, i, r);\n        if ((i < 0)) {\n            return i;\n        }\n        var j = this.property_list(str, i, r[0]);\n        if ((j < 0)) {\n            throw BadSyntax(this._thisDoc, this.lines, str, i, \"expected propertylist\");\n        }\n        return j;\n    };\n    subject(str, i, res) {\n        return this.item(str, i, res);\n    };\n    verb(str, i, res) {\n        /*\n        has _prop_\n        is _prop_ of\n        a\n        =\n        _prop_\n        >- prop ->\n        <- prop -<\n        _operator_*/\n\n        var j = this.skipSpace(str, i);\n        if ((j < 0)) {\n            return j;\n        }\n        var r = new pyjslib_List([]);\n        var j = this.tok(\"has\", str, i);\n        if ((j >= 0)) {\n            var i = this.prop(str, j, r);\n            if ((i < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, j, \"expected property after 'has'\");\n            }\n            res.push(new pyjslib_Tuple([\"->\", r[0]]));\n            return i;\n        }\n        var j = this.tok(\"is\", str, i);\n        if ((j >= 0)) {\n            var i = this.prop(str, j, r);\n            if ((i < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, j, \"expected <property> after 'is'\");\n            }\n            var j = this.skipSpace(str, i);\n            if ((j < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, i, \"End of file found, expected property after 'is'\");\n                return j;\n            }\n            var i = j;\n            var j = this.tok(\"of\", str, i);\n            if ((j < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, i, \"expected 'of' after 'is' <prop>\");\n            }\n            res.push(new pyjslib_Tuple([\"<-\", r[0]]));\n            return j;\n        }\n        var j = this.tok(\"a\", str, i);\n        if ((j >= 0)) {\n            res.push(new pyjslib_Tuple([\"->\", this._store.sym(RDF_type_URI)]));\n            return j;\n        }\n        if ((str.slice( i,  ( i + 2 ) ) == \"<=\")) {\n            res.push(new pyjslib_Tuple([\"<-\", this._store.sym( ( Logic_NS + \"implies\" ) )]));\n            return  ( i + 2 ) ;\n        }\n        if ((str.slice( i,  ( i + 1 ) ) == \"=\")) {\n            if ((str.slice(  ( i + 1 ) ,  ( i + 2 ) ) == \">\")) {\n                res.push(new pyjslib_Tuple([\"->\", this._store.sym( ( Logic_NS + \"implies\" ) )]));\n                return  ( i + 2 ) ;\n            }\n            res.push(new pyjslib_Tuple([\"->\", this._store.sym(DAML_sameAs_URI)]));\n            return  ( i + 1 ) ;\n        }\n        if ((str.slice( i,  ( i + 2 ) ) == \":=\")) {\n            res.push(new pyjslib_Tuple([\"->\",  ( Logic_NS + \"becomes\" ) ]));\n            return  ( i + 2 ) ;\n        }\n        var j = this.prop(str, i, r);\n        if ((j >= 0)) {\n            res.push(new pyjslib_Tuple([\"->\", r[0]]));\n            return j;\n        }\n        if ((str.slice( i,  ( i + 2 ) ) == \">-\") || (str.slice( i,  ( i + 2 ) ) == \"<-\")) {\n            throw BadSyntax(this._thisDoc, this.lines, str, j, \">- ... -> syntax is obsolete.\");\n        }\n        return -1;\n    };\n    prop(str, i, res) {\n        return this.item(str, i, res);\n    };\n    item(str, i, res) {\n        return this.path(str, i, res);\n    };\n    blankNode(uri) {\n        return this._context.bnode(uri, this._reason2);\n    };\n    path(str, i, res) {\n        /*\n        Parse the path production.\n        */\n\n        var j = this.nodeOrLiteral(str, i, res);\n        if ((j < 0)) {\n            return j;\n        }\n        while ((\"!^.\".indexOf(str.slice( j,  ( j + 1 ) )) >= 0)) {\n            var ch = str.slice( j,  ( j + 1 ) );\n            if ((ch == \".\")) {\n                var ahead = str.slice(  ( j + 1 ) ,  ( j + 2 ) );\n                if (!(ahead) || (_notNameChars.indexOf(ahead) >= 0) && (\":?<[{(\".indexOf(ahead) < 0)) {\n                    break;\n                }\n            }\n            var subj = res.pop();\n            var obj = this.blankNode(this.here(j));\n            var j = this.node(str,  ( j + 1 ) , res);\n            if ((j < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, j, \"EOF found in middle of path syntax\");\n            }\n            var pred = res.pop();\n            if ((ch == \"^\")) {\n                this.makeStatement(new pyjslib_Tuple([this._context, pred, obj, subj]));\n            }\n            else {\n                this.makeStatement(new pyjslib_Tuple([this._context, pred, subj, obj]));\n            }\n            res.push(obj);\n        }\n        return j;\n    };\n    anonymousNode(ln) {\n        /*\n        Remember or generate a term for one of these _: anonymous nodes*/\n\n        var term = this._anonymousNodes[ln];\n        if (term) {\n            return term;\n        }\n        var term = this._store.bnode(ln);\n        // var term = this._store.bnode(this._context, this._reason2); eh?\n        this._anonymousNodes[ln] = ( term);\n        return term;\n    };\n    node(str, i, res, subjectAlready) {\n        if (typeof subjectAlready == 'undefined') subjectAlready=null;\n        /*\n        Parse the <node> production.\n        Space is now skipped once at the beginning\n        instead of in multipe calls to self.skipSpace().\n        */\n\n        var subj = subjectAlready;\n        var j = this.skipSpace(str, i);\n        if ((j < 0)) {\n            return j;\n        }\n        var i = j;\n        var ch = str.slice( i,  ( i + 1 ) );\n        if ((ch == \"[\")) {\n            var bnodeID = this.here(i);\n            var j = this.skipSpace(str,  ( i + 1 ) );\n            if ((j < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, i, \"EOF after '['\");\n            }\n            if ((str.slice( j,  ( j + 1 ) ) == \"=\")) {\n                var i =  ( j + 1 ) ;\n                var objs = new pyjslib_List([]);\n                var j = this.objectList(str, i, objs);\n\n                if ((j >= 0)) {\n                    var subj = objs[0];\n                    if ((pyjslib_len(objs) > 1)) {\n\n                        var __obj = new pyjslib_Iterator(objs);\n                        try {\n                            while (true) {\n                                var obj = __obj.next();\n\n\n                                this.makeStatement(new pyjslib_Tuple([this._context, this._store.sym(DAML_sameAs_URI), subj, obj]));\n\n                            }\n                        } catch (e) {\n                            if (e != StopIteration) {\n                                throw e;\n                            }\n                        }\n\n                    }\n                    var j = this.skipSpace(str, j);\n                    if ((j < 0)) {\n                        throw BadSyntax(this._thisDoc, this.lines, str, i, \"EOF when objectList expected after [ = \");\n                    }\n                    if ((str.slice( j,  ( j + 1 ) ) == \";\")) {\n                        var j =  ( j + 1 ) ;\n                    }\n                }\n                else {\n                    throw BadSyntax(this._thisDoc, this.lines, str, i, \"objectList expected after [= \");\n                }\n            }\n            if ((subj == null)) {\n                var subj = this.blankNode(bnodeID);\n            }\n            var i = this.property_list(str, j, subj);\n            if ((i < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, j, \"property_list expected\");\n            }\n            var j = this.skipSpace(str, i);\n            if ((j < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, i, \"EOF when ']' expected after [ <propertyList>\");\n            }\n            if ((str.slice( j,  ( j + 1 ) ) != \"]\")) {\n                throw BadSyntax(this._thisDoc, this.lines, str, j, \"']' expected\");\n            }\n            res.push(subj);\n            return  ( j + 1 ) ;\n        }\n        if ((ch == \"{\")) {\n            var ch2 = str.slice(  ( i + 1 ) ,  ( i + 2 ) );\n            if ((ch2 == \"$\")) {\n                i += 1;\n                var j =  ( i + 1 ) ;\n                var mylist = new pyjslib_List([]);\n                var first_run = true;\n                while (1) {\n                    var i = this.skipSpace(str, j);\n                    if ((i < 0)) {\n                        throw BadSyntax(this._thisDoc, this.lines, str, i, \"needed '$}', found end.\");\n                    }\n                    if ((str.slice( i,  ( i + 2 ) ) == \"$}\")) {\n                        var j =  ( i + 2 ) ;\n                        break;\n                    }\n                    if (!(first_run)) {\n                        if ((str.slice( i,  ( i + 1 ) ) == \",\")) {\n                            i += 1;\n                        }\n                        else {\n                            throw BadSyntax(this._thisDoc, this.lines, str, i, \"expected: ','\");\n                        }\n                    }\n                    else {\n                        var first_run = false;\n                    }\n                    var item = new pyjslib_List([]);\n                    var j = this.item(str, i, item);\n                    if ((j < 0)) {\n                        throw BadSyntax(this._thisDoc, this.lines, str, i, \"expected item in set or '$}'\");\n                    }\n                    mylist.push(item[0]);\n                }\n                res.push(this._store.newSet(mylist, this._context));\n                return j;\n            }\n            else {\n                var j =  ( i + 1 ) ;\n                var oldParentContext = this._parentContext;\n                this._parentContext = this._context;\n                var parentAnonymousNodes = this._anonymousNodes;\n                var grandParentVariables = this._parentVariables;\n                this._parentVariables = this._variables;\n                this._anonymousNodes = new pyjslib_Dict([]);\n                this._variables = this._variables.slice();\n                var reason2 = this._reason2;\n                this._reason2 = becauseSubexpression;\n                if ((subj == null)) {\n                    var subj = this._store.formula();\n                }\n                this._context = subj;\n                while (1) {\n                    var i = this.skipSpace(str, j);\n                    if ((i < 0)) {\n                        throw BadSyntax(this._thisDoc, this.lines, str, i, \"needed '}', found end.\");\n                    }\n                    if ((str.slice( i,  ( i + 1 ) ) == \"}\")) {\n                        var j =  ( i + 1 ) ;\n                        break;\n                    }\n                    var j = this.directiveOrStatement(str, i);\n                    if ((j < 0)) {\n                        throw BadSyntax(this._thisDoc, this.lines, str, i, \"expected statement or '}'\");\n                    }\n                }\n                this._anonymousNodes = parentAnonymousNodes;\n                this._variables = this._parentVariables;\n                this._parentVariables = grandParentVariables;\n                this._context = this._parentContext;\n                this._reason2 = reason2;\n                this._parentContext = oldParentContext;\n                res.push(subj.close());\n                return j;\n            }\n        }\n        if ((ch == \"(\")) {\n            var thing_type = this._store.list;\n            var ch2 = str.slice(  ( i + 1 ) ,  ( i + 2 ) );\n            if ((ch2 == \"$\")) {\n                var thing_type = this._store.newSet;\n                i += 1;\n            }\n            var j =  ( i + 1 ) ;\n            var mylist = new pyjslib_List([]);\n            while (1) {\n                var i = this.skipSpace(str, j);\n                if ((i < 0)) {\n                    throw BadSyntax(this._thisDoc, this.lines, str, i, \"needed ')', found end.\");\n                }\n                if ((str.slice( i,  ( i + 1 ) ) == \")\")) {\n                    var j =  ( i + 1 ) ;\n                    break;\n                }\n                var item = new pyjslib_List([]);\n                var j = this.item(str, i, item);\n                if ((j < 0)) {\n                    throw BadSyntax(this._thisDoc, this.lines, str, i, \"expected item in list or ')'\");\n                }\n                mylist.push(item[0]);\n            }\n            res.push(thing_type(mylist, this._context));\n            return j;\n        }\n        var j = this.tok(\"this\", str, i);\n        if ((j >= 0)) {\n            throw BadSyntax(this._thisDoc, this.lines, str, i, \"Keyword 'this' was ancient N3. Now use @forSome and @forAll keywords.\");\n            res.push(this._context);\n            return j;\n        }\n        var j = this.tok(\"true\", str, i);\n        if ((j >= 0)) {\n            res.push(true);\n            return j;\n        }\n        var j = this.tok(\"false\", str, i);\n        if ((j >= 0)) {\n            res.push(false);\n            return j;\n        }\n        if ((subj == null)) {\n            var j = this.uri_ref2(str, i, res);\n            if ((j >= 0)) {\n                return j;\n            }\n        }\n        return -1;\n    };\n    property_list(str, i, subj) {\n        /*\n        Parse property list\n        Leaves the terminating punctuation in the buffer\n        */\n\n        while (1) {\n            var j = this.skipSpace(str, i);\n            if ((j < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, i, \"EOF found when expected verb in property list\");\n                return j;\n            }\n            if ((str.slice( j,  ( j + 2 ) ) == \":-\")) {\n                var i =  ( j + 2 ) ;\n                var res = new pyjslib_List([]);\n                var j = this.node(str, i, res, subj);\n                if ((j < 0)) {\n                    throw BadSyntax(this._thisDoc, this.lines, str, i, \"bad {} or () or [] node after :- \");\n                }\n                var i = j;\n                continue;\n            }\n            var i = j;\n            var v = new pyjslib_List([]);\n            var j = this.verb(str, i, v);\n            if ((j <= 0)) {\n                return i;\n            }\n            var objs = new pyjslib_List([]);\n            var i = this.objectList(str, j, objs);\n            if ((i < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, j, \"objectList expected\");\n            }\n\n            var __obj = new pyjslib_Iterator(objs);\n            try {\n                while (true) {\n                    var obj = __obj.next();\n\n\n                    var pairFudge = v[0];\n                    var dir = pairFudge[0];\n                    var sym = pairFudge[1];\n                    if ((dir == \"->\")) {\n                        this.makeStatement(new pyjslib_Tuple([this._context, sym, subj, obj]));\n                    }\n                    else {\n                        this.makeStatement(new pyjslib_Tuple([this._context, sym, obj, subj]));\n                    }\n\n                }\n            } catch (e) {\n                if (e != StopIteration) {\n                    throw e;\n                }\n            }\n\n            var j = this.skipSpace(str, i);\n            if ((j < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, j, \"EOF found in list of objects\");\n                return j;\n            }\n            if ((str.slice( i,  ( i + 1 ) ) != \";\")) {\n                return i;\n            }\n            var i =  ( i + 1 ) ;\n        }\n    };\n    commaSeparatedList(str, j, res, ofUris) {\n        /*\n        return value: -1 bad syntax; >1 new position in str\n        res has things found appended\n\n        Used to use a final value of the function to be called, e.g. this.bareWord\n        but passing the function didn't work fo js converion pyjs\n        */\n\n        var i = this.skipSpace(str, j);\n        if ((i < 0)) {\n            throw BadSyntax(this._thisDoc, this.lines, str, i, \"EOF found expecting comma sep list\");\n            return i;\n        }\n        if ((str.charAt(i) == \".\")) {\n            return j;\n        }\n        if (ofUris) {\n            var i = this.uri_ref2(str, i, res);\n        }\n        else {\n            var i = this.bareWord(str, i, res);\n        }\n        if ((i < 0)) {\n            return -1;\n        }\n        while (1) {\n            var j = this.skipSpace(str, i);\n            if ((j < 0)) {\n                return j;\n            }\n            var ch = str.slice( j,  ( j + 1 ) );\n            if ((ch != \",\")) {\n                if ((ch != \".\")) {\n                    return -1;\n                }\n                return j;\n            }\n            if (ofUris) {\n                var i = this.uri_ref2(str,  ( j + 1 ) , res);\n            }\n            else {\n                var i = this.bareWord(str,  ( j + 1 ) , res);\n            }\n            if ((i < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, i, \"bad list content\");\n                return i;\n            }\n        }\n    };\n    objectList(str, i, res) {\n        var i = this.object(str, i, res);\n        if ((i < 0)) {\n            return -1;\n        }\n        while (1) {\n            var j = this.skipSpace(str, i);\n            if ((j < 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, j, \"EOF found after object\");\n                return j;\n            }\n            if ((str.slice( j,  ( j + 1 ) ) != \",\")) {\n                return j;\n            }\n            var i = this.object(str,  ( j + 1 ) , res);\n            if ((i < 0)) {\n                return i;\n            }\n        }\n    };\n    checkDot(str, i) {\n        var j = this.skipSpace(str, i);\n        if ((j < 0)) {\n            return j;\n        }\n        if ((str.slice( j,  ( j + 1 ) ) == \".\")) {\n            return  ( j + 1 ) ;\n        }\n        if ((str.slice( j,  ( j + 1 ) ) == \"}\")) {\n            return j;\n        }\n        if ((str.slice( j,  ( j + 1 ) ) == \"]\")) {\n            return j;\n        }\n        throw BadSyntax(this._thisDoc, this.lines, str, j, \"expected '.' or '}' or ']' at end of statement\");\n        return i;\n    };\n    uri_ref2(str, i, res) {\n        /*\n        Generate uri from n3 representation.\n\n        Note that the RDF convention of directly concatenating\n        NS and local name is now used though I prefer inserting a '#'\n        to make the namesapces look more like what XML folks expect.\n        */\n\n        var qn = new pyjslib_List([]);\n        var j = this.qname(str, i, qn);\n        if ((j >= 0)) {\n            var pairFudge = qn[0];\n            var pfx = pairFudge[0];\n            var ln = pairFudge[1];\n            if ((pfx == null)) {\n                assertFudge(0, \"not used?\");\n                var ns =  ( this._baseURI + ADDED_HASH ) ;\n            }\n            else {\n                var ns = this._bindings[pfx];\n                if (!(ns)) {\n                    if ((pfx == \"_\")) {\n                        res.push(this.anonymousNode(ln));\n                        return j;\n                    }\n                    throw BadSyntax(this._thisDoc, this.lines, str, i,  (  ( \"Prefix \" + pfx )  + \" not bound.\" ) );\n                }\n            }\n            var symb = this._store.sym( ( ns + ln ) );\n            if ((ArrayIndexOf(this._variables, symb) >= 0)) {\n                res.push(this._variables[symb]);\n            }\n            else {\n                res.push(symb);\n            }\n            return j;\n        }\n        var i = this.skipSpace(str, i);\n        if ((i < 0)) {\n            return -1;\n        }\n        if ((str.charAt(i) == \"?\")) {\n            var v = new pyjslib_List([]);\n            var j = this.variable(str, i, v);\n            if ((j > 0)) {\n                res.push(v[0]);\n                return j;\n            }\n            return -1;\n        }\n        else if ((str.charAt(i) == \"<\")) {\n            var i =  ( i + 1 ) ;\n            var st = i;\n            while ((i < pyjslib_len(str))) {\n                if ((str.charAt(i) == \">\")) {\n                    var uref = str.slice( st, i);\n                    if (this._baseURI) {\n                        var uref = uripath_join(this._baseURI, uref);\n                    }\n                    else {\n                        assertFudge((uref.indexOf(\":\") >= 0), \"With no base URI, cannot deal with relative URIs\");\n                    }\n                    if ((str.slice(  ( i - 1 ) , i) == \"#\") && !((pyjslib_slice(uref, -1, null) == \"#\"))) {\n                        var uref =  ( uref + \"#\" ) ;\n                    }\n                    var symb = this._store.sym(uref);\n                    if ((ArrayIndexOf(this._variables,symb) >= 0)) {\n                        res.push(this._variables[symb]);\n                    }\n                    else {\n                        res.push(symb);\n                    }\n                    return  ( i + 1 ) ;\n                }\n                var i =  ( i + 1 ) ;\n            }\n            throw BadSyntax(this._thisDoc, this.lines, str, j, \"unterminated URI reference\");\n        }\n        else if (this.keywordsSet) {\n            var v = new pyjslib_List([]);\n            var j = this.bareWord(str, i, v);\n            if ((j < 0)) {\n                return -1;\n            }\n            if ((ArrayIndexOf(this.keywords, v[0]) >= 0)) {\n                throw BadSyntax(this._thisDoc, this.lines, str, i,  (  ( \"Keyword \\\"\" + v[0] )  + \"\\\" not allowed here.\" ) );\n            }\n            res.push(this._store.sym( ( this._bindings[\"\"] + v[0] ) ));\n            return j;\n        }\n        else {\n            return -1;\n        }\n    };\n    skipSpace(str, i) {\n        /*\n        Skip white space, newlines and comments.\n        return -1 if EOF, else position of first non-ws character*/\n\n        var whitespace = ' \\n\\r\\t\\f\\x0b\\xa0\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u200b\\u2028\\u2029\\u3000';\n        for (var j = (i ? i : 0); j < str.length; j++) {\n            var ch = str.charAt(j);\n            // console.log(\"    skipspace j= \"+j + \" i= \" + i + \" n= \" + str.length);\n            // console.log(\" skipspace ch <\" + ch + \">\");\n            if (whitespace.indexOf(ch) < 0 ) { //not ws\n                // console.log(\" skipspace 2 ch <\" + ch + \">\");\n                if( str.charAt(j)==='#' ) {\n                    for (;; j++) {\n                        // console.log(\"    skipspace2 j= \"+j + \" i= \" + i + \" n= \" + str.length);\n                        if (j === str.length) {\n                            return -1; // EOF\n                        }\n                        if (str.charAt(j) === '\\n') {\n                            this.lines = this.lines + 1;\n                            break;\n                        }\n                    };\n                } else { // Not hash - something interesting\n                    // console.log(\" skipspace 3 ch <\" + ch + \">\");\n                    return j\n                }\n            } else { // Whitespace\n                // console.log(\" skipspace 5 ch <\" + ch + \">\");\n                if (str.charAt(j) === '\\n') {\n                    this.lines = this.lines + 1;\n                }\n            }\n        } // next j\n        return -1; // EOF\n    };\n\n    variable(str, i, res) {\n        /*\n        ?abc -> variable(:abc)\n        */\n\n        var j = this.skipSpace(str, i);\n        if ((j < 0)) {\n            return -1;\n        }\n        if ((str.slice( j,  ( j + 1 ) ) != \"?\")) {\n            return -1;\n        }\n        var j =  ( j + 1 ) ;\n        var i = j;\n        if ((\"0123456789-\".indexOf(str.charAt(j)) >= 0)) {\n            throw BadSyntax(this._thisDoc, this.lines, str, j,  (  ( \"Varible name can't start with '\" + str.charAt(j) )  + \"s'\" ) );\n            return -1;\n        }\n        while ((i < pyjslib_len(str)) && (_notNameChars.indexOf(str.charAt(i)) < 0)) {\n            var i =  ( i + 1 ) ;\n        }\n        if ((this._parentContext == null)) {\n            throw BadSyntax(this._thisDoc, this.lines, str, j,  ( \"Can't use ?xxx syntax for variable in outermost level: \" + str.slice(  ( j - 1 ) , i) ) );\n        }\n        res.push(this._store.variable(str.slice( j, i)));\n        return i;\n    };\n    bareWord(str, i, res) {\n        /*\n        abc -> :abc\n        */\n\n        var j = this.skipSpace(str, i);\n        if ((j < 0)) {\n            return -1;\n        }\n        var ch = str.charAt(j);\n        if ((\"0123456789-\".indexOf(ch) >= 0)) {\n            return -1;\n        }\n        if ((_notNameChars.indexOf(ch) >= 0)) {\n            return -1;\n        }\n        var i = j;\n        while ((i < pyjslib_len(str)) && (_notNameChars.indexOf(str.charAt(i)) < 0)) {\n            var i =  ( i + 1 ) ;\n        }\n        res.push(str.slice( j, i));\n        return i;\n    };\n    qname(str, i, res) {\n        /*\n\n        xyz:def -> ('xyz', 'def')\n        If not in keywords and keywordsSet: def -> ('', 'def')\n        :def -> ('', 'def')\n        */\n\n        var i = this.skipSpace(str, i);\n        if ((i < 0)) {\n            return -1;\n        }\n        var c = str.charAt(i);\n        if ((\"0123456789-+\".indexOf(c) >= 0)) {\n            return -1;\n        }\n        if ((_notNameChars.indexOf(c) < 0)) {\n            var ln = c;\n            var i =  ( i + 1 ) ;\n            while ((i < pyjslib_len(str))) {\n                var c = str.charAt(i);\n                if ((_notNameChars.indexOf(c) < 0)) {\n                    var ln =  ( ln + c ) ;\n                    var i =  ( i + 1 ) ;\n                }\n                else {\n                    break;\n                }\n            }\n        }\n        else {\n            var ln = \"\";\n        }\n        if ((i < pyjslib_len(str)) && (str.charAt(i) == \":\")) {\n            var pfx = ln;\n            var i =  ( i + 1 ) ;\n            var ln = \"\";\n            while ((i < pyjslib_len(str))) {\n                var c = str.charAt(i);\n                if ((_notNameChars.indexOf(c) < 0)) {\n                    var ln =  ( ln + c ) ;\n                    var i =  ( i + 1 ) ;\n                }\n                else {\n                    break;\n                }\n            }\n            res.push(new pyjslib_Tuple([pfx, ln]));\n            return i;\n        }\n        else {\n            if (ln && this.keywordsSet && (ArrayIndexOf(this.keywords, ln) < 0)) {\n                res.push(new pyjslib_Tuple([\"\", ln]));\n                return i;\n            }\n            return -1;\n        }\n    };\n    object(str, i, res) {\n        var j = this.subject(str, i, res);\n        if ((j >= 0)) {\n            return j;\n        }\n        else {\n            var j = this.skipSpace(str, i);\n            if ((j < 0)) {\n                return -1;\n            }\n            else {\n                var i = j;\n            }\n            var delim = null\n            let ch = str.charAt(i)\n            if ((ch == \"\\\"\" || ch == \"'\")) {\n                if (str.slice(i,  ( i + 3 ) == ch + ch)) {\n                    delim = ch + ch + ch;\n                }\n                else {\n                    delim = ch;\n                }\n                var i =  ( i + pyjslib_len(delim) ) ;\n                var pairFudge = this.strconst(str, i, delim);\n                var j = pairFudge[0];\n                var s = pairFudge[1];\n                res.push(this._store.literal(s));\n                diag_progress(\"New string const \", s, j);\n                return j;\n            }\n            else {\n                return -1;\n            }\n        }\n    };\n    nodeOrLiteral(str, i, res) {\n        var j = this.node(str, i, res);\n        if ((j >= 0)) {\n            return j;\n        }\n        else {\n            var j = this.skipSpace(str, i);\n            if ((j < 0)) {\n                return -1;\n            }\n            else {\n                var i = j;\n            }\n            var ch = str.charAt(i);\n            if ((\"-+0987654321\".indexOf(ch) >= 0)) {\n\n                datetime_syntax.lastIndex = 0;\n                var m = datetime_syntax.exec(str.slice(i));\n                if ((m != null)) {\n                    // j =  ( i + datetime_syntax.lastIndex ) ;\n                    var val = m[0];\n                    j = i + val.length;\n                    if ((val.indexOf(\"T\") >= 0)) {\n                        res.push(this._store.literal(val, this._store.sym(DATETIME_DATATYPE)));\n                    } else {\n                        res.push(this._store.literal(val, this._store.sym(DATE_DATATYPE)));\n                    }\n\n                } else {\n                    number_syntax.lastIndex = 0;\n                    var m = number_syntax.exec(str.slice(i));\n                    if ((m == null)) {\n                        throw BadSyntax(this._thisDoc, this.lines, str, i, \"Bad number or date syntax\");\n                    }\n                    j =  ( i + number_syntax.lastIndex ) ;\n                    var val = str.slice( i, j);\n                    if ((val.indexOf(\"e\") >= 0)) {\n                        res.push(this._store.literal(parseFloat(val), this._store.sym(FLOAT_DATATYPE)));\n                    }\n                    else if ((str.slice( i, j).indexOf(\".\") >= 0)) {\n                        res.push(this._store.literal(parseFloat(val), this._store.sym(DECIMAL_DATATYPE)));\n                    }\n                    else {\n                        res.push(this._store.literal(parseInt(val), this._store.sym(INTEGER_DATATYPE)));\n                    }\n                };\n                return j; // Where we have got up to\n            }\n            if ((str.charAt(i) == \"\\\"\")) {\n                if ((str.slice( i,  ( i + 3 ) ) == \"\\\"\\\"\\\"\")) {\n                    var delim = \"\\\"\\\"\\\"\";\n                }\n                else {\n                    var delim = \"\\\"\";\n                }\n                var i =  ( i + pyjslib_len(delim) ) ;\n                var dt = null;\n                var pairFudge = this.strconst(str, i, delim);\n                var j = pairFudge[0];\n                var s = pairFudge[1];\n                var lang = null;\n                if ((str.slice( j,  ( j + 1 ) ) == \"@\")) {\n                    langcode.lastIndex = 0;\n\n                    var m = langcode.exec(str.slice( ( j + 1 ) ));\n                    if ((m == null)) {\n                        throw BadSyntax(this._thisDoc, startline, str, i, \"Bad language code syntax on string literal, after @\");\n                    }\n                    var i =  (  ( langcode.lastIndex + j )  + 1 ) ;\n\n                    var lang = str.slice(  ( j + 1 ) , i);\n                    var j = i;\n                }\n                if ((str.slice( j,  ( j + 2 ) ) == \"^^\")) {\n                    var res2 = new pyjslib_List([]);\n                    var j = this.uri_ref2(str,  ( j + 2 ) , res2);\n                    var dt = res2[0];\n                }\n                res.push(this._store.literal(s, lang || dt));\n                return j;\n            }\n            else {\n                return -1;\n            }\n        }\n    };\n    strconst(str, i, delim) {\n        /*\n        parse an N3 string constant delimited by delim.\n        return index, val\n        */\n\n        var j = i;\n        var ustr = \"\";\n        var startline = this.lines;\n        while ((j < pyjslib_len(str))) {\n            var i =  ( j + pyjslib_len(delim) ) ;\n            if ((str.slice( j, i) == delim)) {\n                return new pyjslib_Tuple([i, ustr]);\n            }\n            if ((str.charAt(j) == \"\\\"\")) {\n                var ustr =  ( ustr + \"\\\"\" ) ;\n                var j =  ( j + 1 ) ;\n                continue;\n            }\n            interesting.lastIndex = 0;\n            var m = interesting.exec(str.slice(j));\n            if (!(m)) {\n                throw BadSyntax(this._thisDoc, startline, str, j,  (  (  ( \"Closing quote missing in string at ^ in \" + str.slice(  ( j - 20 ) , j) )  + \"^\" )  + str.slice( j,  ( j + 20 ) ) ) );\n            }\n            var i =  (  ( j + interesting.lastIndex )  - 1 ) ;\n            var ustr =  ( ustr + str.slice( j, i) ) ;\n            var ch = str.charAt(i);\n            if ((ch == \"\\\"\")) {\n                var j = i;\n                continue;\n            }\n            else if ((ch == \"\\r\")) {\n                var j =  ( i + 1 ) ;\n                continue;\n            }\n            else if ((ch == \"\\n\")) {\n                if ((delim == \"\\\"\")) {\n                    throw BadSyntax(this._thisDoc, startline, str, i, \"newline found in string literal\");\n                }\n                this.lines =  ( this.lines + 1 ) ;\n                var ustr =  ( ustr + ch ) ;\n                var j =  ( i + 1 ) ;\n                this.previousLine = this.startOfLine;\n                this.startOfLine = j;\n            }\n            else if ((ch == \"\\\\\")) {\n                var j =  ( i + 1 ) ;\n                var ch = str.slice( j,  ( j + 1 ) );\n                if (!(ch)) {\n                    throw BadSyntax(this._thisDoc, startline, str, i, \"unterminated string literal (2)\");\n                }\n                var k = string_find(\"abfrtvn\\\\\\\"\", ch);\n                if ((k >= 0)) {\n                    var uch = \"\\a\\b\\f\\r\\t\\v\\n\\\\\\\"\".charAt(k);\n                    var ustr =  ( ustr + uch ) ;\n                    var j =  ( j + 1 ) ;\n                }\n                else if ((ch == \"u\")) {\n                    var pairFudge = this.uEscape(str,  ( j + 1 ) , startline);\n                    var j = pairFudge[0];\n                    var ch = pairFudge[1];\n                    var ustr =  ( ustr + ch ) ;\n                }\n                else if ((ch == \"U\")) {\n                    var pairFudge = this.UEscape(str,  ( j + 1 ) , startline);\n                    var j = pairFudge[0];\n                    var ch = pairFudge[1];\n                    var ustr =  ( ustr + ch ) ;\n                }\n                else {\n                    throw BadSyntax(this._thisDoc, this.lines, str, i, \"bad escape\");\n                }\n            }\n        }\n        throw BadSyntax(this._thisDoc, this.lines, str, i, \"unterminated string literal\");\n    };\n    uEscape(str, i, startline) {\n        var j = i;\n        var count = 0;\n        var value = 0;\n        while ((count < 4)) {\n            var chFudge = str.slice( j,  ( j + 1 ) );\n            var ch = chFudge.toLowerCase();\n            var j =  ( j + 1 ) ;\n            if ((ch == \"\")) {\n                throw BadSyntax(this._thisDoc, startline, str, i, \"unterminated string literal(3)\");\n            }\n            var k = string_find(\"0123456789abcdef\", ch);\n            if ((k < 0)) {\n                throw BadSyntax(this._thisDoc, startline, str, i, \"bad string literal hex escape\");\n            }\n            var value =  (  ( value * 16 )  + k ) ;\n            var count =  ( count + 1 ) ;\n        }\n        var uch = String.fromCharCode(value);\n        return new pyjslib_Tuple([j, uch]);\n    };\n    UEscape(str, i, startline) {\n        var j = i;\n        var count = 0;\n        var value = \"\\\\U\";\n        while ((count < 8)) {\n            var chFudge = str.slice( j,  ( j + 1 ) );\n            var ch = chFudge.toLowerCase();\n            var j =  ( j + 1 ) ;\n            if ((ch == \"\")) {\n                throw BadSyntax(this._thisDoc, startline, str, i, \"unterminated string literal(3)\");\n            }\n            var k = string_find(\"0123456789abcdef\", ch);\n            if ((k < 0)) {\n                throw BadSyntax(this._thisDoc, startline, str, i, \"bad string literal hex escape\");\n            }\n            var value =  ( value + ch ) ;\n            var count =  ( count + 1 ) ;\n        }\n        var uch = stringFromCharCode( (  ( \"0x\" + pyjslib_slice(value, 2, 10) )  - 0 ) );\n        return new pyjslib_Tuple([j, uch]);\n    };\n}\n\nfunction OLD_BadSyntax(uri, lines, str, i, why) {\n    return new __OLD_BadSyntax(uri, lines, str, i, why);\n}\nfunction __OLD_BadSyntax(uri, lines, str, i, why) {\n    this._str = str.encode(\"utf-8\");\n    this._str = str;\n    this._i = i;\n    this._why = why;\n    this.lines = lines;\n    this._uri = uri;\n}\n__OLD_BadSyntax.prototype.toString = function() {\n    var str = this._str;\n    var i = this._i;\n    var st = 0;\n    if ((i > 60)) {\n        var pre = \"...\";\n        var st =  ( i - 60 ) ;\n    }\n    else {\n        var pre = \"\";\n    }\n    if (( ( pyjslib_len(str) - i )  > 60)) {\n        var post = \"...\";\n    }\n    else {\n        var post = \"\";\n    }\n    return \"Line %i of <%s>: Bad syntax (%s) at ^ in:\\n\\\"%s%s^%s%s\\\"\" % new pyjslib_Tuple([ ( this.lines + 1 ) , this._uri, this._why, pre, str.slice( st, i), str.slice( i,  ( i + 60 ) ), post]);\n}\n\nfunction BadSyntax(uri, lines, str, i, why) {\n    let lineNo = lines + 1\n    let msg =  (  (  (  (  (  (  (  ( \"Line \" +  ( lineNo )  )  + \" of <\" )  + uri )  + \">: Bad syntax: \" )  + why )  + \"\\nat: \\\"\" )  + str.slice( i,  ( i + 30 ) ) )  + \"\\\"\" ) ;\n    let e = new SyntaxError(msg, uri , lineNo)\n    e.lineNo = lineNo\n    e.characterInFile = i\n    e.syntaxProblem = why\n    return e\n}\n\nfunction stripCR(str) {\n    var res = \"\";\n\n    var __ch = new pyjslib_Iterator(str);\n    try {\n        while (true) {\n            var ch = __ch.next();\n\n\n            if ((ch != \"\\r\")) {\n                var res =  ( res + ch ) ;\n            }\n\n        }\n    } catch (e) {\n        if (e != StopIteration) {\n            throw e;\n        }\n    }\n\n    return res;\n}\n\n\nfunction dummyWrite(x) {\n}\n","import Collection from '../collection'\nimport CanonicalDataFactory from './canonical-data-factory'\nimport { ValueType, CollectionTermType } from '../types'\nimport { DataFactory, DefaultFactoryTypes, Feature, Indexable } from './factory-types'\nimport { isCollection, isVariable } from '../utils/terms'\nimport Variable from '../variable'\nimport { Term } from '../tf-types'\n\ninterface CollectionFactory extends DataFactory {\n  collection(elements: ReadonlyArray<ValueType>): Collection\n}\n\n/**\n * Data factory which also supports Collections\n *\n * Necessary for preventing circular dependencies.\n */\nconst ExtendedTermFactory: CollectionFactory = {\n  ...CanonicalDataFactory,\n\n  supports: {\n    [Feature.collections]: true,\n    [Feature.defaultGraphType]: false,\n    [Feature.equalsMethod]: true,\n    [Feature.identity]: false,\n    [Feature.id]: true,\n    [Feature.reversibleId]: false,\n    [Feature.variableType]: true,\n  },\n\n  /**\n   * Creates a new collection\n   * @param elements - The initial element\n   */\n  collection (elements: ReadonlyArray<ValueType>): Collection {\n    return new Collection(elements)\n  },\n\n  id (term: Term | DefaultFactoryTypes): Indexable {\n    if (isCollection(term)) {\n      return `( ${term.elements.map((e) => {\n        return this.id(e) }).join(', ')} )`\n    }\n\n    if (isVariable(term)) {\n      return Variable.toString(term)\n    }\n\n    return CanonicalDataFactory.id(term)\n  },\n\n  termToNQ (term: Term): string {\n    if (term.termType === CollectionTermType) {\n      return Collection.toNT(term)\n    }\n\n    return CanonicalDataFactory.termToNQ(term)\n  }\n}\n\nexport default ExtendedTermFactory\n","import { arrayToStatements } from './utils'\n\n/**\n * Parses json-ld formatted JS objects to a rdf Term.\n * @param kb - The DataFactory to use.\n * @param obj - The json-ld object to process.\n * @return {Literal|NamedNode|BlankNode|Collection}\n */\nexport function jsonldObjectToTerm (kb, obj) {\n  if (typeof obj === 'string') {\n    return kb.rdfFactory.literal(obj)\n  }\n\n  if (Object.prototype.hasOwnProperty.call(obj, '@list')) {\n    if (kb.rdfFactory.supports[\"COLLECTIONS\"] === true) {\n      return listToCollection(kb, obj['@list'])\n    }\n\n    return listToStatements(kb, obj)\n  }\n\n  if (Object.prototype.hasOwnProperty.call(obj, '@id')) {\n    return nodeType(kb, obj)\n  }\n\n  if (Object.prototype.hasOwnProperty.call(obj, '@language')) {\n    return kb.rdfFactory.literal(obj['@value'], obj['@language'])\n  }\n\n  if (Object.prototype.hasOwnProperty.call(obj, '@type')) {\n    return kb.rdfFactory.literal(obj['@value'], kb.rdfFactory.namedNode(obj['@type']))\n  }\n\n  if (Object.prototype.hasOwnProperty.call(obj, '@value')) {\n    return kb.rdfFactory.literal(obj['@value'])\n  }\n\n  return kb.rdfFactory.literal(obj)\n}\n\n/**\n * Adds the statements in a json-ld list object to {kb}.\n */\nfunction listToStatements (kb, obj) {\n  const listId = obj['@id'] ? nodeType(kb, obj) : kb.rdfFactory.blankNode()\n\n  const items = obj['@list'].map((listItem => jsonldObjectToTerm(kb, listItem)))\n  const statements = arrayToStatements(kb.rdfFactory, listId, items)\n  kb.addAll(statements)\n\n  return listId\n}\n\nfunction listToCollection (kb, obj) {\n  if (!Array.isArray(obj)) {\n    throw new TypeError(\"Object must be an array\")\n  }\n  return kb.rdfFactory.collection(obj.map((o) => jsonldObjectToTerm(kb, o)))\n}\n\n/**\n * Takes a json-ld formatted string {str} and adds its statements to {kb}.\n *\n * Ensure that {kb.rdfFactory} is a DataFactory.\n */\nexport default function jsonldParser (str, kb, base, callback) {\n  const baseString = base && Object.prototype.hasOwnProperty.call(base, 'termType')\n    ? base.value\n    : base\n\n  return import('jsonld')\n    .then(jsonld => { return jsonld.flatten(JSON.parse(str), null, { base: baseString }) })\n    .then((flattened) => flattened.reduce((store, flatResource) => {\n\n      kb = processResource(kb, base, flatResource)\n\n      return kb\n    }, kb))\n    .then(callback)\n    .catch(callback)\n}\n\nfunction nodeType (kb, obj) {\n  if (obj['@id'].startsWith('_:')) {\n    // This object is a Blank Node. Pass the id without the `_:` prefix\n    return kb.rdfFactory.blankNode(obj['@id'].substring(2));\n  } else {\n    // This object is a Named Node\n    return kb.rdfFactory.namedNode(obj['@id']);\n  }\n}\n\nfunction processResource(kb, base, flatResource) {\n  const id = flatResource['@id']\n    ? nodeType(kb, flatResource)\n    : kb.rdfFactory.blankNode()\n\n  for (const property of Object.keys(flatResource)) {\n    if (property === '@id') {\n      continue\n    } else if (property == '@graph') {\n      // the JSON-LD flattened structure may contain nested graphs\n      // the id value for this object is the new base (named graph id) for all nested flat resources\n      const graphId = id\n      // this is an array of resources\n      const nestedFlatResources = flatResource[property]\n\n      // recursively process all flat resources in the array, but with the graphId as base.\n      for (let i = 0; i < nestedFlatResources.length; i++ ) {\n        kb = processResource(kb, graphId, nestedFlatResources[i])\n      }\n    }\n\n    const value = flatResource[property]\n    if (Array.isArray(value)) {\n      for (let i = 0; i < value.length; i++) {\n        kb.addStatement(createStatement(kb, id, property, value[i], base))\n      }\n    } else {\n      kb.addStatement(createStatement(kb, id, property, value, base))\n    }\n  }\n\n  return kb\n}\n\n/**\n * Create statement quad depending on @type being a type node\n * @param kb\n * @param subject id\n * @param property\n * @param value\n * @return quad statement\n */\nfunction createStatement(kb, id, property, value, base) {\n  let predicate, object\n\n  if (property === \"@type\") {\n    predicate = kb.rdfFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#type\")\n    object = kb.rdfFactory.namedNode(value)\n  } else {\n    predicate = kb.rdfFactory.namedNode(property)\n    object = jsonldObjectToTerm(kb, value)\n  }\n  return kb.rdfFactory.quad(id, predicate, object, kb.rdfFactory.namedNode(base))\n}","const RDF  = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',\n    XSD  = 'http://www.w3.org/2001/XMLSchema#',\n    SWAP = 'http://www.w3.org/2000/10/swap/';\n\nexport default {\n  xsd: {\n    decimal: `${XSD}decimal`,\n    boolean: `${XSD}boolean`,\n    double:  `${XSD}double`,\n    integer: `${XSD}integer`,\n    string:  `${XSD}string`,\n  },\n  rdf: {\n    type:       `${RDF}type`,\n    nil:        `${RDF}nil`,\n    first:      `${RDF}first`,\n    rest:       `${RDF}rest`,\n    langString: `${RDF}langString`,\n  },\n  owl: {\n    sameAs: 'http://www.w3.org/2002/07/owl#sameAs',\n  },\n  r: {\n    forSome: `${SWAP}reify#forSome`,\n    forAll:  `${SWAP}reify#forAll`,\n  },\n  log: {\n    implies: `${SWAP}log#implies`,\n  },\n};\n","// **N3Lexer** tokenizes N3 documents.\nimport queueMicrotask from 'queue-microtask';\nimport namespaces from './IRIs';\n\nconst { xsd } = namespaces;\n\n// Regular expression and replacement string to escape N3 strings\nconst escapeSequence = /\\\\u([a-fA-F0-9]{4})|\\\\U([a-fA-F0-9]{8})|\\\\([^])/g;\nconst escapeReplacements = {\n  '\\\\': '\\\\', \"'\": \"'\", '\"': '\"',\n  'n': '\\n', 'r': '\\r', 't': '\\t', 'f': '\\f', 'b': '\\b',\n  '_': '_', '~': '~', '.': '.', '-': '-', '!': '!', '$': '$', '&': '&',\n  '(': '(', ')': ')', '*': '*', '+': '+', ',': ',', ';': ';', '=': '=',\n  '/': '/', '?': '?', '#': '#', '@': '@', '%': '%',\n};\nconst illegalIriChars = /[\\x00-\\x20<>\\\\\"\\{\\}\\|\\^\\`]/;\n\nconst lineModeRegExps = {\n  _iri: true,\n  _unescapedIri: true,\n  _simpleQuotedString: true,\n  _langcode: true,\n  _blank: true,\n  _newline: true,\n  _comment: true,\n  _whitespace: true,\n  _endOfFile: true,\n};\nconst invalidRegExp = /$0^/;\n\n// ## Constructor\nexport default class N3Lexer {\n  constructor(options) {\n    // ## Regular expressions\n    // It's slightly faster to have these as properties than as in-scope variables\n    this._iri = /^<((?:[^ <>{}\\\\]|\\\\[uU])+)>[ \\t]*/; // IRI with escape sequences; needs sanity check after unescaping\n    this._unescapedIri = /^<([^\\x00-\\x20<>\\\\\"\\{\\}\\|\\^\\`]*)>[ \\t]*/; // IRI without escape sequences; no unescaping\n    this._simpleQuotedString = /^\"([^\"\\\\\\r\\n]*)\"(?=[^\"])/; // string without escape sequences\n    this._simpleApostropheString = /^'([^'\\\\\\r\\n]*)'(?=[^'])/;\n    this._langcode = /^@([a-z]+(?:-[a-z0-9]+)*)(?=[^a-z0-9\\-])/i;\n    this._prefix = /^((?:[A-Za-z\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02ff\\u0370-\\u037d\\u037f-\\u1fff\\u200c\\u200d\\u2070-\\u218f\\u2c00-\\u2fef\\u3001-\\ud7ff\\uf900-\\ufdcf\\ufdf0-\\ufffd]|[\\ud800-\\udb7f][\\udc00-\\udfff])(?:\\.?[\\-0-9A-Z_a-z\\xb7\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u037d\\u037f-\\u1fff\\u200c\\u200d\\u203f\\u2040\\u2070-\\u218f\\u2c00-\\u2fef\\u3001-\\ud7ff\\uf900-\\ufdcf\\ufdf0-\\ufffd]|[\\ud800-\\udb7f][\\udc00-\\udfff])*)?:(?=[#\\s<])/;\n    this._prefixed = /^((?:[A-Za-z\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02ff\\u0370-\\u037d\\u037f-\\u1fff\\u200c\\u200d\\u2070-\\u218f\\u2c00-\\u2fef\\u3001-\\ud7ff\\uf900-\\ufdcf\\ufdf0-\\ufffd]|[\\ud800-\\udb7f][\\udc00-\\udfff])(?:\\.?[\\-0-9A-Z_a-z\\xb7\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u037d\\u037f-\\u1fff\\u200c\\u200d\\u203f\\u2040\\u2070-\\u218f\\u2c00-\\u2fef\\u3001-\\ud7ff\\uf900-\\ufdcf\\ufdf0-\\ufffd]|[\\ud800-\\udb7f][\\udc00-\\udfff])*)?:((?:(?:[0-:A-Z_a-z\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02ff\\u0370-\\u037d\\u037f-\\u1fff\\u200c\\u200d\\u2070-\\u218f\\u2c00-\\u2fef\\u3001-\\ud7ff\\uf900-\\ufdcf\\ufdf0-\\ufffd]|[\\ud800-\\udb7f][\\udc00-\\udfff]|%[0-9a-fA-F]{2}|\\\\[!#-\\/;=?\\-@_~])(?:(?:[\\.\\-0-:A-Z_a-z\\xb7\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u037d\\u037f-\\u1fff\\u200c\\u200d\\u203f\\u2040\\u2070-\\u218f\\u2c00-\\u2fef\\u3001-\\ud7ff\\uf900-\\ufdcf\\ufdf0-\\ufffd]|[\\ud800-\\udb7f][\\udc00-\\udfff]|%[0-9a-fA-F]{2}|\\\\[!#-\\/;=?\\-@_~])*(?:[\\-0-:A-Z_a-z\\xb7\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u037d\\u037f-\\u1fff\\u200c\\u200d\\u203f\\u2040\\u2070-\\u218f\\u2c00-\\u2fef\\u3001-\\ud7ff\\uf900-\\ufdcf\\ufdf0-\\ufffd]|[\\ud800-\\udb7f][\\udc00-\\udfff]|%[0-9a-fA-F]{2}|\\\\[!#-\\/;=?\\-@_~]))?)?)(?:[ \\t]+|(?=\\.?[,;!\\^\\s#()\\[\\]\\{\\}\"'<>]))/;\n    this._variable = /^\\?(?:(?:[A-Z_a-z\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02ff\\u0370-\\u037d\\u037f-\\u1fff\\u200c\\u200d\\u2070-\\u218f\\u2c00-\\u2fef\\u3001-\\ud7ff\\uf900-\\ufdcf\\ufdf0-\\ufffd]|[\\ud800-\\udb7f][\\udc00-\\udfff])(?:[\\-0-:A-Z_a-z\\xb7\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u037d\\u037f-\\u1fff\\u200c\\u200d\\u203f\\u2040\\u2070-\\u218f\\u2c00-\\u2fef\\u3001-\\ud7ff\\uf900-\\ufdcf\\ufdf0-\\ufffd]|[\\ud800-\\udb7f][\\udc00-\\udfff])*)(?=[.,;!\\^\\s#()\\[\\]\\{\\}\"'<>])/;\n    this._blank = /^_:((?:[0-9A-Z_a-z\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02ff\\u0370-\\u037d\\u037f-\\u1fff\\u200c\\u200d\\u2070-\\u218f\\u2c00-\\u2fef\\u3001-\\ud7ff\\uf900-\\ufdcf\\ufdf0-\\ufffd]|[\\ud800-\\udb7f][\\udc00-\\udfff])(?:\\.?[\\-0-9A-Z_a-z\\xb7\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u037d\\u037f-\\u1fff\\u200c\\u200d\\u203f\\u2040\\u2070-\\u218f\\u2c00-\\u2fef\\u3001-\\ud7ff\\uf900-\\ufdcf\\ufdf0-\\ufffd]|[\\ud800-\\udb7f][\\udc00-\\udfff])*)(?:[ \\t]+|(?=\\.?[,;:\\s#()\\[\\]\\{\\}\"'<>]))/;\n    this._number = /^[\\-+]?(?:(\\d+\\.\\d*|\\.?\\d+)[eE][\\-+]?|\\d*(\\.)?)\\d+(?=\\.?[,;:\\s#()\\[\\]\\{\\}\"'<>])/;\n    this._boolean = /^(?:true|false)(?=[.,;\\s#()\\[\\]\\{\\}\"'<>])/;\n    this._keyword = /^@[a-z]+(?=[\\s#<:])/i;\n    this._sparqlKeyword = /^(?:PREFIX|BASE|GRAPH)(?=[\\s#<])/i;\n    this._shortPredicates = /^a(?=[\\s#()\\[\\]\\{\\}\"'<>])/;\n    this._newline = /^[ \\t]*(?:#[^\\n\\r]*)?(?:\\r\\n|\\n|\\r)[ \\t]*/;\n    this._comment = /#([^\\n\\r]*)/;\n    this._whitespace = /^[ \\t]+/;\n    this._endOfFile = /^(?:#[^\\n\\r]*)?$/;\n    options = options || {};\n\n    // In line mode (N-Triples or N-Quads), only simple features may be parsed\n    if (this._lineMode = !!options.lineMode) {\n      this._n3Mode = false;\n      // Don't tokenize special literals\n      for (const key in this) {\n        if (!(key in lineModeRegExps) && this[key] instanceof RegExp)\n          this[key] = invalidRegExp;\n      }\n    }\n    // When not in line mode, enable N3 functionality by default\n    else {\n      this._n3Mode = options.n3 !== false;\n    }\n    // Don't output comment tokens by default\n    this._comments = !!options.comments;\n    // Cache the last tested closing position of long literals\n    this._literalClosingPos = 0;\n  }\n\n  // ## Private methods\n\n  // ### `_tokenizeToEnd` tokenizes as for as possible, emitting tokens through the callback\n  _tokenizeToEnd(callback, inputFinished) {\n    // Continue parsing as far as possible; the loop will return eventually\n    let input = this._input;\n    let currentLineLength = input.length;\n    while (true) {\n      // Count and skip whitespace lines\n      let whiteSpaceMatch, comment;\n      while (whiteSpaceMatch = this._newline.exec(input)) {\n        // Try to find a comment\n        if (this._comments && (comment = this._comment.exec(whiteSpaceMatch[0])))\n          emitToken('comment', comment[1], '', this._line, whiteSpaceMatch[0].length);\n        // Advance the input\n        input = input.substr(whiteSpaceMatch[0].length, input.length);\n        currentLineLength = input.length;\n        this._line++;\n      }\n      // Skip whitespace on current line\n      if (!whiteSpaceMatch && (whiteSpaceMatch = this._whitespace.exec(input)))\n        input = input.substr(whiteSpaceMatch[0].length, input.length);\n\n      // Stop for now if we're at the end\n      if (this._endOfFile.test(input)) {\n        // If the input is finished, emit EOF\n        if (inputFinished) {\n          // Try to find a final comment\n          if (this._comments && (comment = this._comment.exec(input)))\n            emitToken('comment', comment[1], '', this._line, input.length);\n          input = null;\n          emitToken('eof', '', '', this._line, 0);\n        }\n        return this._input = input;\n      }\n\n      // Look for specific token types based on the first character\n      const line = this._line, firstChar = input[0];\n      let type = '', value = '', prefix = '',\n          match = null, matchLength = 0, inconclusive = false;\n      switch (firstChar) {\n      case '^':\n        // We need at least 3 tokens lookahead to distinguish ^^<IRI> and ^^pre:fixed\n        if (input.length < 3)\n          break;\n        // Try to match a type\n        else if (input[1] === '^') {\n          this._previousMarker = '^^';\n          // Move to type IRI or prefixed name\n          input = input.substr(2);\n          if (input[0] !== '<') {\n            inconclusive = true;\n            break;\n          }\n        }\n        // If no type, it must be a path expression\n        else {\n          if (this._n3Mode) {\n            matchLength = 1;\n            type = '^';\n          }\n          break;\n        }\n        // Fall through in case the type is an IRI\n      case '<':\n        // Try to find a full IRI without escape sequences\n        if (match = this._unescapedIri.exec(input))\n          type = 'IRI', value = match[1];\n        // Try to find a full IRI with escape sequences\n        else if (match = this._iri.exec(input)) {\n          value = this._unescape(match[1]);\n          if (value === null || illegalIriChars.test(value))\n            return reportSyntaxError(this);\n          type = 'IRI';\n        }\n        // Try to find a nested triple\n        else if (input.length > 1 && input[1] === '<')\n          type = '<<', matchLength = 2;\n        // Try to find a backwards implication arrow\n        else if (this._n3Mode && input.length > 1 && input[1] === '=')\n          type = 'inverse', matchLength = 2, value = '>';\n        break;\n\n      case '>':\n        if (input.length > 1 && input[1] === '>')\n          type = '>>', matchLength = 2;\n        break;\n\n      case '_':\n        // Try to find a blank node. Since it can contain (but not end with) a dot,\n        // we always need a non-dot character before deciding it is a blank node.\n        // Therefore, try inserting a space if we're at the end of the input.\n        if ((match = this._blank.exec(input)) ||\n            inputFinished && (match = this._blank.exec(`${input} `)))\n          type = 'blank', prefix = '_', value = match[1];\n        break;\n\n      case '\"':\n        // Try to find a literal without escape sequences\n        if (match = this._simpleQuotedString.exec(input))\n          value = match[1];\n        // Try to find a literal wrapped in three pairs of quotes\n        else {\n          ({ value, matchLength } = this._parseLiteral(input));\n          if (value === null)\n            return reportSyntaxError(this);\n        }\n        if (match !== null || matchLength !== 0) {\n          type = 'literal';\n          this._literalClosingPos = 0;\n        }\n        break;\n\n      case \"'\":\n        if (!this._lineMode) {\n          // Try to find a literal without escape sequences\n          if (match = this._simpleApostropheString.exec(input))\n            value = match[1];\n          // Try to find a literal wrapped in three pairs of quotes\n          else {\n            ({ value, matchLength } = this._parseLiteral(input));\n            if (value === null)\n              return reportSyntaxError(this);\n          }\n          if (match !== null || matchLength !== 0) {\n            type = 'literal';\n            this._literalClosingPos = 0;\n          }\n        }\n        break;\n\n      case '?':\n        // Try to find a variable\n        if (this._n3Mode && (match = this._variable.exec(input)))\n          type = 'var', value = match[0];\n        break;\n\n      case '@':\n        // Try to find a language code\n        if (this._previousMarker === 'literal' && (match = this._langcode.exec(input)))\n          type = 'langcode', value = match[1];\n        // Try to find a keyword\n        else if (match = this._keyword.exec(input))\n          type = match[0];\n        break;\n\n      case '.':\n        // Try to find a dot as punctuation\n        if (input.length === 1 ? inputFinished : (input[1] < '0' || input[1] > '9')) {\n          type = '.';\n          matchLength = 1;\n          break;\n        }\n        // Fall through to numerical case (could be a decimal dot)\n\n      case '0':\n      case '1':\n      case '2':\n      case '3':\n      case '4':\n      case '5':\n      case '6':\n      case '7':\n      case '8':\n      case '9':\n      case '+':\n      case '-':\n        // Try to find a number. Since it can contain (but not end with) a dot,\n        // we always need a non-dot character before deciding it is a number.\n        // Therefore, try inserting a space if we're at the end of the input.\n        if (match = this._number.exec(input) ||\n            inputFinished && (match = this._number.exec(`${input} `))) {\n          type = 'literal', value = match[0];\n          prefix = (typeof match[1] === 'string' ? xsd.double :\n                    (typeof match[2] === 'string' ? xsd.decimal : xsd.integer));\n        }\n        break;\n\n      case 'B':\n      case 'b':\n      case 'p':\n      case 'P':\n      case 'G':\n      case 'g':\n        // Try to find a SPARQL-style keyword\n        if (match = this._sparqlKeyword.exec(input))\n          type = match[0].toUpperCase();\n        else\n          inconclusive = true;\n        break;\n\n      case 'f':\n      case 't':\n        // Try to match a boolean\n        if (match = this._boolean.exec(input))\n          type = 'literal', value = match[0], prefix = xsd.boolean;\n        else\n          inconclusive = true;\n        break;\n\n      case 'a':\n        // Try to find an abbreviated predicate\n        if (match = this._shortPredicates.exec(input))\n          type = 'abbreviation', value = 'a';\n        else\n          inconclusive = true;\n        break;\n\n      case '=':\n        // Try to find an implication arrow or equals sign\n        if (this._n3Mode && input.length > 1) {\n          type = 'abbreviation';\n          if (input[1] !== '>')\n            matchLength = 1, value = '=';\n          else\n            matchLength = 2, value = '>';\n        }\n        break;\n\n      case '!':\n        if (!this._n3Mode)\n          break;\n      case ',':\n      case ';':\n      case '[':\n      case ']':\n      case '(':\n      case ')':\n      case '}':\n        if (!this._lineMode) {\n          matchLength = 1;\n          type = firstChar;\n        }\n        break;\n      case '{':\n        // We need at least 2 tokens lookahead to distinguish \"{|\" and \"{ \"\n        if (!this._lineMode && input.length >= 2) {\n          // Try to find a quoted triple annotation start\n          if (input[1] === '|')\n            type = '{|', matchLength = 2;\n          else\n            type = firstChar, matchLength = 1;\n        }\n        break;\n      case '|':\n        // We need 2 tokens lookahead to parse \"|}\"\n        // Try to find a quoted triple annotation end\n        if (input.length >= 2 && input[1] === '}')\n          type = '|}', matchLength = 2;\n        break;\n\n      default:\n        inconclusive = true;\n      }\n\n      // Some first characters do not allow an immediate decision, so inspect more\n      if (inconclusive) {\n        // Try to find a prefix\n        if ((this._previousMarker === '@prefix' || this._previousMarker === 'PREFIX') &&\n            (match = this._prefix.exec(input)))\n          type = 'prefix', value = match[1] || '';\n        // Try to find a prefixed name. Since it can contain (but not end with) a dot,\n        // we always need a non-dot character before deciding it is a prefixed name.\n        // Therefore, try inserting a space if we're at the end of the input.\n        else if ((match = this._prefixed.exec(input)) ||\n                 inputFinished && (match = this._prefixed.exec(`${input} `)))\n          type = 'prefixed', prefix = match[1] || '', value = this._unescape(match[2]);\n      }\n\n      // A type token is special: it can only be emitted after an IRI or prefixed name is read\n      if (this._previousMarker === '^^') {\n        switch (type) {\n        case 'prefixed': type = 'type';    break;\n        case 'IRI':      type = 'typeIRI'; break;\n        default:         type = '';\n        }\n      }\n\n      // What if nothing of the above was found?\n      if (!type) {\n        // We could be in streaming mode, and then we just wait for more input to arrive.\n        // Otherwise, a syntax error has occurred in the input.\n        // One exception: error on an unaccounted linebreak (= not inside a triple-quoted literal).\n        if (inputFinished || (!/^'''|^\"\"\"/.test(input) && /\\n|\\r/.test(input)))\n          return reportSyntaxError(this);\n        else\n          return this._input = input;\n      }\n\n      // Emit the parsed token\n      const length = matchLength || match[0].length;\n      const token = emitToken(type, value, prefix, line, length);\n      this.previousToken = token;\n      this._previousMarker = type;\n\n      // Advance to next part to tokenize\n      input = input.substr(length, input.length);\n    }\n\n    // Emits the token through the callback\n    function emitToken(type, value, prefix, line, length) {\n      const start = input ? currentLineLength - input.length : currentLineLength;\n      const end = start + length;\n      const token = { type, value, prefix, line, start, end };\n      callback(null, token);\n      return token;\n    }\n    // Signals the syntax error through the callback\n    function reportSyntaxError(self) { callback(self._syntaxError(/^\\S*/.exec(input)[0])); }\n  }\n\n  // ### `_unescape` replaces N3 escape codes by their corresponding characters\n  _unescape(item) {\n    let invalid = false;\n    const replaced = item.replace(escapeSequence, (sequence, unicode4, unicode8, escapedChar) => {\n      // 4-digit unicode character\n      if (typeof unicode4 === 'string')\n        return String.fromCharCode(Number.parseInt(unicode4, 16));\n      // 8-digit unicode character\n      if (typeof unicode8 === 'string') {\n        let charCode = Number.parseInt(unicode8, 16);\n        return charCode <= 0xFFFF ? String.fromCharCode(Number.parseInt(unicode8, 16)) :\n          String.fromCharCode(0xD800 + ((charCode -= 0x10000) >> 10), 0xDC00 + (charCode & 0x3FF));\n      }\n      // fixed escape sequence\n      if (escapedChar in escapeReplacements)\n        return escapeReplacements[escapedChar];\n      // invalid escape sequence\n      invalid = true;\n      return '';\n    });\n    return invalid ? null : replaced;\n  }\n\n  // ### `_parseLiteral` parses a literal into an unescaped value\n  _parseLiteral(input) {\n    // Ensure we have enough lookahead to identify triple-quoted strings\n    if (input.length >= 3) {\n      // Identify the opening quote(s)\n      const opening = input.match(/^(?:\"\"\"|\"|'''|'|)/)[0];\n      const openingLength = opening.length;\n\n      // Find the next candidate closing quotes\n      let closingPos = Math.max(this._literalClosingPos, openingLength);\n      while ((closingPos = input.indexOf(opening, closingPos)) > 0) {\n        // Count backslashes right before the closing quotes\n        let backslashCount = 0;\n        while (input[closingPos - backslashCount - 1] === '\\\\')\n          backslashCount++;\n\n        // An even number of backslashes (in particular 0)\n        // means these are actual, non-escaped closing quotes\n        if (backslashCount % 2 === 0) {\n          // Extract and unescape the value\n          const raw = input.substring(openingLength, closingPos);\n          const lines = raw.split(/\\r\\n|\\r|\\n/).length - 1;\n          const matchLength = closingPos + openingLength;\n          // Only triple-quoted strings can be multi-line\n          if (openingLength === 1 && lines !== 0 ||\n              openingLength === 3 && this._lineMode)\n            break;\n          this._line += lines;\n          return { value: this._unescape(raw), matchLength };\n        }\n        closingPos++;\n      }\n      this._literalClosingPos = input.length - openingLength + 1;\n    }\n    return { value: '', matchLength: 0 };\n  }\n\n  // ### `_syntaxError` creates a syntax error for the given issue\n  _syntaxError(issue) {\n    this._input = null;\n    const err = new Error(`Unexpected \"${issue}\" on line ${this._line}.`);\n    err.context = {\n      token: undefined,\n      line: this._line,\n      previousToken: this.previousToken,\n    };\n    return err;\n  }\n\n  // ### Strips off any starting UTF BOM mark.\n  _readStartingBom(input) {\n    return input.startsWith('\\ufeff') ? input.substr(1) : input;\n  }\n\n  // ## Public methods\n\n  // ### `tokenize` starts the transformation of an N3 document into an array of tokens.\n  // The input can be a string or a stream.\n  tokenize(input, callback) {\n    this._line = 1;\n\n    // If the input is a string, continuously emit tokens through the callback until the end\n    if (typeof input === 'string') {\n      this._input = this._readStartingBom(input);\n      // If a callback was passed, asynchronously call it\n      if (typeof callback === 'function')\n        queueMicrotask(() => this._tokenizeToEnd(callback, true));\n      // If no callback was passed, tokenize synchronously and return\n      else {\n        const tokens = [];\n        let error;\n        this._tokenizeToEnd((e, t) => e ? (error = e) : tokens.push(t), true);\n        if (error) throw error;\n        return tokens;\n      }\n    }\n    // Otherwise, the input must be a stream\n    else {\n      this._pendingBuffer = null;\n      if (typeof input.setEncoding === 'function')\n        input.setEncoding('utf8');\n      // Adds the data chunk to the buffer and parses as far as possible\n      input.on('data', data => {\n        if (this._input !== null && data.length !== 0) {\n          // Prepend any previous pending writes\n          if (this._pendingBuffer) {\n            data = Buffer.concat([this._pendingBuffer, data]);\n            this._pendingBuffer = null;\n          }\n          // Hold if the buffer ends in an incomplete unicode sequence\n          if (data[data.length - 1] & 0x80) {\n            this._pendingBuffer = data;\n          }\n          // Otherwise, tokenize as far as possible\n          else {\n            // Only read a BOM at the start\n            if (typeof this._input === 'undefined')\n              this._input = this._readStartingBom(typeof data === 'string' ? data : data.toString());\n            else\n              this._input += data;\n            this._tokenizeToEnd(callback, false);\n          }\n        }\n      });\n      // Parses until the end\n      input.on('end', () => {\n        if (typeof this._input === 'string')\n          this._tokenizeToEnd(callback, true);\n      });\n      input.on('error', callback);\n    }\n  }\n}\n","// N3.js implementations of the RDF/JS core data types\n// See https://github.com/rdfjs/representation-task-force/blob/master/interface-spec.md\n\nimport namespaces from './IRIs';\n\nconst { rdf, xsd } = namespaces;\n\n// eslint-disable-next-line prefer-const\nlet DEFAULTGRAPH;\nlet _blankNodeCounter = 0;\n\nconst escapedLiteral = /^\"(.*\".*)(?=\"[^\"]*$)/;\n\n// ## DataFactory singleton\nconst DataFactory = {\n  namedNode,\n  blankNode,\n  variable,\n  literal,\n  defaultGraph,\n  quad,\n  triple: quad,\n};\nexport default DataFactory;\n\n// ## Term constructor\nexport class Term {\n  constructor(id) {\n    this.id = id;\n  }\n\n  // ### The value of this term\n  get value() {\n    return this.id;\n  }\n\n  // ### Returns whether this object represents the same term as the other\n  equals(other) {\n    // If both terms were created by this library,\n    // equality can be computed through ids\n    if (other instanceof Term)\n      return this.id === other.id;\n    // Otherwise, compare term type and value\n    return !!other && this.termType === other.termType &&\n                      this.value    === other.value;\n  }\n\n  // ### Implement hashCode for Immutable.js, since we implement `equals`\n  // https://immutable-js.com/docs/v4.0.0/ValueObject/#hashCode()\n  hashCode() {\n    return 0;\n  }\n\n  // ### Returns a plain object representation of this term\n  toJSON() {\n    return {\n      termType: this.termType,\n      value:    this.value,\n    };\n  }\n}\n\n\n// ## NamedNode constructor\nexport class NamedNode extends Term {\n  // ### The term type of this term\n  get termType() {\n    return 'NamedNode';\n  }\n}\n\n// ## Literal constructor\nexport class Literal extends Term {\n  // ### The term type of this term\n  get termType() {\n    return 'Literal';\n  }\n\n  // ### The text value of this literal\n  get value() {\n    return this.id.substring(1, this.id.lastIndexOf('\"'));\n  }\n\n  // ### The language of this literal\n  get language() {\n    // Find the last quotation mark (e.g., '\"abc\"@en-us')\n    const id = this.id;\n    let atPos = id.lastIndexOf('\"') + 1;\n    // If \"@\" it follows, return the remaining substring; empty otherwise\n    return atPos < id.length && id[atPos++] === '@' ? id.substr(atPos).toLowerCase() : '';\n  }\n\n  // ### The datatype IRI of this literal\n  get datatype() {\n    return new NamedNode(this.datatypeString);\n  }\n\n  // ### The datatype string of this literal\n  get datatypeString() {\n    // Find the last quotation mark (e.g., '\"abc\"^^http://ex.org/types#t')\n    const id = this.id, dtPos = id.lastIndexOf('\"') + 1;\n    const char = dtPos < id.length ? id[dtPos] : '';\n    // If \"^\" it follows, return the remaining substring\n    return char === '^' ? id.substr(dtPos + 2) :\n           // If \"@\" follows, return rdf:langString; xsd:string otherwise\n           (char !== '@' ? xsd.string : rdf.langString);\n  }\n\n  // ### Returns whether this object represents the same term as the other\n  equals(other) {\n    // If both literals were created by this library,\n    // equality can be computed through ids\n    if (other instanceof Literal)\n      return this.id === other.id;\n    // Otherwise, compare term type, value, language, and datatype\n    return !!other && !!other.datatype &&\n                      this.termType === other.termType &&\n                      this.value    === other.value    &&\n                      this.language === other.language &&\n                      this.datatype.value === other.datatype.value;\n  }\n\n  toJSON() {\n    return {\n      termType: this.termType,\n      value:    this.value,\n      language: this.language,\n      datatype: { termType: 'NamedNode', value: this.datatypeString },\n    };\n  }\n}\n\n// ## BlankNode constructor\nexport class BlankNode extends Term {\n  constructor(name) {\n    super(`_:${name}`);\n  }\n\n  // ### The term type of this term\n  get termType() {\n    return 'BlankNode';\n  }\n\n  // ### The name of this blank node\n  get value() {\n    return this.id.substr(2);\n  }\n}\n\nexport class Variable extends Term {\n  constructor(name) {\n    super(`?${name}`);\n  }\n\n  // ### The term type of this term\n  get termType() {\n    return 'Variable';\n  }\n\n  // ### The name of this variable\n  get value() {\n    return this.id.substr(1);\n  }\n}\n\n// ## DefaultGraph constructor\nexport class DefaultGraph extends Term {\n  constructor() {\n    super('');\n    return DEFAULTGRAPH || this;\n  }\n\n  // ### The term type of this term\n  get termType() {\n    return 'DefaultGraph';\n  }\n\n  // ### Returns whether this object represents the same term as the other\n  equals(other) {\n    // If both terms were created by this library,\n    // equality can be computed through strict equality;\n    // otherwise, compare term types.\n    return (this === other) || (!!other && (this.termType === other.termType));\n  }\n}\n\n// ## DefaultGraph singleton\nDEFAULTGRAPH = new DefaultGraph();\n\n// ### Constructs a term from the given internal string ID\n// The third 'nested' parameter of this function is to aid\n// with recursion over nested terms. It should not be used\n// by consumers of this library.\n// See https://github.com/rdfjs/N3.js/pull/311#discussion_r1061042725\nexport function termFromId(id, factory, nested) {\n  factory = factory || DataFactory;\n\n  // Falsy value or empty string indicate the default graph\n  if (!id)\n    return factory.defaultGraph();\n\n  // Identify the term type based on the first character\n  switch (id[0]) {\n  case '?':\n    return factory.variable(id.substr(1));\n  case '_':\n    return factory.blankNode(id.substr(2));\n  case '\"':\n    // Shortcut for internal literals\n    if (factory === DataFactory)\n      return new Literal(id);\n    // Literal without datatype or language\n    if (id[id.length - 1] === '\"')\n      return factory.literal(id.substr(1, id.length - 2));\n    // Literal with datatype or language\n    const endPos = id.lastIndexOf('\"', id.length - 1);\n    return factory.literal(id.substr(1, endPos - 1),\n            id[endPos + 1] === '@' ? id.substr(endPos + 2)\n                                   : factory.namedNode(id.substr(endPos + 3)));\n  case '[':\n    id = JSON.parse(id);\n    break;\n  default:\n    if (!nested || !Array.isArray(id)) {\n      return factory.namedNode(id);\n    }\n  }\n  return factory.quad(\n    termFromId(id[0], factory, true),\n    termFromId(id[1], factory, true),\n    termFromId(id[2], factory, true),\n    id[3] && termFromId(id[3], factory, true)\n  );\n}\n\n// ### Constructs an internal string ID from the given term or ID string\n// The third 'nested' parameter of this function is to aid\n// with recursion over nested terms. It should not be used\n// by consumers of this library.\n// See https://github.com/rdfjs/N3.js/pull/311#discussion_r1061042725\nexport function termToId(term, nested) {\n  if (typeof term === 'string')\n    return term;\n  if (term instanceof Term && term.termType !== 'Quad')\n    return term.id;\n  if (!term)\n    return DEFAULTGRAPH.id;\n\n  // Term instantiated with another library\n  switch (term.termType) {\n  case 'NamedNode':    return term.value;\n  case 'BlankNode':    return `_:${term.value}`;\n  case 'Variable':     return `?${term.value}`;\n  case 'DefaultGraph': return '';\n  case 'Literal':      return `\"${term.value}\"${\n    term.language ? `@${term.language}` :\n      (term.datatype && term.datatype.value !== xsd.string ? `^^${term.datatype.value}` : '')}`;\n  case 'Quad':\n    const res = [\n      termToId(term.subject, true),\n      termToId(term.predicate, true),\n      termToId(term.object, true),\n    ];\n    if (term.graph && term.graph.termType !== 'DefaultGraph') {\n      res.push(termToId(term.graph, true));\n    }\n    return nested ? res : JSON.stringify(res);\n  default: throw new Error(`Unexpected termType: ${term.termType}`);\n  }\n}\n\n\n// ## Quad constructor\nexport class Quad extends Term {\n  constructor(subject, predicate, object, graph) {\n    super('');\n    this._subject   = subject;\n    this._predicate = predicate;\n    this._object    = object;\n    this._graph     = graph || DEFAULTGRAPH;\n  }\n\n  // ### The term type of this term\n  get termType() {\n    return 'Quad';\n  }\n\n  get subject() {\n    return this._subject;\n  }\n\n  get predicate() {\n    return this._predicate;\n  }\n\n  get object() {\n    return this._object;\n  }\n\n  get graph() {\n    return this._graph;\n  }\n\n  // ### Returns a plain object representation of this quad\n  toJSON() {\n    return {\n      termType:  this.termType,\n      subject:   this._subject.toJSON(),\n      predicate: this._predicate.toJSON(),\n      object:    this._object.toJSON(),\n      graph:     this._graph.toJSON(),\n    };\n  }\n\n  // ### Returns whether this object represents the same quad as the other\n  equals(other) {\n    return !!other && this._subject.equals(other.subject)     &&\n                      this._predicate.equals(other.predicate) &&\n                      this._object.equals(other.object)       &&\n                      this._graph.equals(other.graph);\n  }\n}\nexport { Quad as Triple };\n\n// ### Escapes the quotes within the given literal\nexport function escapeQuotes(id) {\n  return id.replace(escapedLiteral, (_, quoted) => `\"${quoted.replace(/\"/g, '\"\"')}`);\n}\n\n// ### Unescapes the quotes within the given literal\nexport function unescapeQuotes(id) {\n  return id.replace(escapedLiteral, (_, quoted) => `\"${quoted.replace(/\"\"/g, '\"')}`);\n}\n\n// ### Creates an IRI\nfunction namedNode(iri) {\n  return new NamedNode(iri);\n}\n\n// ### Creates a blank node\nfunction blankNode(name) {\n  return new BlankNode(name || `n3-${_blankNodeCounter++}`);\n}\n\n// ### Creates a literal\nfunction literal(value, languageOrDataType) {\n  // Create a language-tagged string\n  if (typeof languageOrDataType === 'string')\n    return new Literal(`\"${value}\"@${languageOrDataType.toLowerCase()}`);\n\n  // Automatically determine datatype for booleans and numbers\n  let datatype = languageOrDataType ? languageOrDataType.value : '';\n  if (datatype === '') {\n    // Convert a boolean\n    if (typeof value === 'boolean')\n      datatype = xsd.boolean;\n    // Convert an integer or double\n    else if (typeof value === 'number') {\n      if (Number.isFinite(value))\n        datatype = Number.isInteger(value) ? xsd.integer : xsd.double;\n      else {\n        datatype = xsd.double;\n        if (!Number.isNaN(value))\n          value = value > 0 ? 'INF' : '-INF';\n      }\n    }\n  }\n\n  // Create a datatyped literal\n  return (datatype === '' || datatype === xsd.string) ?\n    new Literal(`\"${value}\"`) :\n    new Literal(`\"${value}\"^^${datatype}`);\n}\n\n// ### Creates a variable\nfunction variable(name) {\n  return new Variable(name);\n}\n\n// ### Returns the default graph\nfunction defaultGraph() {\n  return DEFAULTGRAPH;\n}\n\n// ### Creates a quad\nfunction quad(subject, predicate, object, graph) {\n  return new Quad(subject, predicate, object, graph);\n}\n","// **N3Parser** parses N3 documents.\nimport N3Lexer from './N3Lexer';\nimport N3DataFactory from './N3DataFactory';\nimport namespaces from './IRIs';\n\nlet blankNodePrefix = 0;\n\n// ## Constructor\nexport default class N3Parser {\n  constructor(options) {\n    this._contextStack = [];\n    this._graph = null;\n\n    // Set the document IRI\n    options = options || {};\n    this._setBase(options.baseIRI);\n    options.factory && initDataFactory(this, options.factory);\n\n    // Set supported features depending on the format\n    const format = (typeof options.format === 'string') ?\n                 options.format.match(/\\w*$/)[0].toLowerCase() : '',\n        isTurtle = /turtle/.test(format), isTriG = /trig/.test(format),\n        isNTriples = /triple/.test(format), isNQuads = /quad/.test(format),\n        isN3 = this._n3Mode = /n3/.test(format),\n        isLineMode = isNTriples || isNQuads;\n    if (!(this._supportsNamedGraphs = !(isTurtle || isN3)))\n      this._readPredicateOrNamedGraph = this._readPredicate;\n    // Support triples in other graphs\n    this._supportsQuads = !(isTurtle || isTriG || isNTriples || isN3);\n    // Support nesting of triples\n    this._supportsRDFStar = format === '' || /star|\\*$/.test(format);\n    // Disable relative IRIs in N-Triples or N-Quads mode\n    if (isLineMode)\n      this._resolveRelativeIRI = iri => { return null; };\n    this._blankNodePrefix = typeof options.blankNodePrefix !== 'string' ? '' :\n                              options.blankNodePrefix.replace(/^(?!_:)/, '_:');\n    this._lexer = options.lexer || new N3Lexer({ lineMode: isLineMode, n3: isN3 });\n    // Disable explicit quantifiers by default\n    this._explicitQuantifiers = !!options.explicitQuantifiers;\n  }\n\n  // ## Static class methods\n\n  // ### `_resetBlankNodePrefix` restarts blank node prefix identification\n  static _resetBlankNodePrefix() {\n    blankNodePrefix = 0;\n  }\n\n  // ## Private methods\n\n  // ### `_setBase` sets the base IRI to resolve relative IRIs\n  _setBase(baseIRI) {\n    if (!baseIRI) {\n      this._base = '';\n      this._basePath = '';\n    }\n    else {\n      // Remove fragment if present\n      const fragmentPos = baseIRI.indexOf('#');\n      if (fragmentPos >= 0)\n        baseIRI = baseIRI.substr(0, fragmentPos);\n      // Set base IRI and its components\n      this._base = baseIRI;\n      this._basePath   = baseIRI.indexOf('/') < 0 ? baseIRI :\n                         baseIRI.replace(/[^\\/?]*(?:\\?.*)?$/, '');\n      baseIRI = baseIRI.match(/^(?:([a-z][a-z0-9+.-]*:))?(?:\\/\\/[^\\/]*)?/i);\n      this._baseRoot   = baseIRI[0];\n      this._baseScheme = baseIRI[1];\n    }\n  }\n\n  // ### `_saveContext` stores the current parsing context\n  // when entering a new scope (list, blank node, formula)\n  _saveContext(type, graph, subject, predicate, object) {\n    const n3Mode = this._n3Mode;\n    this._contextStack.push({\n      type,\n      subject, predicate, object, graph,\n      inverse: n3Mode ? this._inversePredicate : false,\n      blankPrefix: n3Mode ? this._prefixes._ : '',\n      quantified: n3Mode ? this._quantified : null,\n    });\n    // The settings below only apply to N3 streams\n    if (n3Mode) {\n      // Every new scope resets the predicate direction\n      this._inversePredicate = false;\n      // In N3, blank nodes are scoped to a formula\n      // (using a dot as separator, as a blank node label cannot start with it)\n      this._prefixes._ = (this._graph ? `${this._graph.value}.` : '.');\n      // Quantifiers are scoped to a formula\n      this._quantified = Object.create(this._quantified);\n    }\n  }\n\n  // ### `_restoreContext` restores the parent context\n  // when leaving a scope (list, blank node, formula)\n  _restoreContext(type, token) {\n    // Obtain the previous context\n    const context = this._contextStack.pop();\n    if (!context || context.type !== type)\n      return this._error(`Unexpected ${token.type}`, token);\n\n    // Restore the quad of the previous context\n    this._subject   = context.subject;\n    this._predicate = context.predicate;\n    this._object    = context.object;\n    this._graph     = context.graph;\n\n    // Restore N3 context settings\n    if (this._n3Mode) {\n      this._inversePredicate = context.inverse;\n      this._prefixes._ = context.blankPrefix;\n      this._quantified = context.quantified;\n    }\n  }\n\n  // ### `_readInTopContext` reads a token when in the top context\n  _readInTopContext(token) {\n    switch (token.type) {\n    // If an EOF token arrives in the top context, signal that we're done\n    case 'eof':\n      if (this._graph !== null)\n        return this._error('Unclosed graph', token);\n      delete this._prefixes._;\n      return this._callback(null, null, this._prefixes);\n    // It could be a prefix declaration\n    case 'PREFIX':\n      this._sparqlStyle = true;\n    case '@prefix':\n      return this._readPrefix;\n    // It could be a base declaration\n    case 'BASE':\n      this._sparqlStyle = true;\n    case '@base':\n      return this._readBaseIRI;\n    // It could be a graph\n    case '{':\n      if (this._supportsNamedGraphs) {\n        this._graph = '';\n        this._subject = null;\n        return this._readSubject;\n      }\n    case 'GRAPH':\n      if (this._supportsNamedGraphs)\n        return this._readNamedGraphLabel;\n    // Otherwise, the next token must be a subject\n    default:\n      return this._readSubject(token);\n    }\n  }\n\n  // ### `_readEntity` reads an IRI, prefixed name, blank node, or variable\n  _readEntity(token, quantifier) {\n    let value;\n    switch (token.type) {\n    // Read a relative or absolute IRI\n    case 'IRI':\n    case 'typeIRI':\n      const iri = this._resolveIRI(token.value);\n      if (iri === null)\n        return this._error('Invalid IRI', token);\n      value = this._namedNode(iri);\n      break;\n    // Read a prefixed name\n    case 'type':\n    case 'prefixed':\n      const prefix = this._prefixes[token.prefix];\n      if (prefix === undefined)\n        return this._error(`Undefined prefix \"${token.prefix}:\"`, token);\n      value = this._namedNode(prefix + token.value);\n      break;\n    // Read a blank node\n    case 'blank':\n      value = this._blankNode(this._prefixes[token.prefix] + token.value);\n      break;\n    // Read a variable\n    case 'var':\n      value = this._variable(token.value.substr(1));\n      break;\n    // Everything else is not an entity\n    default:\n      return this._error(`Expected entity but got ${token.type}`, token);\n    }\n    // In N3 mode, replace the entity if it is quantified\n    if (!quantifier && this._n3Mode && (value.id in this._quantified))\n      value = this._quantified[value.id];\n    return value;\n  }\n\n  // ### `_readSubject` reads a quad's subject\n  _readSubject(token) {\n    this._predicate = null;\n    switch (token.type) {\n    case '[':\n      // Start a new quad with a new blank node as subject\n      this._saveContext('blank', this._graph,\n                        this._subject = this._blankNode(), null, null);\n      return this._readBlankNodeHead;\n    case '(':\n      // Start a new list\n      this._saveContext('list', this._graph, this.RDF_NIL, null, null);\n      this._subject = null;\n      return this._readListItem;\n    case '{':\n      // Start a new formula\n      if (!this._n3Mode)\n        return this._error('Unexpected graph', token);\n      this._saveContext('formula', this._graph,\n                        this._graph = this._blankNode(), null, null);\n      return this._readSubject;\n    case '}':\n       // No subject; the graph in which we are reading is closed instead\n      return this._readPunctuation(token);\n    case '@forSome':\n      if (!this._n3Mode)\n        return this._error('Unexpected \"@forSome\"', token);\n      this._subject = null;\n      this._predicate = this.N3_FORSOME;\n      this._quantifier = this._blankNode;\n      return this._readQuantifierList;\n    case '@forAll':\n      if (!this._n3Mode)\n        return this._error('Unexpected \"@forAll\"', token);\n      this._subject = null;\n      this._predicate = this.N3_FORALL;\n      this._quantifier = this._variable;\n      return this._readQuantifierList;\n    case 'literal':\n      if (!this._n3Mode)\n        return this._error('Unexpected literal', token);\n\n      if (token.prefix.length === 0) {\n        this._literalValue = token.value;\n        return this._completeSubjectLiteral;\n      }\n      else\n        this._subject = this._literal(token.value, this._namedNode(token.prefix));\n\n      break;\n    case '<<':\n      if (!this._supportsRDFStar)\n        return this._error('Unexpected RDF* syntax', token);\n      this._saveContext('<<', this._graph, null, null, null);\n      this._graph = null;\n      return this._readSubject;\n    default:\n      // Read the subject entity\n      if ((this._subject = this._readEntity(token)) === undefined)\n        return;\n      // In N3 mode, the subject might be a path\n      if (this._n3Mode)\n        return this._getPathReader(this._readPredicateOrNamedGraph);\n    }\n\n    // The next token must be a predicate,\n    // or, if the subject was actually a graph IRI, a named graph\n    return this._readPredicateOrNamedGraph;\n  }\n\n  // ### `_readPredicate` reads a quad's predicate\n  _readPredicate(token) {\n    const type = token.type;\n    switch (type) {\n    case 'inverse':\n      this._inversePredicate = true;\n    case 'abbreviation':\n      this._predicate = this.ABBREVIATIONS[token.value];\n      break;\n    case '.':\n    case ']':\n    case '}':\n      // Expected predicate didn't come, must have been trailing semicolon\n      if (this._predicate === null)\n        return this._error(`Unexpected ${type}`, token);\n      this._subject = null;\n      return type === ']' ? this._readBlankNodeTail(token) : this._readPunctuation(token);\n    case ';':\n      // Additional semicolons can be safely ignored\n      return this._predicate !== null ? this._readPredicate :\n             this._error('Expected predicate but got ;', token);\n    case '[':\n      if (this._n3Mode) {\n        // Start a new quad with a new blank node as subject\n        this._saveContext('blank', this._graph, this._subject,\n                          this._subject = this._blankNode(), null);\n        return this._readBlankNodeHead;\n      }\n    case 'blank':\n      if (!this._n3Mode)\n        return this._error('Disallowed blank node as predicate', token);\n    default:\n      if ((this._predicate = this._readEntity(token)) === undefined)\n        return;\n    }\n    // The next token must be an object\n    return this._readObject;\n  }\n\n  // ### `_readObject` reads a quad's object\n  _readObject(token) {\n    switch (token.type) {\n    case 'literal':\n      // Regular literal, can still get a datatype or language\n      if (token.prefix.length === 0) {\n        this._literalValue = token.value;\n        return this._readDataTypeOrLang;\n      }\n      // Pre-datatyped string literal (prefix stores the datatype)\n      else\n        this._object = this._literal(token.value, this._namedNode(token.prefix));\n      break;\n    case '[':\n      // Start a new quad with a new blank node as subject\n      this._saveContext('blank', this._graph, this._subject, this._predicate,\n                        this._subject = this._blankNode());\n      return this._readBlankNodeHead;\n    case '(':\n      // Start a new list\n      this._saveContext('list', this._graph, this._subject, this._predicate, this.RDF_NIL);\n      this._subject = null;\n      return this._readListItem;\n    case '{':\n      // Start a new formula\n      if (!this._n3Mode)\n        return this._error('Unexpected graph', token);\n      this._saveContext('formula', this._graph, this._subject, this._predicate,\n                        this._graph = this._blankNode());\n      return this._readSubject;\n    case '<<':\n      if (!this._supportsRDFStar)\n        return this._error('Unexpected RDF* syntax', token);\n      this._saveContext('<<', this._graph, this._subject, this._predicate, null);\n      this._graph = null;\n      return this._readSubject;\n    default:\n      // Read the object entity\n      if ((this._object = this._readEntity(token)) === undefined)\n        return;\n      // In N3 mode, the object might be a path\n      if (this._n3Mode)\n        return this._getPathReader(this._getContextEndReader());\n    }\n    return this._getContextEndReader();\n  }\n\n  // ### `_readPredicateOrNamedGraph` reads a quad's predicate, or a named graph\n  _readPredicateOrNamedGraph(token) {\n    return token.type === '{' ? this._readGraph(token) : this._readPredicate(token);\n  }\n\n  // ### `_readGraph` reads a graph\n  _readGraph(token) {\n    if (token.type !== '{')\n      return this._error(`Expected graph but got ${token.type}`, token);\n    // The \"subject\" we read is actually the GRAPH's label\n    this._graph = this._subject, this._subject = null;\n    return this._readSubject;\n  }\n\n  // ### `_readBlankNodeHead` reads the head of a blank node\n  _readBlankNodeHead(token) {\n    if (token.type === ']') {\n      this._subject = null;\n      return this._readBlankNodeTail(token);\n    }\n    else {\n      this._predicate = null;\n      return this._readPredicate(token);\n    }\n  }\n\n  // ### `_readBlankNodeTail` reads the end of a blank node\n  _readBlankNodeTail(token) {\n    if (token.type !== ']')\n      return this._readBlankNodePunctuation(token);\n\n    // Store blank node quad\n    if (this._subject !== null)\n      this._emit(this._subject, this._predicate, this._object, this._graph);\n\n    // Restore the parent context containing this blank node\n    const empty = this._predicate === null;\n    this._restoreContext('blank', token);\n    // If the blank node was the object, restore previous context and read punctuation\n    if (this._object !== null)\n      return this._getContextEndReader();\n    // If the blank node was the predicate, continue reading the object\n    else if (this._predicate !== null)\n      return this._readObject;\n    // If the blank node was the subject, continue reading the predicate\n    else\n      // If the blank node was empty, it could be a named graph label\n      return empty ? this._readPredicateOrNamedGraph : this._readPredicateAfterBlank;\n  }\n\n  // ### `_readPredicateAfterBlank` reads a predicate after an anonymous blank node\n  _readPredicateAfterBlank(token) {\n    switch (token.type) {\n    case '.':\n    case '}':\n      // No predicate is coming if the triple is terminated here\n      this._subject = null;\n      return this._readPunctuation(token);\n    default:\n      return this._readPredicate(token);\n    }\n  }\n\n  // ### `_readListItem` reads items from a list\n  _readListItem(token) {\n    let item = null,                      // The item of the list\n        list = null,                      // The list itself\n        next = this._readListItem;        // The next function to execute\n    const previousList = this._subject,   // The previous list that contains this list\n        stack = this._contextStack,       // The stack of parent contexts\n        parent = stack[stack.length - 1]; // The parent containing the current list\n\n    switch (token.type) {\n    case '[':\n      // Stack the current list quad and start a new quad with a blank node as subject\n      this._saveContext('blank', this._graph,\n                        list = this._blankNode(), this.RDF_FIRST,\n                        this._subject = item = this._blankNode());\n      next = this._readBlankNodeHead;\n      break;\n    case '(':\n      // Stack the current list quad and start a new list\n      this._saveContext('list', this._graph,\n                        list = this._blankNode(), this.RDF_FIRST, this.RDF_NIL);\n      this._subject = null;\n      break;\n    case ')':\n      // Closing the list; restore the parent context\n      this._restoreContext('list', token);\n      // If this list is contained within a parent list, return the membership quad here.\n      // This will be `<parent list element> rdf:first <this list>.`.\n      if (stack.length !== 0 && stack[stack.length - 1].type === 'list')\n        this._emit(this._subject, this._predicate, this._object, this._graph);\n      // Was this list the parent's subject?\n      if (this._predicate === null) {\n        // The next token is the predicate\n        next = this._readPredicate;\n        // No list tail if this was an empty list\n        if (this._subject === this.RDF_NIL)\n          return next;\n      }\n      // The list was in the parent context's object\n      else {\n        next = this._getContextEndReader();\n        // No list tail if this was an empty list\n        if (this._object === this.RDF_NIL)\n          return next;\n      }\n      // Close the list by making the head nil\n      list = this.RDF_NIL;\n      break;\n    case 'literal':\n      // Regular literal, can still get a datatype or language\n      if (token.prefix.length === 0) {\n        this._literalValue = token.value;\n        next = this._readListItemDataTypeOrLang;\n      }\n      // Pre-datatyped string literal (prefix stores the datatype)\n      else {\n        item = this._literal(token.value, this._namedNode(token.prefix));\n        next = this._getContextEndReader();\n      }\n      break;\n    case '{':\n      // Start a new formula\n      if (!this._n3Mode)\n        return this._error('Unexpected graph', token);\n      this._saveContext('formula', this._graph, this._subject, this._predicate,\n                        this._graph = this._blankNode());\n      return this._readSubject;\n    default:\n      if ((item = this._readEntity(token)) === undefined)\n        return;\n    }\n\n     // Create a new blank node if no item head was assigned yet\n    if (list === null)\n      this._subject = list = this._blankNode();\n\n    // Is this the first element of the list?\n    if (previousList === null) {\n      // This list is either the subject or the object of its parent\n      if (parent.predicate === null)\n        parent.subject = list;\n      else\n        parent.object = list;\n    }\n    else {\n      // Continue the previous list with the current list\n      this._emit(previousList, this.RDF_REST, list, this._graph);\n    }\n    // If an item was read, add it to the list\n    if (item !== null) {\n      // In N3 mode, the item might be a path\n      if (this._n3Mode && (token.type === 'IRI' || token.type === 'prefixed')) {\n        // Create a new context to add the item's path\n        this._saveContext('item', this._graph, list, this.RDF_FIRST, item);\n        this._subject = item, this._predicate = null;\n        // _readPath will restore the context and output the item\n        return this._getPathReader(this._readListItem);\n      }\n      // Output the item\n      this._emit(list, this.RDF_FIRST, item, this._graph);\n    }\n    return next;\n  }\n\n  // ### `_readDataTypeOrLang` reads an _optional_ datatype or language\n  _readDataTypeOrLang(token) {\n    return this._completeObjectLiteral(token, false);\n  }\n\n\n  // ### `_readListItemDataTypeOrLang` reads an _optional_ datatype or language in a list\n  _readListItemDataTypeOrLang(token) {\n    return this._completeObjectLiteral(token, true);\n  }\n\n  // ### `_completeLiteral` completes a literal with an optional datatype or language\n  _completeLiteral(token) {\n    // Create a simple string literal by default\n    let literal = this._literal(this._literalValue);\n\n    switch (token.type) {\n    // Create a datatyped literal\n    case 'type':\n    case 'typeIRI':\n      const datatype = this._readEntity(token);\n      if (datatype === undefined) return; // No datatype means an error occurred\n      literal = this._literal(this._literalValue, datatype);\n      token = null;\n      break;\n    // Create a language-tagged string\n    case 'langcode':\n      literal = this._literal(this._literalValue, token.value);\n      token = null;\n      break;\n    }\n\n    return { token, literal };\n  }\n\n  // Completes a literal in subject position\n  _completeSubjectLiteral(token) {\n    this._subject = this._completeLiteral(token).literal;\n    return this._readPredicateOrNamedGraph;\n  }\n\n  // Completes a literal in object position\n  _completeObjectLiteral(token, listItem) {\n    const completed = this._completeLiteral(token);\n    if (!completed)\n      return;\n    this._object = completed.literal;\n\n    // If this literal was part of a list, write the item\n    // (we could also check the context stack, but passing in a flag is faster)\n    if (listItem)\n      this._emit(this._subject, this.RDF_FIRST, this._object, this._graph);\n    // If the token was consumed, continue with the rest of the input\n    if (completed.token === null)\n      return this._getContextEndReader();\n    // Otherwise, consume the token now\n    else {\n      this._readCallback = this._getContextEndReader();\n      return this._readCallback(completed.token);\n    }\n  }\n\n  // ### `_readFormulaTail` reads the end of a formula\n  _readFormulaTail(token) {\n    if (token.type !== '}')\n      return this._readPunctuation(token);\n\n    // Store the last quad of the formula\n    if (this._subject !== null)\n      this._emit(this._subject, this._predicate, this._object, this._graph);\n\n    // Restore the parent context containing this formula\n    this._restoreContext('formula', token);\n    // If the formula was the subject, continue reading the predicate.\n    // If the formula was the object, read punctuation.\n    return this._object === null ? this._readPredicate : this._getContextEndReader();\n  }\n\n  // ### `_readPunctuation` reads punctuation between quads or quad parts\n  _readPunctuation(token) {\n    let next, graph = this._graph;\n    const subject = this._subject, inversePredicate = this._inversePredicate;\n    switch (token.type) {\n    // A closing brace ends a graph\n    case '}':\n      if (this._graph === null)\n        return this._error('Unexpected graph closing', token);\n      if (this._n3Mode)\n        return this._readFormulaTail(token);\n      this._graph = null;\n    // A dot just ends the statement, without sharing anything with the next\n    case '.':\n      this._subject = null;\n      next = this._contextStack.length ? this._readSubject : this._readInTopContext;\n      if (inversePredicate) this._inversePredicate = false;\n      break;\n    // Semicolon means the subject is shared; predicate and object are different\n    case ';':\n      next = this._readPredicate;\n      break;\n    // Comma means both the subject and predicate are shared; the object is different\n    case ',':\n      next = this._readObject;\n      break;\n    // {| means that the current triple is annotated with predicate-object pairs.\n    case '{|':\n      if (!this._supportsRDFStar)\n        return this._error('Unexpected RDF* syntax', token);\n      // Continue using the last triple as quoted triple subject for the predicate-object pairs.\n      const predicate = this._predicate, object = this._object;\n      this._subject = this._quad(subject, predicate, object, this.DEFAULTGRAPH);\n      next = this._readPredicate;\n      break;\n    // |} means that the current quoted triple in annotation syntax is finalized.\n    case '|}':\n      if (this._subject.termType !== 'Quad')\n        return this._error('Unexpected asserted triple closing', token);\n      this._subject = null;\n      next = this._readPunctuation;\n      break;\n    default:\n      // An entity means this is a quad (only allowed if not already inside a graph)\n      if (this._supportsQuads && this._graph === null && (graph = this._readEntity(token)) !== undefined) {\n        next = this._readQuadPunctuation;\n        break;\n      }\n      return this._error(`Expected punctuation to follow \"${this._object.id}\"`, token);\n    }\n    // A quad has been completed now, so return it\n    if (subject !== null) {\n      const predicate = this._predicate, object = this._object;\n      if (!inversePredicate)\n        this._emit(subject, predicate, object,  graph);\n      else\n        this._emit(object,  predicate, subject, graph);\n    }\n    return next;\n  }\n\n    // ### `_readBlankNodePunctuation` reads punctuation in a blank node\n  _readBlankNodePunctuation(token) {\n    let next;\n    switch (token.type) {\n    // Semicolon means the subject is shared; predicate and object are different\n    case ';':\n      next = this._readPredicate;\n      break;\n    // Comma means both the subject and predicate are shared; the object is different\n    case ',':\n      next = this._readObject;\n      break;\n    default:\n      return this._error(`Expected punctuation to follow \"${this._object.id}\"`, token);\n    }\n    // A quad has been completed now, so return it\n    this._emit(this._subject, this._predicate, this._object, this._graph);\n    return next;\n  }\n\n  // ### `_readQuadPunctuation` reads punctuation after a quad\n  _readQuadPunctuation(token) {\n    if (token.type !== '.')\n      return this._error('Expected dot to follow quad', token);\n    return this._readInTopContext;\n  }\n\n  // ### `_readPrefix` reads the prefix of a prefix declaration\n  _readPrefix(token) {\n    if (token.type !== 'prefix')\n      return this._error('Expected prefix to follow @prefix', token);\n    this._prefix = token.value;\n    return this._readPrefixIRI;\n  }\n\n  // ### `_readPrefixIRI` reads the IRI of a prefix declaration\n  _readPrefixIRI(token) {\n    if (token.type !== 'IRI')\n      return this._error(`Expected IRI to follow prefix \"${this._prefix}:\"`, token);\n    const prefixNode = this._readEntity(token);\n    this._prefixes[this._prefix] = prefixNode.value;\n    this._prefixCallback(this._prefix, prefixNode);\n    return this._readDeclarationPunctuation;\n  }\n\n  // ### `_readBaseIRI` reads the IRI of a base declaration\n  _readBaseIRI(token) {\n    const iri = token.type === 'IRI' && this._resolveIRI(token.value);\n    if (!iri)\n      return this._error('Expected valid IRI to follow base declaration', token);\n    this._setBase(iri);\n    return this._readDeclarationPunctuation;\n  }\n\n  // ### `_readNamedGraphLabel` reads the label of a named graph\n  _readNamedGraphLabel(token) {\n    switch (token.type) {\n    case 'IRI':\n    case 'blank':\n    case 'prefixed':\n      return this._readSubject(token), this._readGraph;\n    case '[':\n      return this._readNamedGraphBlankLabel;\n    default:\n      return this._error('Invalid graph label', token);\n    }\n  }\n\n  // ### `_readNamedGraphLabel` reads a blank node label of a named graph\n  _readNamedGraphBlankLabel(token) {\n    if (token.type !== ']')\n      return this._error('Invalid graph label', token);\n    this._subject = this._blankNode();\n    return this._readGraph;\n  }\n\n  // ### `_readDeclarationPunctuation` reads the punctuation of a declaration\n  _readDeclarationPunctuation(token) {\n    // SPARQL-style declarations don't have punctuation\n    if (this._sparqlStyle) {\n      this._sparqlStyle = false;\n      return this._readInTopContext(token);\n    }\n\n    if (token.type !== '.')\n      return this._error('Expected declaration to end with a dot', token);\n    return this._readInTopContext;\n  }\n\n  // Reads a list of quantified symbols from a @forSome or @forAll statement\n  _readQuantifierList(token) {\n    let entity;\n    switch (token.type) {\n    case 'IRI':\n    case 'prefixed':\n      if ((entity = this._readEntity(token, true)) !== undefined)\n        break;\n    default:\n      return this._error(`Unexpected ${token.type}`, token);\n    }\n    // Without explicit quantifiers, map entities to a quantified entity\n    if (!this._explicitQuantifiers)\n      this._quantified[entity.id] = this._quantifier(this._blankNode().value);\n    // With explicit quantifiers, output the reified quantifier\n    else {\n      // If this is the first item, start a new quantifier list\n      if (this._subject === null)\n        this._emit(this._graph || this.DEFAULTGRAPH, this._predicate,\n                   this._subject = this._blankNode(), this.QUANTIFIERS_GRAPH);\n      // Otherwise, continue the previous list\n      else\n        this._emit(this._subject, this.RDF_REST,\n                   this._subject = this._blankNode(), this.QUANTIFIERS_GRAPH);\n      // Output the list item\n      this._emit(this._subject, this.RDF_FIRST, entity, this.QUANTIFIERS_GRAPH);\n    }\n    return this._readQuantifierPunctuation;\n  }\n\n  // Reads punctuation from a @forSome or @forAll statement\n  _readQuantifierPunctuation(token) {\n    // Read more quantifiers\n    if (token.type === ',')\n      return this._readQuantifierList;\n    // End of the quantifier list\n    else {\n      // With explicit quantifiers, close the quantifier list\n      if (this._explicitQuantifiers) {\n        this._emit(this._subject, this.RDF_REST, this.RDF_NIL, this.QUANTIFIERS_GRAPH);\n        this._subject = null;\n      }\n      // Read a dot\n      this._readCallback = this._getContextEndReader();\n      return this._readCallback(token);\n    }\n  }\n\n  // ### `_getPathReader` reads a potential path and then resumes with the given function\n  _getPathReader(afterPath) {\n    this._afterPath = afterPath;\n    return this._readPath;\n  }\n\n  // ### `_readPath` reads a potential path\n  _readPath(token) {\n    switch (token.type) {\n    // Forward path\n    case '!': return this._readForwardPath;\n    // Backward path\n    case '^': return this._readBackwardPath;\n    // Not a path; resume reading where we left off\n    default:\n      const stack = this._contextStack, parent = stack.length && stack[stack.length - 1];\n      // If we were reading a list item, we still need to output it\n      if (parent && parent.type === 'item') {\n        // The list item is the remaining subejct after reading the path\n        const item = this._subject;\n        // Switch back to the context of the list\n        this._restoreContext('item', token);\n        // Output the list item\n        this._emit(this._subject, this.RDF_FIRST, item, this._graph);\n      }\n      return this._afterPath(token);\n    }\n  }\n\n  // ### `_readForwardPath` reads a '!' path\n  _readForwardPath(token) {\n    let subject, predicate;\n    const object = this._blankNode();\n    // The next token is the predicate\n    if ((predicate = this._readEntity(token)) === undefined)\n      return;\n    // If we were reading a subject, replace the subject by the path's object\n    if (this._predicate === null)\n      subject = this._subject, this._subject = object;\n    // If we were reading an object, replace the subject by the path's object\n    else\n      subject = this._object,  this._object  = object;\n    // Emit the path's current quad and read its next section\n    this._emit(subject, predicate, object, this._graph);\n    return this._readPath;\n  }\n\n  // ### `_readBackwardPath` reads a '^' path\n  _readBackwardPath(token) {\n    const subject = this._blankNode();\n    let predicate, object;\n    // The next token is the predicate\n    if ((predicate = this._readEntity(token)) === undefined)\n      return;\n    // If we were reading a subject, replace the subject by the path's subject\n    if (this._predicate === null)\n      object = this._subject, this._subject = subject;\n    // If we were reading an object, replace the subject by the path's subject\n    else\n      object = this._object,  this._object  = subject;\n    // Emit the path's current quad and read its next section\n    this._emit(subject, predicate, object, this._graph);\n    return this._readPath;\n  }\n\n  // ### `_readRDFStarTailOrGraph` reads the graph of a nested RDF* quad or the end of a nested RDF* triple\n  _readRDFStarTailOrGraph(token) {\n    if (token.type !== '>>') {\n      // An entity means this is a quad (only allowed if not already inside a graph)\n      if (this._supportsQuads && this._graph === null && (this._graph = this._readEntity(token)) !== undefined)\n        return this._readRDFStarTail;\n      return this._error(`Expected >> to follow \"${this._object.id}\"`, token);\n    }\n    return this._readRDFStarTail(token);\n  }\n\n  // ### `_readRDFStarTail` reads the end of a nested RDF* triple\n  _readRDFStarTail(token) {\n    if (token.type !== '>>')\n      return this._error(`Expected >> but got ${token.type}`, token);\n    // Read the quad and restore the previous context\n    const quad = this._quad(this._subject, this._predicate, this._object,\n      this._graph || this.DEFAULTGRAPH);\n    this._restoreContext('<<', token);\n    // If the triple was the subject, continue by reading the predicate.\n    if (this._subject === null) {\n      this._subject = quad;\n      return this._readPredicate;\n    }\n    // If the triple was the object, read context end.\n    else {\n      this._object = quad;\n      return this._getContextEndReader();\n    }\n  }\n\n  // ### `_getContextEndReader` gets the next reader function at the end of a context\n  _getContextEndReader() {\n    const contextStack = this._contextStack;\n    if (!contextStack.length)\n      return this._readPunctuation;\n\n    switch (contextStack[contextStack.length - 1].type) {\n    case 'blank':\n      return this._readBlankNodeTail;\n    case 'list':\n      return this._readListItem;\n    case 'formula':\n      return this._readFormulaTail;\n    case '<<':\n      return this._readRDFStarTailOrGraph;\n    }\n  }\n\n  // ### `_emit` sends a quad through the callback\n  _emit(subject, predicate, object, graph) {\n    this._callback(null, this._quad(subject, predicate, object, graph || this.DEFAULTGRAPH));\n  }\n\n  // ### `_error` emits an error message through the callback\n  _error(message, token) {\n    const err = new Error(`${message} on line ${token.line}.`);\n    err.context = {\n      token: token,\n      line: token.line,\n      previousToken: this._lexer.previousToken,\n    };\n    this._callback(err);\n    this._callback = noop;\n  }\n\n  // ### `_resolveIRI` resolves an IRI against the base path\n  _resolveIRI(iri) {\n    return /^[a-z][a-z0-9+.-]*:/i.test(iri) ? iri : this._resolveRelativeIRI(iri);\n  }\n\n  // ### `_resolveRelativeIRI` resolves an IRI against the base path,\n  // assuming that a base path has been set and that the IRI is indeed relative\n  _resolveRelativeIRI(iri) {\n    // An empty relative IRI indicates the base IRI\n    if (!iri.length)\n      return this._base;\n    // Decide resolving strategy based in the first character\n    switch (iri[0]) {\n    // Resolve relative fragment IRIs against the base IRI\n    case '#': return this._base + iri;\n    // Resolve relative query string IRIs by replacing the query string\n    case '?': return this._base.replace(/(?:\\?.*)?$/, iri);\n    // Resolve root-relative IRIs at the root of the base IRI\n    case '/':\n      // Resolve scheme-relative IRIs to the scheme\n      return (iri[1] === '/' ? this._baseScheme : this._baseRoot) + this._removeDotSegments(iri);\n    // Resolve all other IRIs at the base IRI's path\n    default:\n      // Relative IRIs cannot contain a colon in the first path segment\n      return (/^[^/:]*:/.test(iri)) ? null : this._removeDotSegments(this._basePath + iri);\n    }\n  }\n\n  // ### `_removeDotSegments` resolves './' and '../' path segments in an IRI as per RFC3986\n  _removeDotSegments(iri) {\n    // Don't modify the IRI if it does not contain any dot segments\n    if (!/(^|\\/)\\.\\.?($|[/#?])/.test(iri))\n      return iri;\n\n    // Start with an imaginary slash before the IRI in order to resolve trailing './' and '../'\n    const length = iri.length;\n    let result = '', i = -1, pathStart = -1, segmentStart = 0, next = '/';\n\n    while (i < length) {\n      switch (next) {\n      // The path starts with the first slash after the authority\n      case ':':\n        if (pathStart < 0) {\n          // Skip two slashes before the authority\n          if (iri[++i] === '/' && iri[++i] === '/')\n            // Skip to slash after the authority\n            while ((pathStart = i + 1) < length && iri[pathStart] !== '/')\n              i = pathStart;\n        }\n        break;\n      // Don't modify a query string or fragment\n      case '?':\n      case '#':\n        i = length;\n        break;\n      // Handle '/.' or '/..' path segments\n      case '/':\n        if (iri[i + 1] === '.') {\n          next = iri[++i + 1];\n          switch (next) {\n          // Remove a '/.' segment\n          case '/':\n            result += iri.substring(segmentStart, i - 1);\n            segmentStart = i + 1;\n            break;\n          // Remove a trailing '/.' segment\n          case undefined:\n          case '?':\n          case '#':\n            return result + iri.substring(segmentStart, i) + iri.substr(i + 1);\n          // Remove a '/..' segment\n          case '.':\n            next = iri[++i + 1];\n            if (next === undefined || next === '/' || next === '?' || next === '#') {\n              result += iri.substring(segmentStart, i - 2);\n              // Try to remove the parent path from result\n              if ((segmentStart = result.lastIndexOf('/')) >= pathStart)\n                result = result.substr(0, segmentStart);\n              // Remove a trailing '/..' segment\n              if (next !== '/')\n                return `${result}/${iri.substr(i + 1)}`;\n              segmentStart = i + 1;\n            }\n          }\n        }\n      }\n      next = iri[++i];\n    }\n    return result + iri.substring(segmentStart);\n  }\n\n  // ## Public methods\n\n  // ### `parse` parses the N3 input and emits each parsed quad through the callback\n  parse(input, quadCallback, prefixCallback) {\n    // The read callback is the next function to be executed when a token arrives.\n    // We start reading in the top context.\n    this._readCallback = this._readInTopContext;\n    this._sparqlStyle = false;\n    this._prefixes = Object.create(null);\n    this._prefixes._ = this._blankNodePrefix ? this._blankNodePrefix.substr(2)\n                                             : `b${blankNodePrefix++}_`;\n    this._prefixCallback = prefixCallback || noop;\n    this._inversePredicate = false;\n    this._quantified = Object.create(null);\n\n    // Parse synchronously if no quad callback is given\n    if (!quadCallback) {\n      const quads = [];\n      let error;\n      this._callback = (e, t) => { e ? (error = e) : t && quads.push(t); };\n      this._lexer.tokenize(input).every(token => {\n        return this._readCallback = this._readCallback(token);\n      });\n      if (error) throw error;\n      return quads;\n    }\n\n    // Parse asynchronously otherwise, executing the read callback when a token arrives\n    this._callback = quadCallback;\n    this._lexer.tokenize(input, (error, token) => {\n      if (error !== null)\n        this._callback(error), this._callback = noop;\n      else if (this._readCallback)\n        this._readCallback = this._readCallback(token);\n    });\n  }\n}\n\n// The empty function\nfunction noop() {}\n\n// Initializes the parser with the given data factory\nfunction initDataFactory(parser, factory) {\n  // Set factory methods\n  const namedNode = factory.namedNode;\n  parser._namedNode   = namedNode;\n  parser._blankNode   = factory.blankNode;\n  parser._literal     = factory.literal;\n  parser._variable    = factory.variable;\n  parser._quad        = factory.quad;\n  parser.DEFAULTGRAPH = factory.defaultGraph();\n\n  // Set common named nodes\n  parser.RDF_FIRST  = namedNode(namespaces.rdf.first);\n  parser.RDF_REST   = namedNode(namespaces.rdf.rest);\n  parser.RDF_NIL    = namedNode(namespaces.rdf.nil);\n  parser.N3_FORALL  = namedNode(namespaces.r.forAll);\n  parser.N3_FORSOME = namedNode(namespaces.r.forSome);\n  parser.ABBREVIATIONS = {\n    'a': namedNode(namespaces.rdf.type),\n    '=': namedNode(namespaces.owl.sameAs),\n    '>': namedNode(namespaces.log.implies),\n  };\n  parser.QUANTIFIERS_GRAPH = namedNode('urn:n3:quantifiers');\n}\ninitDataFactory(N3Parser.prototype, N3DataFactory);\n","//  RDFa Parser for rdflib.js\n\n// Originally by: Alex Milowski\n// From https://github.com/alexmilowski/green-turtle\n// Converted: timbl 2015-08-25 not yet working\n// Added wrapper: csarven 2016-05-09 working\n\n// RDFaProcessor.prototype = new Object() // Was URIResolver\n\n// RDFaProcessor.prototype.constructor=RDFaProcessor\n\n// options.base = base URI    not really an option, shopuld always be set.\n//\n\nimport BlankNode from './blank-node'\nimport Literal from './literal'\nimport NamedNode from './named-node'\nimport * as Uri from './uri'\nimport * as Util from './utils-js'\nimport rdf from './factories/canonical-data-factory'\n\nif (typeof Node === 'undefined') { //  @@@@@@ Global. Interface to xmldom.\n  var Node = {\n    ELEMENT_NODE: 1,\n    ATTRIBUTE_NODE: 2,\n    TEXT_NODE: 3,\n    CDATA_SECTION_NODE: 4,\n    ENTITY_REFERENCE_NODE: 5,\n    ENTITY_NODE: 6,\n    PROCESSING_INSTRUCTION_NODE: 7,\n    COMMENT_NODE: 8,\n    DOCUMENT_NODE: 9,\n    DOCUMENT_TYPE_NODE: 10,\n    DOCUMENT_FRAGMENT_NODE: 11,\n    NOTATION_NODE: 12\n  }\n}\n\nexport default class RDFaProcessor {\n  constructor (kb, options) {\n    this.options = options || {}\n    this.kb = kb\n    this.target = options.target || {\n      graph: {\n        subjects: {},\n        prefixes: {},\n        terms: {}\n      }\n    }\n    // XXX: Added to track bnodes\n    this.blankNodes = []\n    // XXX: Added for normalisation\n    this.htmlOptions = {\n      'selfClosing': 'br img input area base basefont col colgroup source wbr isindex link meta param hr'\n    }\n    this.theOne = '_:' + (new Date()).getTime()\n    this.language = null\n    this.vocabulary = null\n    this.blankCounter = 0\n    this.langAttributes = [ { namespaceURI: 'http://www.w3.org/XML/1998/namespace', localName: 'lang' } ]\n    this.inXHTMLMode = false\n    this.absURIRE = /[\\w\\_\\-]+:\\S+/\n    this.finishedHandlers = []\n    this.init()\n  }\n\n  addTriple (origin, subject, predicate, object) {\n    var su, ob, pr, or\n    if (typeof subject === 'undefined') {\n      su = rdf.namedNode(this.options.base)\n    } else {\n      su = this.toRDFNodeObject(subject)\n    }\n    pr = this.toRDFNodeObject(predicate)\n    ob = this.toRDFNodeObject(object)\n    or = rdf.namedNode(this.options.base)\n    // console.log('Adding { ' + su + ' ' + pr + ' ' + ob + ' ' + or + ' }')\n    this.kb.add(su, pr, ob, or)\n  }\n\n  ancestorPath (node) {\n    var path = ''\n    while (node && node.nodeType !== Node.DOCUMENT_NODE) {\n      path = '/' + node.localName + path\n      node = node.parentNode\n    }\n    return path\n  }\n\n  copyMappings (mappings) {\n    var newMappings = {}\n    for (var k in mappings) {\n      newMappings[k] = mappings[k]\n    }\n    return newMappings\n  }\n\n  copyProperties () {\n  }\n\n  deriveDateTimeType (value) {\n    for (var i = 0; i < RDFaProcessor.dateTimeTypes.length; i++) {\n      // console.log(\"Checking \"+value+\" against \"+RDFaProcessor.dateTimeTypes[i].type)\n      var matched = RDFaProcessor.dateTimeTypes[i].pattern.exec(value)\n      if (matched && matched[0].length === value.length) {\n        // console.log(\"Matched!\")\n        return RDFaProcessor.dateTimeTypes[i].type\n      }\n    }\n    return null\n  }\n\n  init () {\n  }\n\n  newBlankNode () {\n    this.blankCounter++\n    return '_:' + this.blankCounter\n  }\n\n  newSubjectOrigin (origin, subject) {\n  }\n\n  parseCURIE (value, prefixes, base) {\n    var colon = value.indexOf(':')\n    var uri\n    if (colon >= 0) {\n      var prefix = value.substring(0, colon)\n      if (prefix === '') {\n        // default prefix\n        uri = prefixes['']\n        return uri ? uri + value.substring(colon + 1) : null\n      } else if (prefix === '_') {\n        // blank node\n        return '_:' + value.substring(colon + 1)\n      } else if (RDFaProcessor.NCNAME.test(prefix)) {\n        uri = prefixes[prefix]\n        if (uri) {\n          return uri + value.substring(colon + 1)\n        }\n      }\n    }\n    return null\n  }\n\n  parseCURIEOrURI (value, prefixes, base) {\n    var curie = this.parseCURIE(value, prefixes, base)\n    if (curie) {\n      return curie\n    }\n    return this.resolveAndNormalize(base, value)\n  }\n\n  parsePredicate (value, defaultVocabulary, terms, prefixes, base,\n                  ignoreTerms) {\n    if (value === '') {\n      return null\n    }\n    var predicate = this.parseTermOrCURIEOrAbsURI(value, defaultVocabulary, ignoreTerms ? null : terms, prefixes, base)\n    if (predicate && predicate.indexOf('_:') === 0) {\n      return null\n    }\n    return predicate\n  }\n\n  parsePrefixMappings (str, target) {\n    var values = this.tokenize(str)\n    var prefix = null\n    // var uri = null\n    for (var i = 0; i < values.length; i++) {\n      if (values[i][values[i].length - 1] === ':') {\n        prefix = values[i].substring(0, values[i].length - 1)\n      } else if (prefix) {\n        target[prefix] = this.options.base ? Uri.join(values[i], this.options.base) : values[i]\n        prefix = null\n      }\n    }\n  }\n\n  static parseRDFaDOM (dom, kb, base) {\n    var p = new RDFaProcessor(kb, { 'base': base })\n    //  Cannot assign to read only property 'baseURI' of object '#<XMLDocument>':\n    if (!dom.baseURI) { // Note this became a read-only attribute some time before 2018\n      dom.baseURI = base // oinly set if not already set\n    }\n    p.process(dom, { baseURI: base})\n  }\n\n  parseSafeCURIEOrCURIEOrURI (value, prefixes, base) {\n    value = this.trim(value)\n    if (value.charAt(0) === '[' && value.charAt(value.length - 1) === ']') {\n      value = value.substring(1, value.length - 1)\n      value = value.trim(value)\n      if (value.length === 0) {\n        return null\n      }\n      if (value === '_:') {\n        // the one node\n        return this.theOne\n      }\n      return this.parseCURIE(value, prefixes, base)\n    } else {\n      return this.parseCURIEOrURI(value, prefixes, base)\n    }\n  }\n\n  parseTermOrCURIEOrAbsURI (value, defaultVocabulary, terms, prefixes, base) {\n    // alert(\"Parsing \"+value+\" with default vocab \"+defaultVocabulary)\n    value = this.trim(value)\n    var curie = this.parseCURIE(value, prefixes, base)\n    if (curie) {\n      return curie\n    } else if (terms) {\n      if (defaultVocabulary && !this.absURIRE.exec(value)) {\n        return defaultVocabulary + value\n      }\n      var term = terms[value]\n      if (term) {\n        return term\n      }\n      var lcvalue = value.toLowerCase()\n      term = terms[lcvalue]\n      if (term) {\n        return term\n      }\n    }\n    if (this.absURIRE.exec(value)) {\n      return this.resolveAndNormalize(base, value)\n    }\n    return null\n  }\n\n  parseTermOrCURIEOrURI (value, defaultVocabulary, terms, prefixes, base) {\n    // alert(\"Parsing \"+value+\" with default vocab \"+defaultVocabulary)\n    value = this.trim(value)\n    var curie = this.parseCURIE(value, prefixes, base)\n    if (curie) {\n      return curie\n    } else {\n      var term = terms[value]\n      if (term) {\n        return term\n      }\n      var lcvalue = value.toLowerCase()\n      term = terms[lcvalue]\n      if (term) {\n        return term\n      }\n      if (defaultVocabulary && !this.absURIRE.exec(value)) {\n        return defaultVocabulary + value\n      }\n    }\n    return this.resolveAndNormalize(base, value)\n  }\n\n  parseURI (uri) {\n    return uri // We just use strings as URIs, not objects now.\n  }\n\n  process (node, options) {\n    /*\n    if (!window.console) {\n       window.console = { log: function() {} }\n    } */\n    options = options || {}\n    var base\n    if (node.nodeType === Node.DOCUMENT_NODE) {\n      if (node.baseURI && !options.baseURI) {\n        options.baseURI = node.baseURI  // be defensive as DOM implementations vary\n      }\n      base = node.baseURI\n      node = node.documentElement\n      if (!node.baseURI) {\n        node.baseURI = base\n      }\n      this.setContext(node)\n    } else if (node.parentNode.nodeType === Node.DOCUMENT_NODE) {\n      this.setContext(node)\n    }\n    var queue = []\n    // Fix for Firefox that includes the hash in the base URI\n    var removeHash = function (baseURI) {\n      // Fix for undefined baseURI property\n      if (!baseURI && options && options.baseURI) {\n        return options.baseURI\n      }\n\n      var hash = baseURI.indexOf('#')\n      if (hash >= 0) {\n        baseURI = baseURI.substring(0, hash)\n      }\n      if (options && options.baseURIMap) {\n        baseURI = options.baseURIMap(baseURI)\n      }\n      return baseURI\n    }\n    queue.push({ current: node,\n      context: this.push(null, removeHash(node.baseURI))\n    })\n    while (queue.length > 0) {\n      var item = queue.shift()\n      if (item.parent) {\n        // Sequence Step 14: list triple generation\n        if (item.context.parent && item.context.parent.listMapping === item.listMapping) {\n          // Skip a child context with exactly the same mapping\n          continue\n        }\n        // console.log(\"Generating lists for \"+item.subject+\", tag \"+item.parent.localName)\n        for (let predicate in item.listMapping) {\n          var list = item.listMapping[predicate]\n          if (list.length === 0) {\n            this.addTriple(item.parent, item.subject, predicate, { type: RDFaProcessor.objectURI, value: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil' })\n            continue\n          }\n          var bnodes = []\n          for (let i = 0; i < list.length; i++) {\n            bnodes.push(this.newBlankNode())\n          // this.newSubject(item.parent,bnodes[i])\n          }\n          for (let i = 0; i < bnodes.length; i++) {\n            this.addTriple(item.parent, bnodes[i], 'http://www.w3.org/1999/02/22-rdf-syntax-ns#first', list[i])\n            this.addTriple(item.parent, bnodes[i], 'http://www.w3.org/1999/02/22-rdf-syntax-ns#rest', { type: RDFaProcessor.objectURI, value: (i + 1) < bnodes.length ? bnodes[i + 1] : 'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil' })\n          }\n          this.addTriple(item.parent, item.subject, predicate, { type: RDFaProcessor.objectURI, value: bnodes[0] })\n        }\n        continue\n      }\n      var current = item.current\n      var context = item.context\n      // console.log(\"Tag: \"+current.localName+\", listMapping=\"+JSON.stringify(context.listMapping))\n      // Sequence Step 1\n      var skip = false\n      var newSubject = null\n      var currentObjectResource = null\n      var typedResource = null\n      var prefixes = context.prefixes\n      var prefixesCopied = false\n      var incomplete = []\n      var listMapping = context.listMapping\n      var listMappingDifferent = !context.parent\n      var language = context.language\n      var vocabulary = context.vocabulary\n      // TODO: the \"base\" element may be used for HTML+RDFa 1.1\n      base = this.parseURI(removeHash(current.baseURI))\n      current.item = null\n      // Sequence Step 2: set the default vocabulary\n      var vocabAtt = current.getAttributeNode('vocab')\n      if (vocabAtt) {\n        let value = this.trim(vocabAtt.value)\n        if (value.length > 0) {\n          vocabulary = value\n          var baseSubject = base.spec\n          // this.newSubject(current,baseSubject)\n          this.addTriple(current, baseSubject, 'http://www.w3.org/ns/rdfa#usesVocabulary', { type: RDFaProcessor.objectURI, value: vocabulary })\n        } else {\n          vocabulary = this.vocabulary\n        }\n      }\n      // Sequence Step 3: IRI mappings\n      // handle xmlns attributes\n      for (var i = 0; i < current.attributes.length; i++) {\n        var att = current.attributes[i]\n        // if (att.namespaceURI==\"http://www.w3.org/2000/xmlns/\") {\n        if (att.nodeName.charAt(0) === 'x' && att.nodeName.indexOf('xmlns:') === 0) {\n          if (!prefixesCopied) {\n            prefixes = this.copyMappings(prefixes)\n            prefixesCopied = true\n          }\n          var prefix = att.nodeName.substring(6)\n          // TODO: resolve relative?\n          var ref = RDFaProcessor.trim(att.value)\n          prefixes[prefix] = this.options.base ? Uri.join(ref, this.options.base) : ref\n        }\n      }\n      // Handle prefix mappings (@prefix)\n      var prefixAtt = current.getAttributeNode('prefix')\n      if (prefixAtt) {\n        if (!prefixesCopied) {\n          prefixes = this.copyMappings(prefixes)\n          prefixesCopied = true\n        }\n        this.parsePrefixMappings(prefixAtt.value, prefixes)\n      }\n      // Sequence Step 4: language\n      var xmlLangAtt = null\n      for (let i = 0; !xmlLangAtt && i < this.langAttributes.length; i++) {\n        xmlLangAtt = current.getAttributeNodeNS(this.langAttributes[i].namespaceURI, this.langAttributes[i].localName)\n      }\n      if (xmlLangAtt) {\n        let value = RDFaProcessor.trim(xmlLangAtt.value)\n        if (value.length > 0) {\n          language = value\n        } else {\n          language = null\n        }\n      }\n      var relAtt = current.getAttributeNode('rel')\n      var revAtt = current.getAttributeNode('rev')\n      var typeofAtt = current.getAttributeNode('typeof')\n      var propertyAtt = current.getAttributeNode('property')\n      var datatypeAtt = current.getAttributeNode('datatype')\n      var datetimeAtt = this.inHTMLMode\n        ? current.getAttributeNode('datetime')\n        : null\n      var contentAtt = current.getAttributeNode('content')\n      var aboutAtt = current.getAttributeNode('about')\n      var srcAtt = current.getAttributeNode('src')\n      var resourceAtt = current.getAttributeNode('resource')\n      var hrefAtt = current.getAttributeNode('href')\n      var inlistAtt = current.getAttributeNode('inlist')\n      var relAttPredicates = []\n      var predicate, values\n      if (relAtt) {\n        values = this.tokenize(relAtt.value)\n        for (let i = 0; i < values.length; i++) {\n          predicate = this.parsePredicate(values[i], vocabulary, context.terms, prefixes, base, this.inHTMLMode && propertyAtt !== null)\n          if (predicate) {\n            relAttPredicates.push(predicate)\n          }\n        }\n      }\n      var revAttPredicates = []\n      if (revAtt) {\n        values = this.tokenize(revAtt.value)\n        for (let i = 0; i < values.length; i++) {\n          predicate = this.parsePredicate(values[i], vocabulary, context.terms, prefixes, base, this.inHTMLMode && propertyAtt)\n          if (predicate) {\n            revAttPredicates.push(predicate)\n          }\n        }\n      }\n      // Section 3.1, bullet 7\n      if (this.inHTMLMode && (relAtt || revAtt) && propertyAtt) {\n        if (relAttPredicates.length === 0) {\n          relAtt = null\n        }\n        if (revAttPredicates.length === 0) {\n          revAtt = null\n        }\n      }\n      if (relAtt || revAtt) {\n        // Sequence Step 6: establish new subject and value\n        if (aboutAtt) {\n          newSubject = this.parseSafeCURIEOrCURIEOrURI(aboutAtt.value, prefixes, base)\n        }\n        if (typeofAtt) {\n          typedResource = newSubject\n        }\n        if (!newSubject) {\n          if (current.parentNode.nodeType === Node.DOCUMENT_NODE) {\n            newSubject = removeHash(current.baseURI)\n          } else if (context.parentObject) {\n            // TODO: Verify: If the xml:base has been set and the parentObject is the baseURI of the parent, then the subject needs to be the new base URI\n            newSubject = removeHash(current.parentNode.baseURI) === context.parentObject ? removeHash(current.baseURI) : context.parentObject\n          }\n        }\n        if (resourceAtt) {\n          currentObjectResource = this.parseSafeCURIEOrCURIEOrURI(resourceAtt.value, prefixes, base)\n        }\n        if (!currentObjectResource) {\n          if (hrefAtt) {\n            currentObjectResource = this.resolveAndNormalize(base, encodeURI(hrefAtt.value))\n          } else if (srcAtt) {\n            currentObjectResource = this.resolveAndNormalize(base, encodeURI(srcAtt.value))\n          } else if (typeofAtt && !aboutAtt && !(this.inXHTMLMode && (current.localName === 'head' || current.localName === 'body'))) {\n            currentObjectResource = this.newBlankNode()\n          }\n        }\n        if (typeofAtt && !aboutAtt && this.inXHTMLMode && (current.localName === 'head' || current.localName === 'body')) {\n          typedResource = newSubject\n        } else if (typeofAtt && !aboutAtt) {\n          typedResource = currentObjectResource\n        }\n      } else if (propertyAtt && !contentAtt && !datatypeAtt) {\n        // Sequence Step 5.1: establish a new subject\n        if (aboutAtt) {\n          newSubject = this.parseSafeCURIEOrCURIEOrURI(aboutAtt.value, prefixes, base)\n          if (typeofAtt) {\n            typedResource = newSubject\n          }\n        }\n        if (!newSubject && current.parentNode.nodeType === Node.DOCUMENT_NODE) {\n          newSubject = removeHash(current.baseURI)\n          if (typeofAtt) {\n            typedResource = newSubject\n          }\n        } else if (!newSubject && context.parentObject) {\n          // TODO: Verify: If the xml:base has been set and the parentObject is the baseURI of the parent, then the subject needs to be the new base URI\n          newSubject = removeHash(current.parentNode.baseURI) === context.parentObject ? removeHash(current.baseURI) : context.parentObject\n        }\n        if (typeofAtt && !typedResource) {\n          if (resourceAtt) {\n            typedResource = this.parseSafeCURIEOrCURIEOrURI(resourceAtt.value, prefixes, base)\n          }\n          if (!typedResource && hrefAtt) {\n            typedResource = this.resolveAndNormalize(base, encodeURI(hrefAtt.value))\n          }\n          if (!typedResource && srcAtt) {\n            typedResource = this.resolveAndNormalize(base, encodeURI(srcAtt.value))\n          }\n          if (!typedResource && (this.inXHTMLMode || this.inHTMLMode) && (current.localName === 'head' || current.localName === 'body')) {\n            typedResource = newSubject\n          }\n          if (!typedResource) {\n            typedResource = this.newBlankNode()\n          }\n          currentObjectResource = typedResource\n        }\n      // console.log(current.localName+\", newSubject=\"+newSubject+\", typedResource=\"+typedResource+\", currentObjectResource=\"+currentObjectResource)\n      } else {\n        // Sequence Step 5.2: establish a new subject\n        if (aboutAtt) {\n          newSubject = this.parseSafeCURIEOrCURIEOrURI(aboutAtt.value, prefixes, base)\n        }\n        if (!newSubject && resourceAtt) {\n          newSubject = this.parseSafeCURIEOrCURIEOrURI(resourceAtt.value, prefixes, base)\n        }\n        if (!newSubject && hrefAtt) {\n          newSubject = this.resolveAndNormalize(base, encodeURI(hrefAtt.value))\n        }\n        if (!newSubject && srcAtt) {\n          newSubject = this.resolveAndNormalize(base, encodeURI(srcAtt.value))\n        }\n        if (!newSubject) {\n          if (current.parentNode.nodeType === Node.DOCUMENT_NODE) {\n            newSubject = removeHash(current.baseURI)\n          } else if ((this.inXHTMLMode || this.inHTMLMode) && (current.localName === 'head' || current.localName === 'body')) {\n            newSubject = removeHash(current.parentNode.baseURI) === context.parentObject ? removeHash(current.baseURI) : context.parentObject\n          } else if (typeofAtt) {\n            newSubject = this.newBlankNode()\n          } else if (context.parentObject) {\n            // TODO: Verify: If the xml:base has been set and the parentObject is the baseURI of the parent, then the subject needs to be the new base URI\n            newSubject = removeHash(current.parentNode.baseURI) === context.parentObject ? removeHash(current.baseURI) : context.parentObject\n            if (!propertyAtt) {\n              skip = true\n            }\n          }\n        }\n        if (typeofAtt) {\n          typedResource = newSubject\n        }\n      }\n      // console.log(current.tagName+\": newSubject=\"+newSubject+\", currentObjectResource=\"+currentObjectResource+\", typedResource=\"+typedResource+\", skip=\"+skip)\n      // var rdfaData = null\n      if (newSubject) {\n        // this.newSubject(current,newSubject)\n        if (aboutAtt || resourceAtt || typedResource) {\n          var id = newSubject\n          if (typeofAtt && !aboutAtt && !resourceAtt && currentObjectResource) {\n            id = currentObjectResource\n          }\n          // console.log(\"Setting data attribute for \"+current.localName+\" for subject \"+id)\n          this.newSubjectOrigin(current, id)\n        }\n      }\n      // Sequence Step 7: generate type triple\n      if (typedResource) {\n        values = this.tokenize(typeofAtt.value)\n        for (let i = 0; i < values.length; i++) {\n          var object = this.parseTermOrCURIEOrAbsURI(values[i], vocabulary, context.terms, prefixes, base)\n          if (object) {\n            this.addTriple(current, typedResource, RDFaProcessor.typeURI, { type: RDFaProcessor.objectURI, value: object })\n          }\n        }\n      }\n      // Sequence Step 8: new list mappings if there is a new subject\n      // console.log(\"Step 8: newSubject=\"+newSubject+\", context.parentObject=\"+context.parentObject)\n      if (newSubject && newSubject !== context.parentObject) {\n        // console.log(\"Generating new list mapping for \"+newSubject)\n        listMapping = {}\n        listMappingDifferent = true\n      }\n      // Sequence Step 9: generate object triple\n      if (currentObjectResource) {\n        if (relAtt && inlistAtt) {\n          for (let i = 0; i < relAttPredicates.length; i++) {\n            let list = listMapping[relAttPredicates[i]]\n            if (!list) {\n              list = []\n              listMapping[relAttPredicates[i]] = list\n            }\n            list.push({ type: RDFaProcessor.objectURI, value: currentObjectResource })\n          }\n        } else if (relAtt) {\n          for (let i = 0; i < relAttPredicates.length; i++) {\n            this.addTriple(current, newSubject, relAttPredicates[i], { type: RDFaProcessor.objectURI, value: currentObjectResource })\n          }\n        }\n        if (revAtt) {\n          for (let i = 0; i < revAttPredicates.length; i++) {\n            this.addTriple(current, currentObjectResource, revAttPredicates[i], { type: RDFaProcessor.objectURI, value: newSubject })\n          }\n        }\n      } else {\n        // Sequence Step 10: incomplete triples\n        if (newSubject && !currentObjectResource && (relAtt || revAtt)) {\n          currentObjectResource = this.newBlankNode()\n        // alert(current.tagName+\": generated blank node, newSubject=\"+newSubject+\" currentObjectResource=\"+currentObjectResource)\n        }\n        if (relAtt && inlistAtt) {\n          for (let i = 0; i < relAttPredicates.length; i++) {\n            let list = listMapping[relAttPredicates[i]]\n            if (!list) {\n              list = []\n              listMapping[predicate] = list\n            }\n            // console.log(\"Adding incomplete list for \"+predicate)\n            incomplete.push({ predicate: relAttPredicates[i], list: list })\n          }\n        } else if (relAtt) {\n          for (let i = 0; i < relAttPredicates.length; i++) {\n            incomplete.push({ predicate: relAttPredicates[i], forward: true })\n          }\n        }\n        if (revAtt) {\n          for (let i = 0; i < revAttPredicates.length; i++) {\n            incomplete.push({ predicate: revAttPredicates[i], forward: false })\n          }\n        }\n      }\n      // Step 11: Current property values\n      if (propertyAtt) {\n        var datatype = null\n        var content = null\n        if (datatypeAtt) {\n          datatype = datatypeAtt.value === '' ? RDFaProcessor.PlainLiteralURI : this.parseTermOrCURIEOrAbsURI(datatypeAtt.value, vocabulary, context.terms, prefixes, base)\n          if (datetimeAtt && !contentAtt) {\n            content = datetimeAtt.value\n          } else {\n            content = datatype === RDFaProcessor.XMLLiteralURI || datatype === RDFaProcessor.HTMLLiteralURI ? null : (contentAtt ? contentAtt.value : current.textContent)\n          }\n        } else if (contentAtt) {\n          datatype = RDFaProcessor.PlainLiteralURI\n          content = contentAtt.value\n        } else if (datetimeAtt) {\n          content = datetimeAtt.value\n          datatype = RDFaProcessor.deriveDateTimeType(content)\n          if (!datatype) {\n            datatype = RDFaProcessor.PlainLiteralURI\n          }\n        } else if (!relAtt && !revAtt) {\n          if (resourceAtt) {\n            content = this.parseSafeCURIEOrCURIEOrURI(resourceAtt.value, prefixes, base)\n          }\n          if (!content && hrefAtt) {\n            content = this.resolveAndNormalize(base, encodeURI(hrefAtt.value))\n          } else if (!content && srcAtt) {\n            content = this.resolveAndNormalize(base, encodeURI(srcAtt.value))\n          }\n          if (content) {\n            datatype = RDFaProcessor.objectURI\n          }\n        }\n        if (!datatype) {\n          if (typeofAtt && !aboutAtt) {\n            datatype = RDFaProcessor.objectURI\n            content = typedResource\n          } else {\n            content = current.textContent\n            if (this.inHTMLMode && current.localName === 'time') {\n              datatype = RDFaProcessor.deriveDateTimeType(content)\n            }\n            if (!datatype) {\n              datatype = RDFaProcessor.PlainLiteralURI\n            }\n          }\n        }\n        values = this.tokenize(propertyAtt.value)\n        for (let i = 0; i < values.length; i++) {\n          let predicate = this.parsePredicate(values[i], vocabulary, context.terms, prefixes, base)\n          if (predicate) {\n            if (inlistAtt) {\n              let list = listMapping[predicate]\n              if (!list) {\n                list = []\n                listMapping[predicate] = list\n              }\n              list.push((datatype === RDFaProcessor.XMLLiteralURI || datatype === RDFaProcessor.HTMLLiteralURI) ? { type: datatype, value: current.childNodes } : { type: datatype || RDFaProcessor.PlainLiteralURI, value: content, language: language })\n            } else {\n              if (datatype === RDFaProcessor.XMLLiteralURI || datatype === RDFaProcessor.HTMLLiteralURI) {\n                this.addTriple(current, newSubject, predicate, { type: datatype, value: current.childNodes })\n              } else {\n                this.addTriple(current, newSubject, predicate, { type: datatype || RDFaProcessor.PlainLiteralURI, value: content, language: language })\n              // console.log(newSubject+\" \"+predicate+\"=\"+content)\n              }\n            }\n          }\n        }\n      }\n      // Sequence Step 12: complete incomplete triples with new subject\n      if (newSubject && !skip) {\n        for (let i = 0; i < context.incomplete.length; i++) {\n          if (context.incomplete[i].list) {\n            // console.log(\"Adding subject \"+newSubject+\" to list for \"+context.incomplete[i].predicate)\n            // TODO: it is unclear what to do here\n            context.incomplete[i].list.push({ type: RDFaProcessor.objectURI, value: newSubject })\n          } else if (context.incomplete[i].forward) {\n            // console.log(current.tagName+\": completing forward triple \"+context.incomplete[i].predicate+\" with object=\"+newSubject)\n            this.addTriple(current, context.subject, context.incomplete[i].predicate, { type: RDFaProcessor.objectURI, value: newSubject })\n          } else {\n            // console.log(current.tagName+\": completing reverse triple with object=\"+context.subject)\n            this.addTriple(current, newSubject, context.incomplete[i].predicate, { type: RDFaProcessor.objectURI, value: context.subject })\n          }\n        }\n      }\n      var childContext = null\n      var listSubject = newSubject\n      if (skip) {\n        // TODO: should subject be null?\n        childContext = this.push(context, context.subject)\n        // TODO: should the entObject be passed along?  If not, then intermediary children will keep properties from being associated with incomplete triples.\n        // TODO: Verify: if the current baseURI has changed and the parentObject is the parent's base URI, then the baseURI should change\n        childContext.parentObject = removeHash(current.parentNode.baseURI) === context.parentObject ? removeHash(current.baseURI) : context.parentObject\n        childContext.incomplete = context.incomplete\n        childContext.language = language\n        childContext.prefixes = prefixes\n        childContext.vocabulary = vocabulary\n      } else {\n        childContext = this.push(context, newSubject)\n        childContext.parentObject = currentObjectResource || (newSubject || context.subject)\n        childContext.prefixes = prefixes\n        childContext.incomplete = incomplete\n        if (currentObjectResource) {\n          // console.log(\"Generating new list mapping for \"+currentObjectResource)\n          listSubject = currentObjectResource\n          listMapping = {}\n          listMappingDifferent = true\n        }\n        childContext.listMapping = listMapping\n        childContext.language = language\n        childContext.vocabulary = vocabulary\n      }\n      if (listMappingDifferent) {\n        // console.log(\"Pushing list parent \"+current.localName)\n        queue.unshift({ parent: current, context: context, subject: listSubject, listMapping: listMapping })\n      }\n      for (var child = current.lastChild; child; child = child.previousSibling) {\n        if (child.nodeType === Node.ELEMENT_NODE) {\n          // console.log(\"Pushing child \"+child.localName)\n          // child.baseURI = current.baseURI\n          queue.unshift({ current: child, context: childContext })\n        }\n      }\n    }\n    if (this.inHTMLMode) {\n      this.copyProperties()\n    }\n    for (let i = 0; i < this.finishedHandlers.length; i++) {\n      this.finishedHandlers[i](node)\n    }\n  }\n\n  push (parent, subject) {\n    return {\n      parent: parent,\n      subject: subject || (parent ? parent.subject : null),\n      parentObject: null,\n      incomplete: [],\n      listMapping: parent ? parent.listMapping : {},\n      language: parent ? parent.language : this.language,\n      prefixes: parent ? parent.prefixes : this.target.graph.prefixes,\n      terms: parent ? parent.terms : this.target.graph.terms,\n      vocabulary: parent ? parent.vocabulary : this.vocabulary\n    }\n  }\n\n  resolveAndNormalize (base, uri) {\n    // console.log(\"Joining \" + uri + \" to \" + base + \" making \" +  Uri.join(uri, base))\n    return Uri.join(uri, base) // @@ normalize?\n  }\n\n  setContext (node) {\n    // We only recognized XHTML+RDFa 1.1 if the version is set propertyly\n    if (node.localName === 'html' && node.getAttribute('version') === 'XHTML+RDFa 1.1') {\n      this.setXHTMLContext()\n    } else if (node.localName === 'html' || node.namespaceURI === 'http://www.w3.org/1999/xhtml') {\n      if (typeof document !== 'undefined' && document.doctype) {\n        if (document.doctype.publicId === '-//W3C//DTD XHTML+RDFa 1.0//EN' && document.doctype.systemId === 'http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd') {\n          console.log('WARNING: RDF 1.0 is not supported.  Defaulting to HTML5 mode.')\n          this.setHTMLContext()\n        } else if (document.doctype.publicId === '-//W3C//DTD XHTML+RDFa 1.1//EN' && document.doctype.systemId === 'http://www.w3.org/MarkUp/DTD/xhtml-rdfa-2.dtd') {\n          this.setXHTMLContext()\n        } else {\n          this.setHTMLContext()\n        }\n      } else {\n        this.setHTMLContext()\n      }\n    } else {\n      this.setXMLContext()\n    }\n  }\n\n  setHTMLContext () {\n    this.setInitialContext()\n    this.langAttributes = [\n      {\n        namespaceURI: 'http://www.w3.org/XML/1998/namespace',\n        localName: 'lang'\n      },\n      { namespaceURI: null, localName: 'lang' }\n    ]\n    this.inXHTMLMode = false\n    this.inHTMLMode = true\n  }\n\n  setInitialContext () {\n    this.vocabulary = null\n    // By default, the prefixes are terms are loaded to the RDFa 1.1. standard within the graph constructor\n    this.langAttributes = [\n      {\n        namespaceURI: 'http://www.w3.org/XML/1998/namespace',\n        localName: 'lang'\n      }\n    ]\n  }\n\n  setXHTMLContext () {\n    this.setInitialContext()\n    this.inXHTMLMode = true\n    this.inHTMLMode = false\n    this.langAttributes = [\n      {\n        namespaceURI: 'http://www.w3.org/XML/1998/namespace',\n        localName: 'lang' },\n      { namespaceURI: null, localName: 'lang' }\n    ]\n    // From http://www.w3.org/2011/rdfa-context/xhtml-rdfa-1.1\n    this.target.graph.terms['alternate'] = 'http://www.w3.org/1999/xhtml/vocab#alternate'\n    this.target.graph.terms['appendix'] = 'http://www.w3.org/1999/xhtml/vocab#appendix'\n    this.target.graph.terms['bookmark'] = 'http://www.w3.org/1999/xhtml/vocab#bookmark'\n    this.target.graph.terms['cite'] = 'http://www.w3.org/1999/xhtml/vocab#cite'\n    this.target.graph.terms['chapter'] = 'http://www.w3.org/1999/xhtml/vocab#chapter'\n    this.target.graph.terms['contents'] = 'http://www.w3.org/1999/xhtml/vocab#contents'\n    this.target.graph.terms['copyright'] = 'http://www.w3.org/1999/xhtml/vocab#copyright'\n    this.target.graph.terms['first'] = 'http://www.w3.org/1999/xhtml/vocab#first'\n    this.target.graph.terms['glossary'] = 'http://www.w3.org/1999/xhtml/vocab#glossary'\n    this.target.graph.terms['help'] = 'http://www.w3.org/1999/xhtml/vocab#help'\n    this.target.graph.terms['icon'] = 'http://www.w3.org/1999/xhtml/vocab#icon'\n    this.target.graph.terms['index'] = 'http://www.w3.org/1999/xhtml/vocab#index'\n    this.target.graph.terms['last'] = 'http://www.w3.org/1999/xhtml/vocab#last'\n    this.target.graph.terms['license'] = 'http://www.w3.org/1999/xhtml/vocab#license'\n    this.target.graph.terms['meta'] = 'http://www.w3.org/1999/xhtml/vocab#meta'\n    this.target.graph.terms['next'] = 'http://www.w3.org/1999/xhtml/vocab#next'\n    this.target.graph.terms['prev'] = 'http://www.w3.org/1999/xhtml/vocab#prev'\n    this.target.graph.terms['previous'] = 'http://www.w3.org/1999/xhtml/vocab#previous'\n    this.target.graph.terms['section'] = 'http://www.w3.org/1999/xhtml/vocab#section'\n    this.target.graph.terms['stylesheet'] = 'http://www.w3.org/1999/xhtml/vocab#stylesheet'\n    this.target.graph.terms['subsection'] = 'http://www.w3.org/1999/xhtml/vocab#subsection'\n    this.target.graph.terms['start'] = 'http://www.w3.org/1999/xhtml/vocab#start'\n    this.target.graph.terms['top'] = 'http://www.w3.org/1999/xhtml/vocab#top'\n    this.target.graph.terms['up'] = 'http://www.w3.org/1999/xhtml/vocab#up'\n    this.target.graph.terms['p3pv1'] = 'http://www.w3.org/1999/xhtml/vocab#p3pv1'\n    // other\n    this.target.graph.terms['related'] = 'http://www.w3.org/1999/xhtml/vocab#related'\n    this.target.graph.terms['role'] = 'http://www.w3.org/1999/xhtml/vocab#role'\n    this.target.graph.terms['transformation'] = 'http://www.w3.org/1999/xhtml/vocab#transformation'\n  }\n\n  setXMLContext () {\n    this.setInitialContext()\n    this.inXHTMLMode = false\n    this.inHTMLMode = false\n  }\n\n  tokenize (str) {\n    return this.trim(str).split(/\\s+/)\n  }\n  static tokenize (str) {\n    return this.trim(str).split(/\\s+/)\n  }\n\n  toRDFNodeObject (x) {\n    if (typeof x === 'undefined') return undefined\n    if (typeof x === 'string') {\n      if (x.substring(0, 2) === '_:') {\n        if (typeof this.blankNodes[x.substring(2)] === 'undefined') {\n          this.blankNodes[x.substring(2)] = new BlankNode(x.substring(2))\n        }\n        return this.blankNodes[x.substring(2)]\n      }\n      return rdf.namedNode(x)\n    }\n    switch (x.type) {\n      case RDFaProcessor.objectURI:\n        if (x.value.substring(0, 2) === '_:') {\n          if (typeof this.blankNodes[x.value.substring(2)] === 'undefined') {\n            this.blankNodes[x.value.substring(2)] = new BlankNode(x.value.substring(2))\n          }\n          return this.blankNodes[x.value.substring(2)]\n        }\n        return rdf.namedNode(x.value)\n      case RDFaProcessor.PlainLiteralURI:\n        return new Literal(x.value, x.language || '')\n      case RDFaProcessor.XMLLiteralURI:\n      case RDFaProcessor.HTMLLiteralURI:\n        var string = ''\n        Object.keys(x.value).forEach(i => {\n          string += Util.domToString(x.value[i], this.htmlOptions)\n        })\n        return new Literal(string, '', new NamedNode(x.type))\n      default:\n        return new Literal(x.value, '', new NamedNode(x.type))\n    }\n  }\n\n  trim (str) {\n    return str.replace(/^\\s\\s*/, '').replace(/\\s\\s*$/, '')\n  }\n  static trim (str) {\n    return str.replace(/^\\s\\s*/, '').replace(/\\s\\s*$/, '')\n  }\n}\n\nRDFaProcessor.XMLLiteralURI =\n  'http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral'\nRDFaProcessor.HTMLLiteralURI = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#HTML'\nRDFaProcessor.PlainLiteralURI =\n  'http://www.w3.org/1999/02/22-rdf-syntax-ns#PlainLiteral'\nRDFaProcessor.objectURI = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#object'\nRDFaProcessor.typeURI = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type'\nRDFaProcessor.nameChar =\n  '[-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\\u10000-\\uEFFFF\\.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]'\nRDFaProcessor.nameStartChar =\n  '[\\u0041-\\u005A\\u0061-\\u007A\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u00FF\\u0100-\\u0131\\u0134-\\u013E\\u0141-\\u0148\\u014A-\\u017E\\u0180-\\u01C3\\u01CD-\\u01F0\\u01F4-\\u01F5\\u01FA-\\u0217\\u0250-\\u02A8\\u02BB-\\u02C1\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03CE\\u03D0-\\u03D6\\u03DA\\u03DC\\u03DE\\u03E0\\u03E2-\\u03F3\\u0401-\\u040C\\u040E-\\u044F\\u0451-\\u045C\\u045E-\\u0481\\u0490-\\u04C4\\u04C7-\\u04C8\\u04CB-\\u04CC\\u04D0-\\u04EB\\u04EE-\\u04F5\\u04F8-\\u04F9\\u0531-\\u0556\\u0559\\u0561-\\u0586\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0621-\\u063A\\u0641-\\u064A\\u0671-\\u06B7\\u06BA-\\u06BE\\u06C0-\\u06CE\\u06D0-\\u06D3\\u06D5\\u06E5-\\u06E6\\u0905-\\u0939\\u093D\\u0958-\\u0961\\u0985-\\u098C\\u098F-\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09DC-\\u09DD\\u09DF-\\u09E1\\u09F0-\\u09F1\\u0A05-\\u0A0A\\u0A0F-\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32-\\u0A33\\u0A35-\\u0A36\\u0A38-\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8B\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2-\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AE0\\u0B05-\\u0B0C\\u0B0F-\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32-\\u0B33\\u0B36-\\u0B39\\u0B3D\\u0B5C-\\u0B5D\\u0B5F-\\u0B61\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99-\\u0B9A\\u0B9C\\u0B9E-\\u0B9F\\u0BA3-\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB5\\u0BB7-\\u0BB9\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C60-\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CDE\\u0CE0-\\u0CE1\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D28\\u0D2A-\\u0D39\\u0D60-\\u0D61\\u0E01-\\u0E2E\\u0E30\\u0E32-\\u0E33\\u0E40-\\u0E45\\u0E81-\\u0E82\\u0E84\\u0E87-\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA-\\u0EAB\\u0EAD-\\u0EAE\\u0EB0\\u0EB2-\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0F40-\\u0F47\\u0F49-\\u0F69\\u10A0-\\u10C5\\u10D0-\\u10F6\\u1100\\u1102-\\u1103\\u1105-\\u1107\\u1109\\u110B-\\u110C\\u110E-\\u1112\\u113C\\u113E\\u1140\\u114C\\u114E\\u1150\\u1154-\\u1155\\u1159\\u115F-\\u1161\\u1163\\u1165\\u1167\\u1169\\u116D-\\u116E\\u1172-\\u1173\\u1175\\u119E\\u11A8\\u11AB\\u11AE-\\u11AF\\u11B7-\\u11B8\\u11BA\\u11BC-\\u11C2\\u11EB\\u11F0\\u11F9\\u1E00-\\u1E9B\\u1EA0-\\u1EF9\\u1F00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2126\\u212A-\\u212B\\u212E\\u2180-\\u2182\\u3041-\\u3094\\u30A1-\\u30FA\\u3105-\\u312C\\uAC00-\\uD7A3\\u4E00-\\u9FA5\\u3007\\u3021-\\u3029_]'\nRDFaProcessor.NCNAME = new RegExp('^' + RDFaProcessor.nameStartChar +\n  RDFaProcessor.nameChar + '*$')\n\n/*\nRDFaProcessor.prototype.resolveAndNormalize = function(base,href) {\n   var u = base.resolve(href)\n   var parsed = this.parseURI(u)\n   parsed.normalize()\n   return parsed.spec\n}\n*/\n\nRDFaProcessor.dateTimeTypes = [\n  { pattern: /-?P(?:[0-9]+Y)?(?:[0-9]+M)?(?:[0-9]+D)?(?:T(?:[0-9]+H)?(?:[0-9]+M)?(?:[0-9]+(?:\\.[0-9]+)?S)?)?/,\n    type: 'http://www.w3.org/2001/XMLSchema#duration' },\n  { pattern: /-?(?:[1-9][0-9][0-9][0-9]|0[1-9][0-9][0-9]|00[1-9][0-9]|000[1-9])-[0-9][0-9]-[0-9][0-9]T(?:[0-1][0-9]|2[0-4]):[0-5][0-9]:[0-5][0-9](?:\\.[0-9]+)?(?:Z|[+\\-][0-9][0-9]:[0-9][0-9])?/,\n    type: 'http://www.w3.org/2001/XMLSchema#dateTime' },\n  { pattern: /-?(?:[1-9][0-9][0-9][0-9]|0[1-9][0-9][0-9]|00[1-9][0-9]|000[1-9])-[0-9][0-9]-[0-9][0-9](?:Z|[+\\-][0-9][0-9]:[0-9][0-9])?/,\n    type: 'http://www.w3.org/2001/XMLSchema#date' },\n  { pattern: /(?:[0-1][0-9]|2[0-4]):[0-5][0-9]:[0-5][0-9](?:\\.[0-9]+)?(?:Z|[+\\-][0-9][0-9]:[0-9][0-9])?/,\n    type: 'http://www.w3.org/2001/XMLSchema#time' },\n  { pattern: /-?(?:[1-9][0-9][0-9][0-9]|0[1-9][0-9][0-9]|00[1-9][0-9]|000[1-9])-[0-9][0-9]/,\n    type: 'http://www.w3.org/2001/XMLSchema#gYearMonth' },\n  { pattern: /-?[1-9][0-9][0-9][0-9]|0[1-9][0-9][0-9]|00[1-9][0-9]|000[1-9]/,\n    type: 'http://www.w3.org/2001/XMLSchema#gYear' }\n]\n\nconst parseRDFaDOM = RDFaProcessor.parseRDFaDOM\nexport { parseRDFaDOM }\n","/**\n *  RDF/XML PARSER\n *\n *  Parser believed to be in full positive RDF/XML parsing compliance\n *  with the possible exception of handling deprecated RDF attributes\n *  appropriately. Parser is believed to comply fully with other W3C\n *  and industry standards where appropriate (DOM, ECMAScript, &c.)\n *\n *  Author: David Sheets <dsheets@mit.edu>\n *\n * W3C® SOFTWARE NOTICE AND LICENSE\n * http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231\n * This work (and included software, documentation such as READMEs, or\n * other related items) is being provided by the copyright holders under\n * the following license. By obtaining, using and/or copying this work,\n * you (the licensee) agree that you have read, understood, and will\n * comply with the following terms and conditions.\n *\n * Permission to copy, modify, and distribute this software and its\n * documentation, with or without modification, for any purpose and\n * without fee or royalty is hereby granted, provided that you include\n * the following on ALL copies of the software and documentation or\n * portions thereof, including modifications:\n *\n * 1. The full text of this NOTICE in a location viewable to users of\n * the redistributed or derivative work.\n * 2. Any pre-existing intellectual property disclaimers, notices, or terms and\n * conditions. If none exist, the W3C Software Short Notice should be\n * included (hypertext is preferred, text is permitted) within the body\n * of any redistributed or derivative code.\n * 3. Notice of any changes or modifications to the files, including the\n * date changes were made. (We recommend you provide URIs to the location\n * from which the code is derived.)\n *\n * THIS SOFTWARE AND DOCUMENTATION IS PROVIDED \"AS IS,\" AND COPYRIGHT\n * HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED,\n * INCLUDING BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR FITNESS\n * FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE OR\n * DOCUMENTATION WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS,\n * TRADEMARKS OR OTHER RIGHTS.\n *\n * COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL\n * OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE OR\n * DOCUMENTATION.\n *\n * The name and trademarks of copyright holders may NOT be used in\n * advertising or publicity pertaining to the software without specific,\n * written prior permission. Title to copyright in this software and any\n * associated documentation will at all times remain with copyright\n * holders.\n */\n/**\n * @class RDFParser resource object tied to an RDFStore\n *\n * @author David Sheets <dsheets@mit.edu>\n *\n*/\nimport * as uriUtil from './uri'\n\n\nexport default class RDFParser {\n\n  /*\n   * @constructor\n   * @param {RDFStore} store An RDFStore object\n   */\n  constructor(store) {\n    /** Our triple store reference @private */\n\n    this.store = store /** Our identified blank nodes @private */\n    this.bnodes = {} /** A context for context-aware stores @private */\n    this.why = null /** Reification flag */\n    this.reify = false\n  }\n\n  /** Standard namespaces that we know how to handle @final\n   *  @member RDFParser\n   */\n  static ns = {'RDF': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#', 'RDFS': 'http://www.w3.org/2000/01/rdf-schema#'}\n\n  /** DOM Level 2 node type magic numbers @final\n   *  @member RDFParser\n   */\n  static nodeType = {'ELEMENT': 1, 'ATTRIBUTE': 2, 'TEXT': 3,\n    'CDATA_SECTION': 4, 'ENTITY_REFERENCE': 5,\n    'ENTITY': 6, 'PROCESSING_INSTRUCTION': 7,\n    'COMMENT': 8, 'DOCUMENT': 9, 'DOCUMENT_TYPE': 10,\n  'DOCUMENT_FRAGMENT': 11, 'NOTATION': 12}\n\n  /**\n   * Frame class for namespace and base URI lookups\n   * Base lookups will always resolve because the parser knows\n   * the default base.\n   *\n   * @private\n   */\n\n  frameFactory(parser, parent, element) {\n    return {'NODE': 1, 'ARC': 2, 'parent': parent, 'parser': parser, 'store': parser.store, 'element': element,\n      'lastChild': 0, 'base': null, 'lang': null, 'node': null, 'nodeType': null, 'listIndex': 1, 'rdfid': null, 'datatype': null, 'collection': false, /** Terminate the frame and notify the store that we're done */\n      'terminateFrame': function () {\n        if (this.collection) {\n          this.node.close()\n        }\n      },         /** Add a symbol of a certain type to the this frame */'addSymbol': function (type, uri) {\n        uri = uriUtil.join(uri, this.base)\n        this.node = this.store.sym(uri)\n\n        this.nodeType = type\n      },         /** Load any constructed triples into the store */'loadTriple': function () {\n        if (this.parent.parent.collection) {\n          this.parent.parent.node.append(this.node)\n        } else {\n          this.store.add(this.parent.parent.node, this.parent.node, this.node, this.parser.why)\n        }\n        if (this.parent.rdfid != null) {\n          // reify\n          var triple = this.store.sym(uriUtil.join('#' + this.parent.rdfid, this.base))\n          this.store.add(triple, this.store.sym(RDFParser.ns.RDF + 'type'), this.store.sym(RDFParser.ns.RDF + 'Statement'), this.parser.why)\n          this.store.add(triple, this.store.sym(RDFParser.ns.RDF + 'subject'), this.parent.parent.node, this.parser.why)\n          this.store.add(triple, this.store.sym(RDFParser.ns.RDF + 'predicate'), this.parent.node, this.parser.why)\n\n          this.store.add(triple, this.store.sym(RDFParser.ns.RDF + 'object'), this.node, this.parser.why)\n        }\n      },         /** Check if it's OK to load a triple */'isTripleToLoad': function () {\n        return (this.parent != null && this.parent.parent != null && this.nodeType === this.NODE && this.parent.nodeType ===\n        this.ARC && this.parent.parent.nodeType === this.NODE)\n      },         /** Add a symbolic node to this frame */'addNode': function (uri) {\n        this.addSymbol(this.NODE, uri)\n        if (this.isTripleToLoad()) {\n          this.loadTriple()\n        }\n      },         /** Add a collection node to this frame */'addCollection': function () {\n        this.nodeType = this.NODE\n        this.node = this.store.collection()\n        this.collection = true\n        if (this.isTripleToLoad()) {\n          this.loadTriple()\n        }\n      },         /** Add a collection arc to this frame */'addCollectionArc': function () {\n        this.nodeType = this.ARC\n      },         /** Add a bnode to this frame */'addBNode': function (id) {\n        if (id != null) {\n          if (this.parser.bnodes[id] != null) {\n            this.node = this.parser.bnodes[id]\n          } else {\n            this.node = this.parser.bnodes[id] = this.store.bnode()\n          }\n        } else {\n          this.node = this.store.bnode()\n        }\n        this.nodeType = this.NODE\n        if (this.isTripleToLoad()) {\n          this.loadTriple()\n        }\n      },         /** Add an arc or property to this frame */'addArc': function (uri) {\n        if (uri === RDFParser.ns.RDF + 'li') {\n          uri = RDFParser.ns.RDF + '_' + this.parent.listIndex\n          this.parent.listIndex++\n        }\n\n        this.addSymbol(this.ARC, uri)\n      },         /** Add a literal to this frame */'addLiteral': function (value) {\n        if (this.parent.datatype && this.parent.datatype !== RDFParser.ns.RDF +'langString') {\n          this.node = this.store.literal(value, this.store.sym(this.parent.datatype))\n        } else {\n          this.node = this.store.literal(value, this.lang)\n        }\n        this.nodeType = this.NODE\n        if (this.isTripleToLoad()) {\n          this.loadTriple()\n        }\n      }\n    }\n  }\n\n  // from the OpenLayers source .. needed to get around IE problems.\n  getAttributeNodeNS(node, uri, name) {\n    var attributeNode = null\n    if (node.getAttributeNodeNS) {\n      attributeNode = node.getAttributeNodeNS(uri, name)\n    } else {\n      var attributes = node.attributes\n      var potentialNode, fullName\n      for (var i = 0;i < attributes.length; ++i) {\n        potentialNode = attributes[i]\n        if (potentialNode.namespaceURI === uri) {\n          fullName = (potentialNode.prefix) ? (potentialNode.prefix + ':' + name) : name\n          if (fullName === potentialNode.nodeName) {\n            attributeNode = potentialNode\n            break\n          }\n        }\n      }\n    }\n    return attributeNode\n  }\n\n  /**\n   * Build our initial scope frame and parse the DOM into triples\n   * @param {HTMLDocument} document The DOM to parse\n   * @param {String} base The base URL to use\n   * @param {Object} why The context to which this resource belongs\n   */\n\n  parse(document, base, why) {\n    var children = document.childNodes // clean up for the next run\n    this.cleanParser() // figure out the root element\n    var root\n    if (document.nodeType === RDFParser.nodeType.DOCUMENT) {\n      for (var c = 0;c < children.length;c++) {\n        if (children[c].nodeType === RDFParser.nodeType.ELEMENT) {\n          root = children[c]\n          break\n        }\n      }\n    } else if (document.nodeType === RDFParser.nodeType.ELEMENT) {\n      root = document\n    } else {\n      throw new Error(\"RDFParser: can't find root in \" + base + '. Halting. ')\n    // return false\n    }\n    this.why = why // our topmost frame\n    var f = this.frameFactory(this)\n    this.base = base\n    f.base = base\n    f.lang = null // was '' but can't have langs like that 2015 (!)\n    this.parseDOM(this.buildFrame(f, root))\n    return true\n  }\n\n  parseDOM(frame) {\n    // a DOM utility function used in parsing\n    var rdfid\n    var elementURI = function (el) {\n      var result = ''\n      if (el.namespaceURI == null) {\n        throw new Error('RDF/XML syntax error: No namespace for ' + el.localName + ' in ' + this.base)\n      }\n      if (el.namespaceURI) {\n        result = result + el.namespaceURI\n      }\n      if (el.localName) {\n        result = result + el.localName\n      } else if (el.nodeName) {\n        if (el.nodeName.indexOf(':') >= 0)result = result + el.nodeName.split(':')[1]\n        else result = result + el.nodeName\n      }\n      return result\n    }.bind(this)\n    var dig = true // if we'll dig down in the tree on the next iter\n    while (frame.parent) {\n      var dom = frame.element\n      var attrs = dom.attributes\n      if (dom.nodeType === RDFParser.nodeType.TEXT || dom.nodeType === RDFParser.nodeType.CDATA_SECTION) {\n        // we have a literal\n        if (frame.parent.nodeType === frame.NODE) {\n          // must have had attributes, store as rdf:value\n          frame.addArc(RDFParser.ns.RDF + 'value')\n          frame = this.buildFrame(frame)\n        }\n        frame.addLiteral(dom.nodeValue)\n      } else if (elementURI(dom) !== RDFParser.ns.RDF + 'RDF') {\n        // not root\n        if (frame.parent && frame.parent.collection) {\n          // we're a collection element\n          frame.addCollectionArc()\n          frame = this.buildFrame(frame, frame.element)\n          frame.parent.element = null\n        }\n        if (!frame.parent || !frame.parent.nodeType || frame.parent.nodeType === frame.ARC) {\n          // we need a node\n          var about = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'about')\n          rdfid = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'ID')\n          if (about && rdfid) {\n            throw new Error('RDFParser: ' + dom.nodeName + ' has both rdf:id and rdf:about.' +\n              ' Halting. Only one of these' + ' properties may be specified on a' + ' node.')\n          }\n          if (!about && rdfid) {\n            frame.addNode('#' + rdfid.nodeValue)\n            dom.removeAttributeNode(rdfid)\n          } else if (about == null && rdfid == null) {\n            var bnid = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'nodeID')\n            if (bnid) {\n              frame.addBNode(bnid.nodeValue)\n              dom.removeAttributeNode(bnid)\n            } else {\n              frame.addBNode()\n            }\n          } else {\n            frame.addNode(about.nodeValue)\n            dom.removeAttributeNode(about)\n          }\n          // Typed nodes\n          var rdftype = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'type')\n          if (RDFParser.ns.RDF + 'Description' !== elementURI(dom)) {\n            rdftype = {'nodeValue': elementURI(dom)}\n          }\n          if (rdftype != null) {\n            this.store.add(frame.node, this.store.sym(RDFParser.ns.RDF + 'type'), this.store.sym(uriUtil.join(rdftype.nodeValue,\n              frame.base)), this.why)\n            if (rdftype.nodeName) {\n              dom.removeAttributeNode(rdftype)\n            }\n          }\n          // Property Attributes\n          for (var x = attrs.length - 1; x >= 0; x--) {\n            this.store.add(frame.node, this.store.sym(elementURI(attrs[x])), this.store.literal(attrs[x].nodeValue,\n              frame.lang), this.why)\n          }\n        } else {\n          // we should add an arc (or implicit bnode+arc)\n          frame.addArc(elementURI(dom)) // save the arc's rdf:ID if it has one\n          if (this.reify) {\n            rdfid = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'ID')\n            if (rdfid) {\n              frame.rdfid = rdfid.nodeValue\n              dom.removeAttributeNode(rdfid)\n            }\n          }\n          var parsetype = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'parseType')\n          var datatype = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'datatype')\n          if (datatype) {\n            frame.datatype = datatype.nodeValue\n            dom.removeAttributeNode(datatype)\n          }\n          if (parsetype) {\n            var nv = parsetype.nodeValue\n            if (nv === 'Literal') {\n              frame.datatype = RDFParser.ns.RDF + 'XMLLiteral'\n              frame = this.buildFrame(frame)\n              // Don't include the literal node, only its children\n              // see https://github.com/linkeddata/rdflib.js/issues/75\n              frame.addLiteral(dom.innerHTML || dom.childNodes)\n              dig = false\n            } else if (nv === 'Resource') {\n              frame = this.buildFrame(frame, frame.element)\n              frame.parent.element = null\n              frame.addBNode()\n            } else if (nv === 'Collection') {\n              frame = this.buildFrame(frame, frame.element)\n              frame.parent.element = null\n              frame.addCollection()\n            }\n            dom.removeAttributeNode(parsetype)\n          }\n          if (attrs.length !== 0) {\n            var resource = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'resource')\n            var bnid2 = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'nodeID')\n            frame = this.buildFrame(frame)\n            if (resource) {\n              frame.addNode(resource.nodeValue)\n              dom.removeAttributeNode(resource)\n            } else {\n              if (bnid2) {\n                frame.addBNode(bnid2.nodeValue)\n                dom.removeAttributeNode(bnid2)\n              } else {\n                frame.addBNode()\n              }\n            }\n            for (var x1 = attrs.length - 1; x1 >= 0; x1--) {\n              var f = this.buildFrame(frame)\n              f.addArc(elementURI(attrs[x1]))\n              if (elementURI(attrs[x1]) === RDFParser.ns.RDF + 'type') {\n                (this.buildFrame(f)).addNode(attrs[x1].nodeValue)\n              } else {\n                (this.buildFrame(f)).addLiteral(attrs[x1].nodeValue)\n              }\n            }\n          } else if (dom.childNodes.length === 0) {\n            (this.buildFrame(frame)).addLiteral('')\n          }\n        }\n      } // rdf:RDF\n      // dig dug\n      dom = frame.element\n      while (frame.parent) {\n        var pframe = frame\n        while (dom == null) {\n          frame = frame.parent\n          dom = frame.element\n        }\n        var candidate = dom.childNodes && dom.childNodes[frame.lastChild]\n        if (!candidate || !dig) {\n          frame.terminateFrame()\n          if (!(frame = frame.parent)) {\n            break\n          } // done\n          dom = frame.element\n          dig = true\n        } else if ((candidate.nodeType !== RDFParser.nodeType.ELEMENT &&\n          candidate.nodeType !== RDFParser.nodeType.TEXT &&\n          candidate.nodeType !== RDFParser.nodeType.CDATA_SECTION) ||\n          ((candidate.nodeType === RDFParser.nodeType.TEXT ||\n          candidate.nodeType === RDFParser.nodeType.CDATA_SECTION) &&\n          dom.childNodes.length !== 1)) {\n          frame.lastChild++\n        } else {\n          // not a leaf\n          frame.lastChild++\n          frame = this.buildFrame(pframe, dom.childNodes[frame.lastChild - 1])\n          break\n        }\n      }\n    } // while\n  }\n\n  /**\n   * Cleans out state from a previous parse run\n   * @private\n   */\n  cleanParser() {\n    this.bnodes = {}\n    this.why = null\n  }\n\n  /**\n   * Builds scope frame\n   * @private\n   */\n  buildFrame(parent, element) {\n    var frame = this.frameFactory(this, parent, element)\n    if (parent) {\n      frame.base = parent.base\n      frame.lang = parent.lang\n    }\n    if (!element || element.nodeType === RDFParser.nodeType.TEXT ||\n      element.nodeType === RDFParser.nodeType.CDATA_SECTION) {\n      return frame\n    }\n    var attrs = element.attributes\n    var base = element.getAttributeNode('xml:base')\n    if (base != null) {\n      frame.base = base.nodeValue\n      element.removeAttribute('xml:base')\n    }\n    var lang = element.getAttributeNode('xml:lang')\n    if (lang != null) {\n      frame.lang = lang.nodeValue\n      element.removeAttribute('xml:lang')\n    }\n    // remove all extraneous xml and xmlns attributes\n    for (var x = attrs.length - 1;x >= 0;x--) {\n      if (attrs[x].nodeName.substr(0, 3) === 'xml') {\n        if (attrs[x].name.slice(0, 6) === 'xmlns:') {\n          var uri = attrs[x].nodeValue // alert('base for namespac attr:'+this.base)\n          if (this.base) uri = uriUtil.join(uri, this.base)\n          this.store.setPrefixForURI(attrs[x].name.slice(6), uri)\n        }\n        //\t\talert('rdfparser: xml atribute: '+attrs[x].name) //@@\n        element.removeAttributeNode(attrs[x])\n      }\n    }\n    return frame\n  }\n}\n","// Parse a simple SPARL-Update subset syntax for patches.\n//\n//  This parses\n//   WHERE {xxx} DELETE {yyy} INSERT DATA {zzz}\n// (not necessarily in that order)\n// as though it were the n3\n//   <#query> patch:where {xxx}; patch:delete {yyy}; patch:insert {zzz}.\nimport N3Parser from './n3parser'\nimport Namespace from './namespace'\n\nexport default function sparqlUpdateParser (str, kb, base) {\n  var i, j, k\n  var keywords = [ 'INSERT', 'DELETE', 'WHERE' ]\n  var SQNS = Namespace('http://www.w3.org/ns/pim/patch#')\n  var p = N3Parser(kb, kb, base, base, null, null, '', null)\n  var clauses = {}\n\n  var badSyntax = function (uri, lines, str, i, why) {\n    return ('Line ' + (lines + 1) + ' of <' + uri + '>: Bad syntax:\\n   ' +\n    why + '\\n   at: \"' + str.slice(i, (i + 30)) + '\"')\n  }\n\n  // var check = function (next, last, message) {\n  //   if (next < 0) {\n  //     throw badSyntax(p._thisDoc, p.lines, str, j, last, message)\n  //   }\n  //   return next\n  // }\n  i = 0\n  var query = kb.sym(base + '#query') // Invent a URI for the query\n  clauses['query'] = query // A way of accessing it in its N3 model.\n\n  while (true) {\n    // console.log(\"A Now at i = \" + i)\n    j = p.skipSpace(str, i)\n    if (j < 0) {\n      return clauses\n    }\n    // console.log(\"B After space at j= \" + j)\n    if (str[j] === ';') {\n      i = p.skipSpace(str, j + 1)\n      if (i < 0) {\n        return clauses // Allow end in a\n      }\n      j = i\n    }\n    var found = false\n    for (k = 0; k < keywords.length; k++) {\n      var key = keywords[k]\n      if (str.slice(j, j + key.length) === key) {\n        i = p.skipSpace(str, j + key.length)\n        if (i < 0) {\n          throw badSyntax(p._thisDoc, p.lines, str, j + key.length, 'found EOF, needed {...} after ' + key)\n        }\n        if (((key === 'INSERT') || (key === 'DELETE')) && str.slice(i, i + 4) === 'DATA') { // Some wanted 'DATA'. Whatever\n          j = p.skipSpace(str, i + 4)\n          if (j < 0) {\n            throw badSyntax(p._thisDoc, p.lines, str, i + 4, 'needed {...} after INSERT DATA ' + key)\n          }\n          i = j\n        }\n        var res2 = []\n        j = p.node(str, i, res2) // Parse all the complexity of the clause\n\n        if (j < 0) {\n          throw badSyntax(p._thisDoc, p.lines, str, i,\n            'bad syntax or EOF in {...} after ' + key)\n        }\n        clauses[key.toLowerCase()] = res2[0]\n        kb.add(query, SQNS(key.toLowerCase()), res2[0]) // , kb.sym(base)\n        // key is the keyword and res2 has the contents\n        found = true\n        i = j\n      }\n    }\n    if (!found && str.slice(j, j + 7) === '@prefix') {\n      i = p.directive(str, j)\n      if (i < 0) {\n        throw badSyntax(p._thisDoc, p.lines, str, i,\n          'bad syntax or EOF after @prefix ')\n      }\n      // console.log(\"P before dot i= \" + i)\n      i = p.checkDot(str, i)\n      // console.log(\"Q after dot i= \" + i)\n      found = true\n    }\n    if (!found) {\n      // console.log(\"Bad syntax \" + j)\n      throw badSyntax(p._thisDoc, p.lines, str, j,\n        \"Unknown syntax at start of statememt: '\" + str.slice(j).slice(0, 20) + \"'\")\n    }\n  } // while\n// return clauses\n}\n","import DataFactory from './factories/extended-term-factory'\nimport jsonldParser from './jsonldparser'\n// @ts-ignore is this injected?\nimport { Parser as N3jsParser } from 'n3'  // @@ Goal: remove this dependency\nimport N3Parser from './n3parser'\nimport { parseRDFaDOM } from './rdfaparser'\nimport RDFParser from './rdfxmlparser'\nimport sparqlUpdateParser from './patch-parser'\nimport * as Util from './utils-js'\nimport Formula from './formula'\nimport { ContentType, TurtleContentType, N3ContentType, RDFXMLContentType, XHTMLContentType, HTMLContentType, SPARQLUpdateContentType, SPARQLUpdateSingleMatchContentType, JSONLDContentType, NQuadsContentType, NQuadsAltContentType } from './types'\nimport { Quad } from './tf-types'\n\ntype CallbackFunc = (error: any, kb: Formula | null) => void\n\n/**\n * Parse a string and put the result into the graph kb.\n * Normal method is sync.\n * Unfortunately jsdonld is currently written to need to be called async.\n * Hence the mess below with executeCallback.\n * @param str - The input string to parse\n * @param kb - The store to use\n * @param base - The base URI to use\n * @param contentType - The MIME content type string for the input - defaults to text/turtle\n * @param [callback] - The callback to call when the data has been loaded\n */\nexport default function parse (\n  str: string,\n  kb: Formula,\n  base: string,\n  contentType: string | ContentType = 'text/turtle',\n  callback?: CallbackFunc\n) {\n  contentType = contentType || TurtleContentType\n  contentType = contentType.split(';')[0] as ContentType\n  try {\n    if (contentType === N3ContentType || contentType === TurtleContentType) {\n      var p = N3Parser(kb, kb, base, base, null, null, '', null)\n      p.loadBuf(str)\n      executeCallback()\n    } else if (contentType === RDFXMLContentType) {\n      var parser = new RDFParser(kb)\n      parser.parse(Util.parseXML(str), base, kb.sym(base))\n      executeCallback()\n    } else if (contentType === XHTMLContentType) {\n      parseRDFaDOM(Util.parseXML(str, {contentType: XHTMLContentType}), kb, base)\n      executeCallback()\n    } else if (contentType === HTMLContentType) {\n      parseRDFaDOM(Util.parseXML(str, {contentType: HTMLContentType}), kb, base)\n      executeCallback()\n    } else if ((contentType === SPARQLUpdateContentType) || (contentType === SPARQLUpdateSingleMatchContentType)) { // @@ we handle a subset\n      sparqlUpdateParser(str, kb, base)\n      executeCallback()\n    } else if (contentType === JSONLDContentType) {\n      jsonldParser(str, kb, base, executeCallback)\n    } else if (contentType === NQuadsContentType ||\n               contentType === NQuadsAltContentType) {\n      var n3Parser = new N3jsParser({ factory: DataFactory })\n      nquadCallback(null, str)\n    } else if (contentType === undefined) {\n      throw new Error(\"contentType is undefined\")\n    } else {\n      throw new Error(\"Don't know how to parse \" + contentType + ' yet')\n    }\n  } catch (e) {\n    // @ts-ignore\n    executeErrorCallback(e)\n  }\n\n  (parse as any).handled= {\n    'text/n3': true,\n    'text/turtle': true,\n    'application/rdf+xml': true,\n    'application/xhtml+xml': true,\n    'text/html': true,\n    'application/sparql-update': true,\n    'application/sparql-update-single-match': true,\n    'application/ld+json': true,\n    'application/nquads' : true,\n    'application/n-quads' : true\n  }\n\n  function executeCallback () {\n    if (callback) {\n      callback(null, kb)\n    } else {\n      return\n    }\n  }\n\n  function executeErrorCallback (e: Error): void {\n    if (\n      // TODO: Always true, what is the right behavior\n      contentType !== JSONLDContentType ||\n      // @ts-ignore always true?\n      contentType !== NQuadsContentType ||\n      // @ts-ignore always true?\n      contentType !== NQuadsAltContentType\n    ) {\n      if (callback) {\n        callback(e, kb)\n      } else {\n        let e2 = new Error('' + e + ' while trying to parse <' + base + '> as ' + contentType)\n        //@ts-ignore .cause is not a default error property\n        e2.cause = e\n        throw e2\n      }\n    }\n  }\n/*\n  function setJsonLdBase (doc, base) {\n    if (doc instanceof Array) {\n      return\n    }\n    if (!('@context' in doc)) {\n      doc['@context'] = {}\n    }\n    doc['@context']['@base'] = base\n  }\n*/\n  function nquadCallback (err?: Error | null, nquads?: string): void {\n    if (err) {\n      (callback as CallbackFunc)(err, kb)\n    }\n    try {\n      n3Parser.parse(nquads, tripleCallback)\n    } catch (err) {\n      (callback as CallbackFunc)(err, kb)\n    }\n  }\n\n  function tripleCallback (err: Error, triple: Quad) {\n    if (triple) {\n      kb.add(triple.subject, triple.predicate, triple.object, triple.graph)\n    } else {\n      (callback as CallbackFunc)(err, kb)\n    }\n  }\n}\n","/* global $SolidTestEnvironment */\n/**\n *\n * Project: rdflib.js\n *\n * @file: fetcher.js\n *\n * Description: contains functions for requesting/fetching/retracting\n *  This implements quite a lot of the web architecture.\n * A fetcher is bound to a specific quad store, into which\n * it loads stuff and into which it writes its metadata\n * @@ The metadata could be optionally a separate graph\n *\n * - implements semantics of HTTP headers, Internet Content Types\n * - selects parsers for rdf/xml, n3, rdfa, grddl\n *\n * TO do:\n * - Implement a runtime registry for parsers and serializers\n * -\n */\n\n/**\n * Things to test: callbacks on request, refresh, retract\n *   loading from HTTP, HTTPS, FTP, FILE, others?\n * To do:\n * Firing up a mail client for mid:  (message:) URLs\n */\nimport IndexedFormula from './store'\nimport log from './log'\nimport N3Parser from './n3parser'\nimport RDFlibNamedNode from './named-node'\nimport Namespace from './namespace'\nimport rdfParse from './parse'\nimport { parseRDFaDOM } from './rdfaparser'\nimport RDFParser from './rdfxmlparser'\nimport * as Uri from './uri'\nimport { isCollection, isNamedNode} from './utils/terms'\nimport * as Util from './utils-js'\nimport serialize from './serialize'\nimport crossFetch, { Headers } from 'cross-fetch'\n\nimport {\n  ContentType, TurtleContentType, RDFXMLContentType, XHTMLContentType\n} from './types'\nimport { termValue } from './utils/termValue'\nimport {\n  BlankNode,\n  RdfJsDataFactory,\n  Quad_Graph,\n  NamedNode,\n  Quad_Predicate,\n  Quad_Subject\n} from './tf-types'\nimport jsonldParser from './jsonldparser'\n\nconst Parsable = {\n  'text/n3': true,\n  'text/turtle': true,\n  'application/rdf+xml': true,\n  'application/xhtml+xml': true,\n  'text/html': true,\n  'application/ld+json': true\n}\n\n// This is a minimal set to allow the use of damaged servers if necessary\nconst CONTENT_TYPE_BY_EXT = {\n  'rdf': RDFXMLContentType,\n  'owl': RDFXMLContentType,\n  'n3': 'text/n3',\n  'ttl': 'text/turtle',\n  'nt': 'text/n3',\n  'acl': 'text/n3',\n  'html': 'text/html',\n  'xml': 'text/xml'\n}\n\n// Convenience namespaces needed in this module.\n// These are deliberately not exported as the user application should\n// make its own list and not rely on the prefixes used here,\n// and not be tempted to add to them, and them clash with those of another\n// application.\nconst getNS = (factory?: RdfJsDataFactory) => {\n  return {\n    link: Namespace('http://www.w3.org/2007/ont/link#', factory),\n    http: Namespace('http://www.w3.org/2007/ont/http#', factory),\n    httph: Namespace('http://www.w3.org/2007/ont/httph#', factory),  // headers\n    rdf: Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#', factory),\n    rdfs: Namespace('http://www.w3.org/2000/01/rdf-schema#', factory),\n    dc: Namespace('http://purl.org/dc/elements/1.1/', factory),\n    ldp: Namespace('http://www.w3.org/ns/ldp#', factory)\n  }\n}\nconst ns = getNS()\n\nexport interface FetchError extends Error {\n  statusText?: string\n  status?: StatusValues\n  response?: ExtendedResponse\n}\n\n/** An extended interface of Response, since RDFlib.js adds some properties. */\nexport interface ExtendedResponse extends Response {\n  /** String representation of the Body */\n  responseText?: string\n  /** Identifier of the reqest */\n  req?: Quad_Subject\n  size?: number\n  timeout?: number\n  /** Used in UpdateManager.updateDav */\n  error?: string\n}\n\n/** tell typescript that a 'panes' child may exist on Window */\ndeclare global {\n  interface Window {\n    panes?: any\n    solidFetcher?: any\n    solidFetch?: any\n  }\n  var solidFetcher: Function\n  var solidFetch: Function\n}\ndeclare var $SolidTestEnvironment: {\n  localSiteMap?: any\n}\n\ntype UserCallback = (\n  ok: boolean,\n  message: string,\n  response?: any\n) => void\n\ntype HTTPMethods = 'GET' | 'PUT' | 'POST' | 'PATCH' | 'HEAD' | 'DELETE' | 'CONNECT' | 'TRACE' | 'OPTIONS'\n\n/** All valid inputs for initFetchOptions */\nexport type Options = Partial<AutoInitOptions>\n\n/** Initiated by initFetchOptions, which runs on load */\nexport interface AutoInitOptions extends RequestInit{\n  /** The used Fetch function */\n  fetch?: Fetch\n  /**\n   * Referring term, the resource which\n   * referred to this (for tracking bad links).\n   * The document in which this link was found.\n   */\n  referringTerm?: NamedNode\n  /** Provided content type (for writes) */\n  contentType?: string\n  /**\n   * Override the incoming header to\n   * force the data to be treated as this content-type (for reads)\n   */\n  forceContentType?: ContentType\n  /**\n   * Load the data even if loaded before.\n   * Also sets the `Cache-Control:` header to `no-cache`\n   */\n  force?: boolean\n  /**\n   * Original uri to preserve\n   * through proxying etc (`xhr.original`).\n   */\n  baseURI: string\n  /**\n   * Whether this request is a retry via\n   * a proxy (generally done from an error handler)\n   */\n  proxyUsed?: boolean\n  actualProxyURI?: string\n  /** flag for XHR/CORS etc */\n  withCredentials?: boolean\n  /** Before we parse new data, clear old, but only on status 200 responses */\n  clearPreviousData?: boolean\n  /** Prevents the addition of various metadata triples (about the fetch request) to the store*/\n  noMeta?: boolean\n  noRDFa?: boolean\n  handlers?: Handler[]\n  timeout?: number\n  method?: HTTPMethods\n  retriedWithNoCredentials?: boolean\n  requestedURI?: string\n  // Seems to be required in some functions, such as XHTML parse and RedirectToProxy\n  resource: Quad_Subject\n  /** The serialized resource in the body*/\n  // Used for storing metadata of requests\n  original: NamedNode\n  // Like requeststatus? Can contain text with error.\n  data?: string\n  // Probably an identifier for request?s\n  req: BlankNode\n  // Might be the same as Options.data\n  body?: string\n  headers: HeadersInit\n  credentials?: 'include' | 'omit'\n}\n\nclass Handler {\n  // TODO: Document, type\n  response: ExtendedResponse\n  // TODO: Document, type\n  dom: Document\n  static pattern: RegExp\n\n  constructor (response: ExtendedResponse, dom?: Document) {\n    this.response = response\n    // The type assertion operator here might need to be removed.\n    this.dom = dom!\n  }\n}\n\nclass RDFXMLHandler extends Handler {\n  static toString () {\n    return 'RDFXMLHandler'\n  }\n\n  static register (fetcher: Fetcher) {\n    fetcher.mediatypes[RDFXMLContentType] = {\n      'q': 0.9\n    }\n  }\n\n  parse (\n    fetcher: Fetcher,\n    /** An XML String */\n    responseText: String,\n    /** Requires .original */\n    options: {\n      original: Quad_Subject\n      req: Quad_Subject\n    } & Options,\n  ) {\n    let kb = fetcher.store\n    if (!this.dom) {\n      this.dom = Util.parseXML(responseText)\n    }\n    let root = this.dom.documentElement\n    if (root.nodeName === 'parsererror') { // Mozilla only See issue/issue110\n      // have to fail the request\n      return fetcher.failFetch(options, 'Badly formed XML in ' +\n        options.resource!.value, 'parse_error')\n    }\n    let parser = new RDFParser(kb)\n    try {\n      parser.parse(this.dom, options.original.value, options.original)\n    } catch (err) {\n      return fetcher.failFetch(options, 'Syntax error parsing RDF/XML! ' + err,\n        'parse_error')\n    }\n    if (!options.noMeta) {\n      kb.add(options.original, ns.rdf('type'), ns.link('RDFDocument'), fetcher.appNode)\n    }\n\n    return fetcher.doneFetch(options, this.response)\n  }\n}\nRDFXMLHandler.pattern = new RegExp('application/rdf\\\\+xml')\n\nclass XHTMLHandler extends Handler {\n  static toString () {\n    return 'XHTMLHandler'\n  }\n\n  static register (fetcher: Fetcher) {\n    fetcher.mediatypes[XHTMLContentType] = {}\n  }\n\n  parse (\n    fetcher: Fetcher,\n    responseText: string,\n    options: {\n      resource: Quad_Subject\n      original: Quad_Subject\n    } & Options,\n  ): Promise<FetchError> | ExtendedResponse {\n    let relation, reverse: boolean\n    if (!this.dom) {\n      this.dom = Util.parseXML(responseText)\n    }\n    let kb = fetcher.store\n\n    // dc:title\n    let title = this.dom.getElementsByTagName('title')\n    if (title.length > 0) {\n      kb.add(options.resource, ns.dc('title'), kb.rdfFactory.literal(title[0].textContent as string),\n        options.resource)\n      // log.info(\"Inferring title of \" + xhr.resource)\n    }\n\n    // link rel\n    let links = this.dom.getElementsByTagName('link')\n    for (let x = links.length - 1; x >= 0; x--) { // @@ rev\n      relation = links[x].getAttribute('rel')\n      reverse = false\n      if (!relation) {\n        relation = links[x].getAttribute('rev')\n        reverse = true\n      }\n      if (relation) {\n        fetcher.linkData(options.original, relation,\n          links[x].getAttribute('href') as string, options.resource, reverse)\n      }\n    }\n\n    // Data Islands\n    let scripts = this.dom.getElementsByTagName('script')\n    for (let i = 0; i < scripts.length; i++) {\n      let contentType = scripts[i].getAttribute('type')\n      if (Parsable[contentType!]) {\n        // @ts-ignore incompatibility between Store.add and Formula.add\n        rdfParse(scripts[i].textContent as string, kb, options.original.value, contentType)\n        // @ts-ignore incompatibility between Store.add and Formula.add\n        rdfParse(scripts[i].textContent as string, kb, options.original.value, contentType)\n      }\n    }\n\n    if (!options.noMeta) {\n      kb.add(options.resource, ns.rdf('type'), ns.link('WebPage'), fetcher.appNode)\n    }\n\n    if (!options.noRDFa && parseRDFaDOM) { // enable by default\n      try {\n        parseRDFaDOM(this.dom, kb, options.original.value)\n      } catch (err) {\n        // @ts-ignore\n        let msg = 'Error trying to parse ' + options.resource + ' as RDFa:\\n' + err + ':\\n' + err.stack\n        return fetcher.failFetch(options as AutoInitOptions, msg, 'parse_error')\n      }\n    }\n\n    return fetcher.doneFetch(options as AutoInitOptions, this.response)\n  }\n}\nXHTMLHandler.pattern = new RegExp('application/xhtml')\n\nclass XMLHandler extends Handler {\n  static toString () {\n    return 'XMLHandler'\n  }\n\n  static register (fetcher: Fetcher) {\n    fetcher.mediatypes['text/xml'] = { 'q': 0.5 }\n    fetcher.mediatypes['application/xml'] = { 'q': 0.5 }\n  }\n\n  static isElement(node: Node): node is Element {\n    return node.nodeType === Node.ELEMENT_NODE;\n  }\n\n\n  parse (\n    fetcher: Fetcher,\n    responseText: string,\n    options: {\n      original: Quad_Subject\n      req: BlankNode\n      resource: Quad_Subject\n    } & Options,\n  ): ExtendedResponse | Promise<FetchError> {\n    let dom = Util.parseXML(responseText)\n\n    // XML Semantics defined by root element namespace\n    // figure out the root element\n    for (let c = 0; c < dom.childNodes.length; c++) {\n      const node = dom.childNodes[c]\n      // is this node an element?\n      if (XMLHandler.isElement(node)) {\n\n        // We've found the first element, it's the root\n        let ns = node.namespaceURI\n\n        // Is it RDF/XML?\n        if (ns && ns === ns['rdf']) {\n          fetcher.addStatus(options.req,\n            'Has XML root element in the RDF namespace, so assume RDF/XML.')\n\n          let rdfHandler = new RDFXMLHandler(this.response, dom)\n          return rdfHandler.parse(fetcher, responseText, options)\n        }\n\n        break\n      }\n    }\n\n    // Or it could be XHTML?\n    // Maybe it has an XHTML DOCTYPE?\n    if (dom.doctype) {\n      // log.info(\"We found a DOCTYPE in \" + xhr.resource)\n      if (dom.doctype.name === 'html' &&\n          dom.doctype.publicId.match(/^-\\/\\/W3C\\/\\/DTD XHTML/) &&\n          dom.doctype.systemId.match(/http:\\/\\/www.w3.org\\/TR\\/xhtml/)) {\n        fetcher.addStatus(options.req,\n          'Has XHTML DOCTYPE. Switching to XHTML Handler.\\n')\n\n        let xhtmlHandler = new XHTMLHandler(this.response, dom)\n        return xhtmlHandler.parse(fetcher, responseText, options)\n      }\n    }\n\n    // Or what about an XHTML namespace?\n    let html = dom.getElementsByTagName('html')[0]\n    if (html) {\n      let xmlns = html.getAttribute('xmlns')\n      if (xmlns && xmlns.match(/^http:\\/\\/www.w3.org\\/1999\\/xhtml/)) {\n        fetcher.addStatus(options.req,\n          'Has a default namespace for ' + 'XHTML. Switching to XHTMLHandler.\\n')\n\n        let xhtmlHandler = new XHTMLHandler(this.response, dom)\n        return xhtmlHandler.parse(fetcher, responseText, options)\n      }\n    }\n\n    // At this point we should check the namespace document (cache it!) and\n    // look for a GRDDL transform\n    // @@  Get namespace document <n>, parse it, look for  <n> grddl:namespaceTransform ?y\n    // Apply ?y to   dom\n    // We give up. What dialect is this?\n    return fetcher.failFetch(options,\n      'Unsupported dialect of XML: not RDF or XHTML namespace, etc.\\n' +\n      responseText.slice(0, 80), 901)\n  }\n}\nXMLHandler.pattern = new RegExp('(text|application)/(.*)xml')\n\nclass HTMLHandler extends Handler {\n  static toString () {\n    return 'HTMLHandler'\n  }\n\n  static register (fetcher: Fetcher) {\n    fetcher.mediatypes['text/html'] = {\n      'q': 0.9\n    }\n  }\n\n  parse (\n    fetcher: Fetcher,\n    responseText: string,\n    options: {\n      req: BlankNode,\n      resource: Quad_Subject,\n      original: Quad_Subject,\n    } & Options\n  ): Promise<FetchError> | ExtendedResponse {\n    let kb = fetcher.store\n\n    // We only handle XHTML so we have to figure out if this is XML\n    // log.info(\"Sniffing HTML \" + xhr.resource + \" for XHTML.\")\n    if (isXML(responseText)) {\n      fetcher.addStatus(options.req, \"Has an XML declaration. We'll assume \" +\n        \"it's XHTML as the content-type was text/html.\\n\")\n\n      let xhtmlHandler = new XHTMLHandler(this.response)\n      return xhtmlHandler.parse(fetcher, responseText, options)\n    }\n\n    // DOCTYPE html\n    if (isXHTML(responseText)) {\n      fetcher.addStatus(options.req,\n        'Has XHTML DOCTYPE. Switching to XHTMLHandler.\\n')\n\n      let xhtmlHandler = new XHTMLHandler(this.response)\n      return xhtmlHandler.parse(fetcher, responseText, options)\n    }\n\n    // xmlns\n    if (isXMLNS(responseText)) {\n      fetcher.addStatus(options.req,\n        'Has default namespace for XHTML, so switching to XHTMLHandler.\\n')\n\n      let xhtmlHandler = new XHTMLHandler(this.response)\n      return xhtmlHandler.parse(fetcher, responseText, options)\n    }\n\n    // dc:title\n    // no need to escape '/' here\n    let titleMatch = (new RegExp('<title>([\\\\s\\\\S]+?)</title>', 'im')).exec(responseText)\n    if (titleMatch) {\n      kb.add(options.resource, ns.dc('title'), kb.rdfFactory.literal(titleMatch[1]),\n        options.resource) // think about xml:lang later\n    }\n    kb.add(options.resource, ns.rdf('type'), ns.link('WebPage'), fetcher.appNode)\n    fetcher.addStatus(options.req, 'non-XML HTML document, not parsed for data.')\n\n    return fetcher.doneFetch(options, this.response)\n  }\n}\nHTMLHandler.pattern = new RegExp('text/html')\n\nclass JsonLdHandler extends Handler {\n  static toString () {\n    return 'JsonLdHandler'\n  }\n  static register (fetcher: Fetcher) {\n    fetcher.mediatypes['application/ld+json'] = {\n      'q': 0.9\n    }\n  }\n  parse (\n    fetcher: Fetcher,\n    responseText: string,\n    options: {\n      req: Quad_Subject\n      original: Quad_Subject\n      resource: Quad_Subject\n    } & Options,\n    response: ExtendedResponse\n  ): Promise<ExtendedResponse | FetchError> {\n    const kb = fetcher.store\n    return new Promise((resolve, reject) => {\n      try {\n        jsonldParser (responseText, kb, options.original.value, () => {\n          resolve(fetcher.doneFetch(options, response))\n        })\n      } catch (err) {\n        const msg = 'Error trying to parse ' + options.resource +\n          ' as JSON-LD:\\n' + err  // not err.stack -- irrelevant\n        resolve(fetcher.failFetch(options, msg, 'parse_error', response))\n      }\n    })\n  }\n}\nJsonLdHandler.pattern = /application\\/ld\\+json/\n\nclass TextHandler extends Handler {\n  static toString () {\n    return 'TextHandler'\n  }\n\n  static register (fetcher: Fetcher) {\n    fetcher.mediatypes['text/plain'] = {\n      'q': 0.5\n    }\n  }\n\n  parse (\n    fetcher: Fetcher,\n    responseText: string,\n    options: {\n      req: Quad_Subject\n      original: Quad_Subject\n      resource: Quad_Subject\n    } & Options\n  ): ExtendedResponse | Promise<FetchError> {\n    // We only speak dialects of XML right now. Is this XML?\n\n    // Look for an XML declaration\n    if (isXML(responseText)) {\n      fetcher.addStatus(options.req, 'Warning: ' + options.resource +\n        \" has an XML declaration. We'll assume \" +\n        \"it's XML but its content-type wasn't XML.\\n\")\n\n      let xmlHandler = new XMLHandler(this.response)\n      return xmlHandler.parse(fetcher, responseText, options)\n    }\n\n    // Look for an XML declaration\n    if (responseText.slice(0, 500).match(/xmlns:/)) {\n      fetcher.addStatus(options.req, \"May have an XML namespace. We'll assume \" +\n        \"it's XML but its content-type wasn't XML.\\n\")\n\n      let xmlHandler = new XMLHandler(this.response)\n      return xmlHandler.parse(fetcher, responseText, options)\n    }\n\n    // We give up finding semantics - this is not an error, just no data\n    fetcher.addStatus(options.req, 'Plain text document, no known RDF semantics.')\n\n    return fetcher.doneFetch(options, this.response)\n  }\n}\nTextHandler.pattern = new RegExp('text/plain')\n\nclass N3Handler extends Handler {\n  static toString () {\n    return 'N3Handler'\n  }\n\n  static register (fetcher: Fetcher) {\n    fetcher.mediatypes['text/n3'] = {\n      'q': '1.0'\n    } // as per 2008 spec\n    /*\n     fetcher.mediatypes['application/x-turtle'] = {\n     'q': 1.0\n     } // pre 2008\n     */\n    fetcher.mediatypes['text/turtle'] = {\n      'q': 1.0\n    } // post 2008\n  }\n\n  parse (\n    fetcher: Fetcher,\n    responseText: string,\n    options: {\n      original: NamedNode\n      req: Quad_Subject\n    } & Options,\n    response: ExtendedResponse\n  ): ExtendedResponse | Promise<FetchError> {\n    // Parse the text of this N3 file\n    let kb = fetcher.store\n    let p = N3Parser(kb, kb, options.original.value, options.original.value,\n      null, null, '', null)\n    //                p.loadBuf(xhr.responseText)\n    try {\n      p.loadBuf(responseText)\n    } catch (err) {\n      let msg = 'Error trying to parse ' + options.resource +\n        ' as Notation3:\\n' + err  // not err.stack -- irrelevant\n      return fetcher.failFetch(options, msg, 'parse_error', response)\n    }\n\n    fetcher.addStatus(options.req, 'N3 parsed: ' + p.statementCount + ' triples in ' + p.lines + ' lines.')\n    fetcher.store.add(options.original, ns.rdf('type'), ns.link('RDFDocument'), fetcher.appNode)\n\n    return fetcher.doneFetch(options, this.response)\n  }\n}\nN3Handler.pattern = new RegExp('(application|text)/(x-)?(rdf\\\\+)?(n3|turtle)')\n\nconst defaultHandlers = {\n  RDFXMLHandler, XHTMLHandler, XMLHandler, HTMLHandler, TextHandler, N3Handler, JsonLdHandler\n}\n\nfunction isXHTML (responseText) {\n  const docTypeStart = responseText.indexOf('<!DOCTYPE html')\n  const docTypeEnd = responseText.indexOf('>')\n  if (docTypeStart === -1 || docTypeEnd === -1 || docTypeStart > docTypeEnd) {\n    return false\n  }\n  return responseText.substr(docTypeStart, docTypeEnd - docTypeStart).indexOf('XHTML') !== -1\n}\n\nfunction isXML (responseText: string): boolean {\n  const match = responseText.match(/\\s*<\\?xml\\s+version\\s*=[^<>]+\\?>/)\n  return !!match\n}\n\nfunction isXMLNS (responseText: string): boolean {\n  const match = responseText.match(/[^(<html)]*<html\\s+[^<]*xmlns=['\"]http:\\/\\/www.w3.org\\/1999\\/xhtml[\"'][^<]*>/)\n  return !!match\n}\n\ntype StatusValues =\n  /** No record of web access or record reset */\n  undefined |\n  /** Has been requested, fetch in progress */\n  true |\n  /** Received, OK */\n  'done' |\n  /** Not logged in */\n  401 |\n  /** HTTP status unauthorized */\n  403 |\n  /** Not found, resource does not exist */\n  404 |\n  /** In attempt to counter CORS problems retried */\n  'redirected' |\n  /** If it did fail */\n  'failed' |\n  'parse_error' |\n  /**\n   * URI is not a protocol Fetcher can deal with\n   * other strings mean various other errors.\n   */\n  'unsupported_protocol' |\n  'timeout' |\n  /** Any other HTTP status code */\n  number\n\ninterface MediatypesMap {\n  [id: string]: {\n    // Either string '1.0' or number 1.0 is allowed\n    'q'?: number | string\n  };\n}\n\ninterface RequestedMap {\n  [uri: string]: StatusValues\n}\n\ninterface TimeOutsMap {\n  [uri: string]: number[]\n}\n\ninterface FetchQueue {\n  [uri: string]: Promise<ExtendedResponse>\n}\n\ninterface FetchCallbacks {\n  [uri: string]: UserCallback[]\n}\n\ninterface BooleanMap {\n  [uri: string]: boolean\n}\n\n// Not sure about the shapes of this. Response? FetchError?\ntype Result = Response\n\n/** Differs from normal Fetch, has an extended Response type */\ntype Fetch = (input: RequestInfo, init?: RequestInit) => Promise<ExtendedResponse>;\n\ninterface CallbackifyInterface {\n  fireCallbacks: Function\n}\n\n/** Fetcher\n *\n * The Fetcher object is a helper object for a quadstore\n * which turns it from an offline store to an online store.\n * The fetcher deals with loading data files rom the web,\n  * figuring how to parse them.  It will also refresh, remove, the data\n  * and put back the data to the web.\n */\nexport default class Fetcher implements CallbackifyInterface {\n  store: IndexedFormula\n  timeout: number\n  _fetch: Fetch\n  mediatypes: MediatypesMap\n  /** Denoting this session */\n  appNode: NamedNode\n  /**\n   * this.requested[uri] states:\n   * undefined     no record of web access or records reset\n   * true          has been requested, fetch in progress\n   * 'done'        received, Ok\n   * 401           Not logged in\n   * 403           HTTP status unauthorized\n   * 404           Resource does not exist. Can be created etc.\n   * 'redirected'  In attempt to counter CORS problems retried.\n   * 'parse_error' Parse error\n   * 'unsupported_protocol'  URI is not a protocol Fetcher can deal with\n   * other strings mean various other errors.\n   */\n  requested: RequestedMap\n  /** List of timeouts associated with a requested URL */\n  timeouts: TimeOutsMap\n  /** Redirected from *key uri* to *value uri* */\n  redirectedTo: Record<string, string>\n  fetchQueue: FetchQueue\n  /** fetchCallbacks[uri].push(callback) */\n  fetchCallbacks: FetchCallbacks\n  /** Keep track of explicit 404s -> we can overwrite etc */\n  nonexistent: BooleanMap\n  lookedUp: BooleanMap\n  handlers: Array<typeof Handler>\n  ns: { [k: string]: (ln: string) => Quad_Predicate }\n  static HANDLERS: {\n    [handlerName: number]: Handler\n  }\n  static CONTENT_TYPE_BY_EXT: Record<string, string>\n  // TODO: Document this\n  static crossSiteProxyTemplate: any\n\n  /** Methods added by calling Util.callbackify in the constructor*/\n  fireCallbacks!: Function\n\n  constructor (store: IndexedFormula, options: Options = {}) {\n    this.store = store || new IndexedFormula()\n    this.ns = getNS(this.store.rdfFactory)\n    this.timeout = options.timeout || 30000\n\n    // solidFetcher is deprecated\n    this._fetch = options.fetch\n               || (typeof global !== 'undefined' && (global.solidFetcher || global.solidFetch))\n               || (typeof window !== 'undefined' && (window.solidFetcher || window.solidFetch))\n               || crossFetch\n    if (!this._fetch) {\n      throw new Error('No _fetch function available for Fetcher')\n    }\n    // This is the name of the graph we store all the HTTP metadata in\n    this.appNode = this.store.sym('chrome://TheCurrentSession')\n    // this.appNode = this.store.rdfFactory.blankNode() // Needs to have a URI in tests\n    this.store.fetcher = this // Bi-linked\n    this.requested = {}\n    this.timeouts = {}\n    this.redirectedTo = {}\n    this.fetchQueue = {}\n    this.fetchCallbacks = {}\n    this.nonexistent = {}\n    this.lookedUp = {}\n    this.handlers = []\n    this.mediatypes = {\n      'image/*': { 'q': 0.9 },\n      '*/*': { 'q': 0.1 }  // Must allow access to random content\n    }\n\n    // Util.callbackify(this, ['request', 'recv', 'headers', 'load', 'fail',\n    //   'refresh', 'retract', 'done'])\n    // In switching to fetch(), 'recv', 'headers' and 'load' do not make sense\n    Util.callbackify(this, ['request', 'fail', 'refresh', 'retract', 'done'])\n\n    Object.keys(options.handlers || defaultHandlers).map(key => this.addHandler(defaultHandlers[key]))\n  }\n\n  static crossSiteProxy (uri: string): undefined | any {\n    if (Fetcher.crossSiteProxyTemplate) {\n      return Fetcher.crossSiteProxyTemplate\n        .replace('{uri}', encodeURIComponent(uri))\n    } else {\n      return undefined\n    }\n  }\n\n  static offlineOverride (uri: string): string {\n    // Map the URI to a localhost proxy if we are running on localhost\n    // This is used for working offline, e.g. on planes.\n    // Is the script itself is running in localhost, then access all\n    //   data in a localhost mirror.\n    // Do not remove without checking with TimBL\n    let requestedURI = uri\n\n    var UI\n    if (typeof window !== 'undefined' && window.panes && (UI = window.panes.UI) &&\n      UI.preferences && UI.preferences.get('offlineModeUsingLocalhost')) {\n      if (requestedURI.slice(0, 7) === 'http://' && requestedURI.slice(7, 17) !== 'localhost/') {\n        requestedURI = 'http://localhost/' + requestedURI.slice(7)\n        log.warn('Localhost kludge for offline use: actually getting <' +\n          requestedURI + '>')\n      } else {\n        // log.warn(\"Localhost kludge NOT USED <\" + requestedURI + \">\")\n      }\n    } else {\n      // log.warn(\"Localhost kludge OFF offline use: actually getting <\" +\n      //   requestedURI + \">\")\n    }\n\n    return requestedURI\n  }\n\n  static proxyIfNecessary (uri: string) {\n    var UI\n    if (\n      typeof window !== 'undefined' &&\n      (window as any).panes &&\n      (UI = (window as any).panes.UI) &&\n      UI.isExtension\n    ) {\n      return uri\n    } // Extension does not need proxy\n\n    if (typeof $SolidTestEnvironment !== 'undefined' &&\n      $SolidTestEnvironment.localSiteMap) {\n      // nested dictionaries of URI parts from origin down\n      let hostpath = uri.split('/').slice(2) // the bit after the //\n\n      const lookup = (parts, index) => {\n        let z = index[parts.shift()]\n\n        if (!z) { return null }\n\n        if (typeof z === 'string') {\n          return z + parts.join('/')\n        }\n\n        if (!parts) { return null }\n\n        return lookup(parts, z)\n      }\n\n      const y = lookup(hostpath, $SolidTestEnvironment.localSiteMap)\n\n      if (y) {\n        return y\n      }\n    }\n\n    // browser does 2014 on as https browser script not trusted\n    // If the web app origin is https: then the mixed content rules\n    // prevent it loading insecure http: stuff so we need proxy.\n    if (Fetcher.crossSiteProxyTemplate &&\n        typeof document !== 'undefined' && document.location &&\n        ('' + document.location).slice(0, 6) === 'https:' && // origin is secure\n        uri.slice(0, 5) === 'http:') { // requested data is not\n      return Fetcher.crossSiteProxyTemplate\n        .replace('{uri}', encodeURIComponent(uri))\n    }\n\n    return uri\n  }\n\n  /**\n   * Tests whether the uri's protocol is supported by the Fetcher.\n   * @param uri\n   */\n  static unsupportedProtocol (uri: string): boolean {\n    let pcol = Uri.protocol(uri)\n\n    return (pcol === 'tel' || pcol === 'mailto' || pcol === 'urn')\n  }\n\n  /** Decide on credentials using old XXHR api or new fetch()  one\n   * @param requestedURI\n   * @param options\n   */\n  static setCredentials (requestedURI: string, options: Options = {}) {\n    // 2014 CORS problem:\n    // XMLHttpRequest cannot load http://www.w3.org/People/Berners-Lee/card.\n    // A wildcard '*' cannot be used in the 'Access-Control-Allow-Origin'\n    //   header when the credentials flag is true.\n    // @ Many ontology files under http: and need CORS wildcard ->\n    //   can't have credentials\n    if (options.credentials === undefined) { // Caller using new fetch convention\n      if (options.withCredentials !== undefined) { // XHR style is what Fetcher specified before\n        options.credentials = options.withCredentials ? 'include' : 'omit'\n      } else {\n        options.credentials = 'include' // default is to be logged on\n      }\n    }\n  }\n\n  /**\n   * Promise-based load function\n   *\n   * Loads a web resource or resources into the store.\n   *\n   * A resource may be given as NamedNode object, or as a plain URI.\n   * an array of resources will be given, in which they will be fetched in parallel.\n   * By default, the HTTP headers are recorded also, in the same store, in a separate graph.\n   * This allows code like editable() for example to test things about the resource.\n   *\n   * @param uri {Array<RDFlibNamedNode>|Array<string>|RDFlibNamedNode|string}\n   *\n   * @param [options={}] {Object}\n   *\n   * @param [options.fetch] {Function}\n   *\n   * @param [options.referringTerm] {RDFlibNamedNode} Referring term, the resource which\n   *   referred to this (for tracking bad links)\n   *\n   * @param [options.contentType] {string} Provided content type (for writes)\n   *\n   * @param [options.forceContentType] {string} Override the incoming header to\n   *   force the data to be treated as this content-type (for reads)\n   *\n   * @param [options.force] {boolean} Load the data even if loaded before.\n   *   Also sets the `Cache-Control:` header to `no-cache`\n   *\n   * @param [options.baseURI=docuri] {Node|string} Original uri to preserve\n   *   through proxying etc (`xhr.original`).\n   *\n   * @param [options.proxyUsed] {boolean} Whether this request is a retry via\n   *   a proxy (generally done from an error handler)\n   *\n   * @param [options.withCredentials] {boolean} flag for XHR/CORS etc\n   *\n   * @param [options.clearPreviousData] {boolean} Before we parse new data,\n   *   clear old, but only on status 200 responses\n   *\n   * @param [options.noMeta] {boolean} Prevents the addition of various metadata\n   *   triples (about the fetch request) to the store\n   *\n   * @param [options.noRDFa] {boolean}\n   *\n   * @returns {Promise<Result>}\n   */\n  load <T extends NamedNode | string | Array<string | NamedNode>>(\n    uri: T,\n    options: Options = {}\n  ): T extends Array<string | NamedNode> ? Promise<Result[]> : Promise<Result> {\n    options = Object.assign({}, options) // Take a copy as we add stuff to the options!!\n    if (uri instanceof Array) {\n      return Promise.all(uri.map((x) => {\n        return this.load(x, Object.assign({}, options)) as unknown as Promise<Result>\n      })) as T extends Array<string | NamedNode> ? Promise<Result[]> : Promise<Result>\n    }\n\n    const uriIn: NamedNode | string = uri as NamedNode\n\n    let docuri = termValue(uriIn)\n    docuri = docuri.split('#')[0]\n\n    options = this.initFetchOptions(docuri, options)\n    // if metadata flaged clear cache and removeDocument\n    const meta = this.appNode\n    const kb = this.store\n    const requests = kb.statementsMatching(undefined, this.ns.link('requestedURI'), kb.sym(docuri), meta).map(st => st.subject)\n    for (const request of requests) {\n      const response = kb.any(request, this.ns.link('response'), null, meta) as Quad_Subject\n      if (response != undefined) { // ts\n        const quad = kb.statementsMatching(response, this.ns.link('outOfDate'), true as any, meta)\n        kb.remove(quad)\n        options.force = true\n        options.clearPreviousData = true\n      }\n    }\n\n    const initialisedOptions = this.initFetchOptions(docuri, options)\n\n    return this.pendingFetchPromise(docuri, initialisedOptions.baseURI, initialisedOptions) as any\n  }\n\n  async pendingFetchPromise (\n    uri: string,\n    originalUri: string,\n    options: AutoInitOptions\n  ): Promise<Result> {\n    let pendingPromise\n\n    // Check to see if some request is already dealing with this uri\n    if (!options.force && await this.fetchQueue[originalUri]) {\n      pendingPromise = this.fetchQueue[originalUri]\n    } else {\n      pendingPromise = Promise\n        .race([\n          this.setRequestTimeout(uri, options),\n          this.fetchUri(uri, options)\n        ])\n      this.fetchQueue[originalUri] = pendingPromise\n\n      // Clean up the queued promise after a time, if it's resolved\n      this.cleanupFetchRequest(originalUri, undefined, this.timeout)\n    }\n\n    return pendingPromise.then(x => {\n      if (uri in this.timeouts) {\n        this.timeouts[uri].forEach(clearTimeout)\n        delete this.timeouts[uri]\n      }\n      return x\n    })\n  }\n\n  /**\n   * @param _options - DEPRECATED\n   */\n  cleanupFetchRequest (\n    originalUri: string,\n    _options,\n    timeout: number\n  ) {\n    if (_options !== undefined) {\n      console.warn(\"_options is deprecated\")\n    }\n    this.timeouts[originalUri] = (this.timeouts[originalUri] || []).concat(setTimeout(() => {\n      if (!this.isPending(originalUri)) {\n        delete this.fetchQueue[originalUri]\n      }\n    }, timeout) as unknown as number)\n  }\n\n  initFetchOptions (\n    uri: string,\n    options: Options\n  ): AutoInitOptions {\n    let kb = this.store\n\n    let isGet = !options.method || options.method.toUpperCase() === 'GET'\n    if (!isGet) {\n      options.force = true\n    }\n\n    options.resource = kb.rdfFactory.namedNode(uri) // This might be proxified\n    options.baseURI = options.baseURI || uri // Preserve though proxying etc\n    options.original = kb.rdfFactory.namedNode(options.baseURI)\n    options.req = kb.bnode()\n    options.headers = options.headers || new Headers()\n\n    if (options.contentType) {\n      // @ts-ignore\n      options.headers['content-type'] = options.contentType\n    }\n\n    if (options.force) {\n      options.cache = 'no-cache'\n    }\n\n    let acceptString = this.acceptString()\n    // @ts-ignore\n    options.headers['accept'] = acceptString\n\n    let requestedURI = Fetcher.offlineOverride(uri)\n    options.requestedURI = requestedURI\n\n    Fetcher.setCredentials(requestedURI, options)\n\n    let actualProxyURI = Fetcher.proxyIfNecessary(requestedURI)\n    if (requestedURI !== actualProxyURI) {\n      options.proxyUsed = true\n    }\n    options.actualProxyURI = actualProxyURI\n\n    return options as AutoInitOptions\n  }\n\n  /**\n   * (The promise chain ends in either a `failFetch()` or a `doneFetch()`)\n   *\n   * @param docuri {string}\n   * @param options {Object}\n   *\n   * @returns {Promise<Object>} fetch() result or an { error, status } object\n   */\n  fetchUri (docuri: string, options: AutoInitOptions): Promise<ExtendedResponse | FetchError> {\n    if (!docuri) {\n      return Promise.reject(new Error('Cannot fetch an empty uri'))\n    }\n\n    if (Fetcher.unsupportedProtocol(docuri)) {\n      return this.failFetch(options, 'fetcher: Unsupported protocol', 'unsupported_protocol')\n    }\n\n    let state = this.getState(docuri)\n\n    if (!options.force) {\n      if (state === 'fetched') {  // URI already fetched and added to store\n        return Promise.resolve(\n          // @ts-ignore This is not a valid response object\n          this.doneFetch(options, {\n            status: 200,\n            ok: true,\n            statusText: 'Already loaded into quadstore.'\n          })\n        )\n      }\n      if (state === 'failed' && this.requested[docuri] === 404) { // Remember nonexistence\n        let message = 'Previously failed: ' + this.requested[docuri]\n        // @ts-ignore This is not a valid response object\n        let dummyResponse: ExtendedResponse = {\n          url: docuri,\n          // This does not comply to Fetch spec, it can be a string value in rdflib\n          status: this.requested[docuri] as number,\n          statusText: message,\n          responseText: message,\n          headers: new Headers,  // Headers() ???\n          ok: false,\n          body: null,\n          bodyUsed: false,\n          size: 0,\n          timeout: 0\n        }\n        return this.failFetch(options, message,\n          this.requested[docuri], dummyResponse)\n      }\n    } else {\n      // options.force == true\n      delete this.nonexistent[docuri]\n    }\n\n    this.fireCallbacks('request', [docuri])\n\n    this.requested[docuri] = true  // mark this uri as 'requested'\n\n    if (!options.noMeta) {\n      this.saveRequestMetadata(docuri, options)\n    }\n\n    let { actualProxyURI } = options\n\n    // Map might get mistakenly added into headers\n    // error TS2339: Property 'map' does not exist on type 'Headers'.\n    /* let map\n    if (options.headers && map in options.headers) {\n      delete options.headers.map\n    } */\n\n    return this._fetch((actualProxyURI as string), options)\n      .then(response => this.handleResponse(response, docuri, options),\n      error => { // @@ handleError?\n        // @ts-ignore Invalid response object\n        let dummyResponse: ExtendedResponse = {\n          url: actualProxyURI as string,\n          status: 999, // @@ what number/string should fetch failures report?\n          statusText: (error.name || 'network failure') + ': ' +\n            (error.errno || error.code || error.type),\n          responseText: error.message,\n          headers: new Headers(),  // Headers() ???\n          ok: false,\n          body: null,\n          bodyUsed: false,\n          size: 0,\n          timeout: 0\n        }\n        // console.log('Fetcher: <' + actualProxyURI + '> Non-HTTP fetch exception: ' + error)\n        return this.handleError(dummyResponse, docuri, options) // possible credentials retry\n        // return this.failFetch(options, 'fetch failed: ' + error, 999, dummyResponse) // Fake status code: fetch exception\n\n        // handleError expects a response so we fake some important bits.\n        /*\n        this.handleError(, docuri, options)\n        */\n      }\n    )\n  }\n\n  /**\n   * Asks for a doc to be loaded if necessary then calls back\n   *\n   * Calling methods:\n   *   nowOrWhenFetched (uri, userCallback)\n   *   nowOrWhenFetched (uri, options, userCallback)\n   *   nowOrWhenFetched (uri, referringTerm, userCallback, options)  <-- old\n   *   nowOrWhenFetched (uri, referringTerm, userCallback) <-- old\n   *\n   *  Options include:\n   *   referringTerm    The document in which this link was found.\n   *                    this is valuable when finding the source of bad URIs\n   *   force            boolean.  Never mind whether you have tried before,\n   *                    load this from scratch.\n   *   forceContentType Override the incoming header to force the data to be\n   *                    treated as this content-type.\n   *\n   *  Callback function takes:\n   *\n   *    ok               True if the fetch worked, and got a 200 response.\n   *                     False if any error happened\n   *\n   *    errmessage       Text error message if not OK.\n   *\n   *    response         The fetch Response object (was: XHR) if there was was one\n   *                     includes response.status as the HTTP status if any.\n   */\n  nowOrWhenFetched (\n    uriIn: string | NamedNode,\n    p2?: UserCallback | Options,\n    userCallback?: UserCallback,\n    options: Options = {}\n  ): void {\n    const uri = termValue(uriIn)\n\n    if (typeof p2 === 'function') {\n      // nowOrWhenFetched (uri, userCallback)\n      userCallback = p2\n    } else if (typeof p2 === 'undefined') { // original calling signature\n      // referringTerm = undefined\n    } else if (isNamedNode(p2)) {\n      // referringTerm = p2\n      options.referringTerm = p2\n    } else {\n      // nowOrWhenFetched (uri, options, userCallback)\n      options = p2\n    }\n\n    (this.load(uri, options) as Promise<Response>)\n      .then((fetchResponse: ExtendedResponse) => {\n        if (userCallback) {\n          if (fetchResponse) {\n            if ((fetchResponse as Response).ok) {\n              userCallback(true, 'OK', fetchResponse)\n            } else {\n              let oops = 'HTTP error: Status ' + fetchResponse.status + ' (' + fetchResponse.statusText + ')'\n              if (fetchResponse.responseText) {\n                oops += ' ' + fetchResponse.responseText // not in 404, dns error, nock failure\n              }\n              userCallback(false, oops, fetchResponse)\n            }\n          } else {\n            let oops = ('@@ nowOrWhenFetched:  no response object!')\n            userCallback(false, oops)\n          }\n        }\n      }, function (err: FetchError) {\n        var message = err.message || err.statusText\n        message = 'Failed to load  <' + uri + '> ' + message\n        if (err.response && err.response.status) {\n          message += ' status: ' + err.response.status\n        }\n        (userCallback as any)(false, message, err.response)\n      })\n  }\n\n  /**\n   * Records a status message (as a literal node) by appending it to the\n   * request's metadata status collection.\n   *\n   */\n  addStatus (req: BlankNode, statusMessage: string) {\n    // <Debug about=\"parsePerformance\">\n    let now = new Date()\n    statusMessage = '[' + now.getHours() + ':' + now.getMinutes() + ':' +\n      now.getSeconds() + '.' + now.getMilliseconds() + '] ' + statusMessage\n    // </Debug>\n    let kb = this.store\n\n    const statusNode = kb.the(req, this.ns.link('status'))\n    if (isCollection(statusNode)) {\n      statusNode.append(kb.rdfFactory.literal(statusMessage))\n    } else {\n      log.warn('web.js: No list to add to: ' + statusNode + ',' + statusMessage)\n    }\n  }\n\n  /**\n   * Records errors in the system on failure:\n   *\n   *  - Adds an entry to the request status collection\n   *  - Adds an error triple with the fail message to the metadata\n   *  - Fires the 'fail' callback\n   *  - Rejects with an error result object, which has a response object if any\n   */\n  failFetch (\n    options: {\n      req: BlankNode\n      original: Quad_Subject\n    } & Options,\n    errorMessage: string,\n    statusCode: StatusValues,\n    response?: ExtendedResponse\n  ): Promise<FetchError> {\n    this.addStatus(options.req, errorMessage)\n\n    if (!options.noMeta) {\n      this.store.add(\n        options.original,\n        this.ns.link('error'),\n        this.store.rdfFactory.literal(errorMessage)\n      )\n    }\n\n    let meth = (options.method || 'GET').toUpperCase()\n    let isGet = meth === 'GET' || meth === 'HEAD'\n\n    if (isGet) {  // only cache the status code on GET or HEAD\n      if (!(options as any).resource.equals(options.original)) {\n        // console.log('@@ Recording failure  ' + meth + '  original ' + options.original +option '( as ' + options.resource + ') : ' + statusCode)\n      } else {\n        // console.log('@@ Recording ' + meth + ' failure for ' + options.original + ': ' + statusCode)\n      }\n      this.requested[Uri.docpart(options.original.value)] = statusCode\n      this.fireCallbacks('fail', [options.original.value, errorMessage])\n    }\n\n    var err: FetchError = new Error('Fetcher: ' + errorMessage)\n\n    // err.ok = false // Is taken as a response, will work too @@ phase out?\n    err.status = statusCode\n    err.statusText = errorMessage\n    err.response = response\n\n    return Promise.reject(err)\n  }\n\n  // in the why part of the quad distinguish between HTML and HTTP header\n  // Reverse is set iif the link was rev= as opposed to rel=\n  linkData (\n    originalUri: NamedNode,\n    rel: string,\n    uri: string,\n    why: Quad_Graph,\n    reverse?: boolean\n  ) {\n    if (!uri) return\n    let kb = this.store\n    let predicate\n    // See http://www.w3.org/TR/powder-dr/#httplink for describedby 2008-12-10\n    let obj = kb.rdfFactory.namedNode(Uri.join(uri, originalUri.value))\n\n    if (rel === 'alternate' || rel === 'seeAlso' || rel === 'meta' ||\n        rel === 'describedby') {\n      if (obj.value === originalUri.value) { return }\n      predicate = this.ns.rdfs('seeAlso')\n    } else if (rel === 'type') {\n      predicate = kb.rdfFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type')\n    } else {\n      // See https://www.iana.org/assignments/link-relations/link-relations.xml\n      // Alas not yet in RDF yet for each predicate\n      // encode space in e.g. rel=\"shortcut icon\"\n      predicate = kb.rdfFactory.namedNode(\n        Uri.join(encodeURIComponent(rel),\n          'http://www.iana.org/assignments/link-relations/')\n      )\n    }\n    if (reverse) {\n      kb.add(obj, predicate, originalUri, why)\n    } else {\n      kb.add(originalUri, predicate, obj, why)\n    }\n  }\n\n  parseLinkHeader (\n    linkHeader: string,\n    originalUri: NamedNode,\n    reqNode: Quad_Graph\n  ): void {\n    if (!linkHeader) { return }\n\n    // const linkexp = /<[^>]*>\\s*(\\s*;\\s*[^()<>@,;:\"/[\\]?={} \\t]+=(([^()<>@,;:\"/[]?={} \\t]+)|(\"[^\"]*\")))*(,|$)/g\n    // const paramexp = /[^()<>@,;:\"/[]?={} \\t]+=(([^()<>@,;:\"/[]?={} \\t]+)|(\"[^\"]*\"))/g\n\n    // From https://www.dcode.fr/regular-expression-simplificator:\n    // const linkexp = /<[^>]*>\\s*(\\s*;\\s*[^()<>@,;:\"/[\\]?={} t]+=[\"]))*[,$]/g\n    // const paramexp = /[^\\\\<>@,;:\"\\/\\[\\]?={} \\t]+=[\"])/g\n    // Original:\n    const linkexp = /<[^>]*>\\s*(\\s*;\\s*[^()<>@,;:\"/[\\]?={} \\t]+=(([^\\(\\)<>@,;:\"\\/\\[\\]\\?={} \\t]+)|(\"[^\"]*\")))*(,|$)/g\n    const paramexp = /[^\\(\\)<>@,;:\"\\/\\[\\]\\?={} \\t]+=(([^\\(\\)<>@,;:\"\\/\\[\\]\\?={} \\t]+)|(\"[^\"]*\"))/g\n\n    const matches = linkHeader.match(linkexp)\n\n    if (matches == null) return;\n\n    for (let i = 0; i < matches.length; i++) {\n      let split = matches[i].split('>')\n      let href = split[0].substring(1)\n      let ps = split[1]\n      let s = ps.match(paramexp)\n      if (s == null) return\n      for (let j = 0; j < s.length; j++) {\n        let p = s[j]\n        let paramsplit = p.split('=')\n        // var name = paramsplit[0]\n        let rel = paramsplit[1].replace(/[\"']/g, '') // '\"\n        this.linkData(originalUri, rel, href, reqNode)\n      }\n    }\n  }\n\n  doneFetch (\n    options: {\n      req: Quad_Subject,\n      original: Quad_Subject\n    } & Options,\n    response: ExtendedResponse\n  ): Response {\n    this.addStatus(options.req, 'Done.')\n    this.requested[options.original.value] = 'done'\n\n    this.fireCallbacks('done', [options.original.value])\n\n    response.req = options.req  // Set the request meta blank node\n\n    return response\n  }\n\n  /**\n   * Note two nodes are now smushed\n   * If only one was flagged as looked up, then the new node is looked up again,\n   * which will make sure all the URIs are dereferenced\n   */\n  nowKnownAs (was: Quad_Subject, now: Quad_Subject): void {\n    if (this.lookedUp[was.value]) {\n      // Transfer userCallback\n      if (!this.lookedUp[now.value]) {\n        this.lookUpThing(now, was)\n      }\n    } else if (this.lookedUp[now.value]) {\n      if (!this.lookedUp[was.value]) {\n        this.lookUpThing(was, now)\n      }\n    }\n  }\n\n  /**\n   * Writes back to the web what we have in the store for this uri\n   */\n  putBack (\n    uri: NamedNode | string,\n    options: Options = {}\n  ): Promise<Response> {\n    const uriSting = termValue(uri)\n    let doc = new RDFlibNamedNode(uriSting).doc() // strip off #\n    options.contentType = options[\"content-type\"] || options[\"Content-Type\"] || options.contentType || TurtleContentType\n    if (options.contentType === 'application/ld+json') {\n      return new Promise((resolve, reject) => {\n        serialize(doc, this.store, doc.uri, options.contentType, (err, jsonString) => {\n          if (err) {\n            reject(err)\n          } else {\n            // @ts-ignore\n            options.data = jsonString\n            this.webOperation('PUT', uri, options)\n              .then((res) => resolve(res))\n              .catch((error) => reject(error))\n          }\n        })\n      })\n    }\n    options.data = serialize(doc, this.store, doc.value, options.contentType) as string\n    return this.webOperation('PUT', uriSting, options)\n  }\n\n  webCopy (here: string, there: string, contentType): Promise<ExtendedResponse> {\n    return this.webOperation('GET', here)\n      .then((result) => {\n        return this.webOperation(\n          'PUT', // change to binary from text\n          there, { data: result.responseText, contentType })\n      })\n  }\n\n  delete (uri: string, options?: Options): Promise<ExtendedResponse> {\n    return this.webOperation('DELETE', uri, options)\n      .then(response => {\n        this.requested[uri] = 404\n        this.nonexistent[uri] = true\n        this.unload(this.store.rdfFactory.namedNode(uri))\n\n        return response\n      })\n  }\n\n  /** Create an empty resource if it really does not exist\n   *  Be absolutely sure something does not exist before creating a new empty file\n   * as otherwise existing could  be deleted.\n   * @param doc - The resource\n  */\n  async createIfNotExists (\n    doc: RDFlibNamedNode,\n    contentType = TurtleContentType,\n    data = ''\n  ): Promise<ExtendedResponse> {\n    const fetcher = this\n    try {\n      var response = await fetcher.load(doc as NamedNode)\n    } catch (err) {\n      // @ts-ignore\n      if (err.response.status === 404) {\n        // console.log('createIfNotExists: doc does NOT exist, will create... ' + doc)\n        try {\n          response = await fetcher.webOperation('PUT', doc.value, {data, contentType})\n        } catch (err) {\n          // console.log('createIfNotExists doc FAILED: ' + doc + ': ' + err)\n          throw err\n        }\n        delete fetcher.requested[doc.value] // delete cached 404 error\n        // console.log('createIfNotExists doc created ok ' + doc)\n        return response\n      } else {\n        // console.log('createIfNotExists doc load error NOT 404:  ' + doc + ': ' + err)\n        throw err\n      }\n    }\n    // console.log('createIfNotExists: doc exists, all good: ' + doc)\n    return response as Response\n  }\n\n  /**\n   * @param parentURI URI of parent container\n   * @param folderName - Optional folder name (slug)\n   * @param data - Optional folder metadata\n   */\n  createContainer (\n    parentURI: string,\n    folderName: string,\n    data: string\n  ): Promise<Response> {\n    let headers = {\n      // Force the right mime type for containers\n      'content-type': TurtleContentType,\n      'link': this.ns.ldp('BasicContainer') + '; rel=\"type\"'\n    }\n\n    if (folderName) {\n      headers['slug'] = folderName\n    }\n\n    // @ts-ignore These headers lack some of the required operators.\n    let options: Options = { headers }\n\n    if (data) {\n      options.body = data\n    }\n\n    return this.webOperation('POST', parentURI, options)\n  }\n\n  invalidateCache (iri: string | NamedNode): void {\n    const uri = termValue(iri)\n    const fetcher = this\n    // @ts-ignore\n    if (fetcher.fetchQueue && fetcher.fetchQueue[uri]) {\n      // console.log('Internal error - fetchQueue exists ' + uri)\n      var promise = fetcher.fetchQueue[uri]\n      if (promise['PromiseStatus'] === 'resolved') {\n        delete fetcher.fetchQueue[uri]\n      } else { // pending\n        delete fetcher.fetchQueue[uri]\n        // console.log('*** Fetcher: pending fetchQueue deleted ' + uri)\n      }\n    } if (fetcher.requested[uri] && fetcher.requested[uri] !== 'done' &&\n     fetcher.requested[uri] !== 'failed' && fetcher.requested[uri] !== 404) {\n       let msg = `Rdflib: fetcher: Destructive operation on <${fetcher.requested[uri]}> file being fetched! ` + uri\n      console.error(msg)\n      // alert(msg)\n    } else {\n      delete fetcher.requested[uri] // invalidate read cache -- @@ messes up logic if request in progress ??\n      delete fetcher.nonexistent[uri]\n    }\n  }\n\n  /**\n   * A generic web operation, at the fetch() level.\n   * does not involve the quad store.\n   *\n   *  Returns promise of Response\n   *  If data is returned, copies it to response.responseText before returning\n   */\n  webOperation (\n    method: HTTPMethods,\n    uriIn: string | NamedNode,\n    // Not sure about this type. Maybe this Options is different?\n    options: Options = {}\n  ): Promise<ExtendedResponse> {\n    const uri = termValue(uriIn)\n    options.method = method\n    options.body = options.data || options.body\n    options.force = true\n    const fetcher = this\n\n    if (options.body && !options.contentType) {\n      throw new Error('Web operation sending data must have a defined contentType.')\n    }\n    if (options.contentType) {\n      (options as any).headers = options.headers || {};\n      (options as any).headers['content-type'] = options.contentType\n    }\n    Fetcher.setCredentials(uri, options)\n\n    return new Promise(function (resolve, reject) {\n      fetcher._fetch(uri, options).then(response => {\n        if (response.ok) {\n          if (method === 'PUT' || method === 'PATCH' || method === 'POST' || method === 'DELETE') {\n            fetcher.invalidateCache (uri)\n          } // response.body with Chrome can't be relied on\n          if (response.text) { // Was: response.body https://github.com/linkeddata/rdflib.js/issues/506\n            response.text().then(data => {\n              response.responseText = data\n              resolve(response)\n            })\n          } else {\n            resolve(response)\n          }\n        } else {\n          let msg = 'Web error: ' + response.status\n          if (response.statusText) msg += ' (' + response.statusText + ')'\n          msg += ' on ' + method + ' of <' + uri + '>'\n          if (response.responseText) msg += ': ' + response.responseText\n          let e2: FetchError = new Error(msg)\n          e2.response = response\n          reject(e2)\n        }\n      }, (err: Error) => {\n        let msg = 'Fetch error for ' + method + ' of <' + uri + '>:' + err\n        reject(new Error(msg))\n      })\n    })\n  }\n\n  /**\n   * Looks up something.\n   * Looks up all the URIs a things has.\n   *\n   * @param term - canonical term for the thing whose URI is\n   *   to be dereferenced\n   * @param rterm - the resource which referred to this\n   *   (for tracking bad links)\n   */\n  lookUpThing (\n    term: Quad_Subject,\n    rterm: Quad_Subject\n  ): Promise<Response> | Promise<Response>[] {\n    let uris = this.store.uris(term)  // Get all URIs\n    uris = uris.map(u => Uri.docpart(u))  // Drop hash fragments\n\n    uris.forEach(u => {\n      this.lookedUp[u] = true\n    })\n\n    // @ts-ignore Recursive type\n    return this.load(uris, { referringTerm: rterm })\n  }\n\n  /**\n   * Looks up response header.\n   *\n   * @returns {Array|undefined} a list of header values found in a stored HTTP\n   *   response, or [] if response was found but no header found,\n   *   or undefined if no response is available.\n   * Looks for { [] link:requestedURI ?uri; link:response [ httph:header-name  ?value ] }\n   */\n  getHeader (\n    doc: NamedNode,\n    header: string\n  ): undefined | string[] {\n    const kb = this.store // look for the URI (AS A STRING NOT A NODE) for a stored request\n    const docuri: string = doc.value\n    const requests = kb.each(undefined, this.ns.link('requestedURI'), kb.rdfFactory.literal(docuri)) as Quad_Subject[]\n\n    for (let r = 0; r < requests.length; r++) {\n      let request = requests[r]\n      if (request !== undefined) {\n        let response = kb.any(request, this.ns.link('response')) as Quad_Subject\n        if (response !== undefined && kb.anyValue(response, this.ns.http('status')) && (kb.anyValue(response, this.ns.http('status')) as string).startsWith('2')) {\n          // Only look at success returns - not 401 error messagess etc\n          let results = kb.each(response, this.ns.httph(header.toLowerCase()))\n\n          if (results.length) {\n            return results.map(v => { return v.value })\n          }\n\n          return []\n        }\n      }\n    }\n    return undefined\n  }\n\n  saveRequestMetadata (\n    docuri: string,\n    options: AutoInitOptions\n  ) {\n    let req = options.req\n    let kb = this.store\n    let rterm = options.referringTerm\n\n    this.addStatus(options.req, 'Accept: ' + options.headers['accept'])\n\n    if (isNamedNode(rterm)) {\n      kb.add(kb.rdfFactory.namedNode(docuri), this.ns.link('requestedBy'), rterm, this.appNode)\n    }\n\n    if (options.original && options.original.value !== docuri) {\n      kb.add(req, this.ns.link('orginalURI'), kb.rdfFactory.literal(options.original.value),\n        this.appNode)\n    }\n\n    const now = new Date()\n    const timeNow = '[' + now.getHours() + ':' + now.getMinutes() + ':' +\n      now.getSeconds() + '] '\n\n    kb.add(req, this.ns.rdfs('label'),\n      kb.rdfFactory.literal(timeNow + ' Request for ' + docuri), this.appNode)\n    // We store the docuri as a string, not as a node,\n    // see https://github.com/linkeddata/rdflib.js/pull/427#pullrequestreview-447910061\n    kb.add(req, this.ns.link('requestedURI'), kb.rdfFactory.literal(docuri), this.appNode)\n    kb.add(req, this.ns.link('status'), kb.collection(), this.appNode)\n  }\n\n  saveResponseMetadata (\n    response: Response,\n    options: {\n      req: BlankNode,\n      resource: Quad_Subject\n    } & Options\n  ): BlankNode {\n    const kb = this.store\n\n    let responseNode = kb.bnode()\n\n    kb.add(options.req, this.ns.link('response'), responseNode, this.appNode)\n    kb.add(responseNode, this.ns.http('status'),\n    kb.rdfFactory.literal(response.status as any), this.appNode)\n    kb.add(responseNode, this.ns.http('statusText'),\n    kb.rdfFactory.literal(response.statusText), this.appNode)\n\n    // Save the response headers\n    response.headers.forEach((value, header) => {\n      kb.add(responseNode, this.ns.httph(header), this.store.rdfFactory.literal(value), this.appNode)\n\n      if (header === 'content-type') {\n        kb.add(\n          options.resource,\n          this.ns.rdf('type'),\n          kb.rdfFactory.namedNode(Util.mediaTypeClass(value).value),\n          this.appNode // responseNode\n        )\n      }\n    })\n\n    return responseNode\n  }\n\n  objectRefresh (term: NamedNode): void {\n    let uris = this.store.uris(term) // Get all URIs\n    if (typeof uris !== 'undefined') {\n      for (let i = 0; i < uris.length; i++) {\n        this.refresh(this.store.rdfFactory.namedNode(Uri.docpart(uris[i])))\n        // what about rterm?\n      }\n    }\n  }\n\n  /* refresh  Reload data from a given document\n  **\n  ** @param term - An RDF Named Node for the eodcument in question\n  ** @param userCallback - A function userCallback(ok, message, response)\n  */\n  refresh (\n    term: NamedNode,\n    userCallback?: UserCallback\n  ): void { // sources_refresh\n    this.fireCallbacks('refresh', arguments)\n\n    this.nowOrWhenFetched(term, { force: true, clearPreviousData: true },\n      userCallback)\n  }\n\n /* refreshIfExpired   Conditional refresh if Expired\n **\n ** @param term - An RDF Named Node for the eodcument in question\n ** @param userCallback - A function userCallback(ok, message, response)\n */\n  refreshIfExpired (\n    term: NamedNode,\n    userCallback: UserCallback\n  ): void {\n    let exp = this.getHeader(term, 'Expires')\n    if (!exp || (new Date(exp[0]).getTime()) <= (new Date().getTime())) {\n      this.refresh(term, userCallback)\n    } else {\n      userCallback(true, 'Not expired', {})\n    }\n  }\n\n  retract (term: Quad_Graph) { // sources_retract\n    this.store.removeMany(undefined, undefined, undefined, term)\n    if (term.value) {\n      delete this.requested[Uri.docpart(term.value)]\n    }\n    this.fireCallbacks('retract', arguments)\n  }\n\n  getState (docuri: string) {\n    if (typeof this.requested[docuri] === 'undefined') {\n      return 'unrequested'\n    } else if (this.requested[docuri] === true) {\n      return 'requested'\n    } else if (this.requested[docuri] === 'done') {\n      return 'fetched'\n    } else if (this.requested[docuri] === 'redirected') {\n      return this.getState(this.redirectedTo[docuri])\n    } else { // An non-200 HTTP error status\n      return 'failed'\n    }\n  }\n\n  isPending (docuri: string) { // sources_pending\n    // doing anyStatementMatching is wasting time\n    // if it's not pending: false -> flailed\n    //   'done' -> done 'redirected' -> redirected\n    return this.requested[docuri] === true\n  }\n\n  unload (term: NamedNode) {\n    this.store.removeDocument(term)\n    delete this.requested[term.value] // So it can be load2ed again\n  }\n\n  addHandler (handler: typeof Handler) {\n    this.handlers.push(handler);\n    (handler as any).register(this)\n  }\n\n  retryNoCredentials (\n    docuri: string,\n    options\n  ): Promise<Result> {\n    // console.log('Fetcher: CORS: RETRYING with NO CREDENTIALS for ' + options.resource)\n\n    options.retriedWithNoCredentials = true // protect against being called twice\n\n    delete this.requested[docuri] // forget the original request happened\n    delete this.fetchQueue[docuri]\n    // Note: XHR property was withCredentials, but fetch property is just credentials\n    let newOptions = Object.assign({}, options, { credentials: 'omit' })\n\n    this.addStatus(options.req,\n      'Abort: Will retry with credentials SUPPRESSED to see if that helps')\n\n    return this.load(docuri, newOptions) as Promise<Result>\n  }\n\n  /**\n   * Tests whether a request is being made to a cross-site URI (for purposes\n   * of retrying with a proxy)\n   */\n  isCrossSite (uri: string): boolean {\n    // Mashup situation, not node etc\n    if (typeof document === 'undefined' || !document.location) {\n      return false\n    }\n\n    const hostpart = Uri.hostpart\n    const here = '' + document.location\n    return (hostpart(here) && hostpart(uri) && hostpart(here)) !== hostpart(uri)\n  }\n\n  /**\n   * Called when there's a network error in fetch(), or a response\n   * with status of 0.\n   */\n  handleError (\n    response: ExtendedResponse | Error,\n    docuri: string,\n    options: AutoInitOptions\n  ): Promise<ExtendedResponse | FetchError> {\n    if (this.isCrossSite(docuri)) {\n      // Make sure we haven't retried already\n      if (options.credentials && options.credentials === 'include' && !options.retriedWithNoCredentials) {\n        return this.retryNoCredentials(docuri, options)\n      }\n\n      // Now attempt retry via proxy\n      let proxyUri = Fetcher.crossSiteProxy(docuri)\n\n      if (proxyUri && !options.proxyUsed) {\n        // console.log('web: Direct failed so trying proxy ' + proxyUri)\n        return this.redirectToProxy(proxyUri, options)\n      }\n    }\n\n    var message\n    if (response instanceof Error) {\n      message = 'Fetch error: ' + response.message\n    } else {\n      message = response.statusText\n      if (response.responseText) {\n        message += ` ${response.responseText}`\n      }\n    }\n\n    // This is either not a CORS error, or retries have been made\n    return this.failFetch(options, message, (response as Response).status || 998, (response as Response))\n  }\n\n  // deduce some things from the HTTP transaction\n  addType (\n    rdfType: NamedNode,\n    req: Quad_Subject,\n    kb: IndexedFormula,\n    locURI: string\n  ): void { // add type to all redirected resources too\n    let prev = req\n    if (locURI) {\n      var reqURI = kb.any(prev, this.ns.link('requestedURI'))\n      if (reqURI && reqURI.value !== locURI) {\n        kb.add(kb.rdfFactory.namedNode(locURI), this.ns.rdf('type'), rdfType, this.appNode)\n      }\n    }\n    for (;;) {\n      const doc = kb.any(prev, this.ns.link('requestedURI'))\n      if (doc && doc.value) {\n        kb.add(kb.rdfFactory.namedNode(doc.value), this.ns.rdf('type'), rdfType, this.appNode)\n      } // convert Literal\n      prev = kb.any(undefined, kb.rdfFactory.namedNode('http://www.w3.org/2007/ont/link#redirectedRequest'), prev) as Quad_Subject\n      if (!prev) { break }\n      var response = kb.any(prev, kb.rdfFactory.namedNode('http://www.w3.org/2007/ont/link#response'))\n      if (!response) { break }\n      var redirection = kb.any((response as NamedNode), kb.rdfFactory.namedNode('http://www.w3.org/2007/ont/http#status'))\n      if (!redirection) { break }\n      // @ts-ignore always true?\n      if ((redirection !== '301') && (redirection !== '302')) { break }\n    }\n  }\n\n  /**\n   * Handle fetch() response\n   */\n  handleResponse (\n    response: ExtendedResponse,\n    docuri: string,\n    options: AutoInitOptions\n  ): Promise<FetchError | ExtendedResponse> | ExtendedResponse {\n\n    const kb = this.store\n    const headers = (response as Response).headers\n\n    const reqNode = options.req\n\n    const responseNode = this.saveResponseMetadata(response, options)\n\n    const contentType = this.normalizedContentType(options, headers) || ''\n    let contentLocation = headers.get('content-location')\n\n    // this.fireCallbacks('recv', xhr.args)\n    // this.fireCallbacks('headers', [{uri: docuri, headers: xhr.headers}])\n\n    // Check for masked errors (CORS, etc)\n    if (response.status === 0) {\n      // console.log('Masked error - status 0 for ' + docuri)\n      return this.handleError(response, docuri, options)\n    }\n\n    if (response.status >= 400) {\n      if (response.status === 404) {\n        this.nonexistent[options.original.value] = true\n        this.nonexistent[docuri] = true\n      }\n\n      return this.saveErrorResponse(response, responseNode)\n        .then(() => {\n          let errorMessage = options.resource + ' ' + response.statusText\n\n          return this.failFetch(options, errorMessage, response.status, response)\n        })\n    }\n\n    var diffLocation: null | string = null\n    var absContentLocation: null | string = null\n    if (contentLocation) {\n      absContentLocation = Uri.join(contentLocation, docuri)\n      if (absContentLocation !== docuri) {\n        diffLocation = absContentLocation\n      }\n    }\n    if (response.status === 200) {\n      this.addType(this.ns.link('Document') as NamedNode, reqNode, kb, docuri)\n      if (diffLocation) {\n        this.addType(this.ns.link('Document') as NamedNode, reqNode, kb,\n          diffLocation)\n      }\n\n      // Before we parse new data clear old but only on 200\n      if (options.clearPreviousData) {\n        // kb.removeDocument(options.resource)\n        // only remove content, keep metatdata\n        const sts = kb.statementsMatching(undefined, undefined, undefined, options.resource).slice() // Take a copy as this is the actual index\n        for (let i = 0; i < sts.length; i++) {\n          kb.removeStatement(sts[i])\n        }\n      }\n\n      let isImage = contentType.includes('image/') ||\n        contentType.includes('application/pdf')\n\n      if (contentType && isImage) {\n        this.addType(kb.rdfFactory.namedNode('http://purl.org/dc/terms/Image'), reqNode, kb,\n          docuri)\n        if (diffLocation) {\n          this.addType(kb.rdfFactory.namedNode('http://purl.org/dc/terms/Image'), reqNode, kb,\n            diffLocation)\n        }\n      }\n    }\n\n    // If we have already got the thing at this location, abort\n    if (contentLocation) {\n      if (!options.force && diffLocation && this.requested[absContentLocation as string] === 'done') {\n        // we have already fetched this\n        // should we smush too?\n        // log.info(\"HTTP headers indicate we have already\" + \" retrieved \" +\n        // xhr.resource + \" as \" + absContentLocation + \". Aborting.\")\n        return this.doneFetch(options, response)\n      }\n\n      this.requested[absContentLocation as string] = true\n    }\n\n    this.parseLinkHeader(headers.get('link') as string, options.original, reqNode)\n\n    let handler = this.handlerForContentType(contentType, response) as Handler\n\n    if (!handler) {\n      //  Not a problem, we just don't extract data\n      this.addStatus(reqNode, 'Fetch over. No data handled.')\n      return this.doneFetch(options, response)\n    }\n\n    return response\n      .text()\n      // @ts-ignore Types seem right\n      .then(responseText => {\n        response.responseText = responseText\n        return (handler as N3Handler).parse(this, responseText, options, response)\n      })\n  }\n\n  saveErrorResponse (\n    response: ExtendedResponse,\n    responseNode: Quad_Subject\n  ): Promise<void> {\n    let kb = this.store\n\n    return response.text()\n      .then(content => {\n        if (content.length > 10) {\n          kb.add(responseNode, this.ns.http('content'), kb.rdfFactory.literal(content), responseNode)\n        }\n      })\n  }\n\n  handlerForContentType (contentType: string, response: ExtendedResponse): Handler | null {\n    if (!contentType) {\n      return null\n    }\n\n    let Handler = this.handlers.find(handler => {\n      return contentType.match(handler.pattern)\n    })\n\n    // @ts-ignore in practice all Handlers have constructors.\n    return Handler ? new Handler(response) : null\n  }\n\n  guessContentType (uri: string): ContentType | undefined {\n    return CONTENT_TYPE_BY_EXT[uri.split('.').pop() as string]\n  }\n\n  normalizedContentType (\n    options: AutoInitOptions,\n    headers: Headers\n  ): ContentType | string | null {\n    if (options.forceContentType) {\n      return options.forceContentType\n    }\n\n    let contentType = headers.get('content-type')\n    if (!contentType || contentType.includes('application/octet-stream')) {\n      let guess = this.guessContentType(options.resource.value)\n\n      if (guess) {\n        return guess\n      }\n    }\n\n    let protocol = Uri.protocol(options.resource.value) as string\n\n    if (!contentType && ['file', 'chrome'].includes(protocol)) {\n      return 'text/xml'\n    }\n\n    return contentType\n  }\n\n  /**\n   * Sends a new request to the specified uri. (Extracted from `onerrorFactory()`)\n   */\n  redirectToProxy (\n    newURI: string,\n    options: AutoInitOptions\n  ): Promise<ExtendedResponse | FetchError> {\n    this.addStatus(options.req, 'BLOCKED -> Cross-site Proxy to <' + newURI + '>')\n\n    options.proxyUsed = true\n\n    const kb = this.store\n    const oldReq = options.req  // request metadata blank node\n\n    if (!options.noMeta) {\n      kb.add(oldReq, this.ns.link('redirectedTo'), kb.rdfFactory.namedNode(newURI), oldReq)\n      this.addStatus(oldReq, 'redirected to new request') // why\n    }\n\n    this.requested[options.resource.value] = 'redirected'\n    this.redirectedTo[options.resource.value] = newURI\n\n    let newOptions = Object.assign({}, options)\n    newOptions.baseURI = options.resource.value\n\n    return this.fetchUri(newURI, newOptions)\n      .then(response => {\n        if (!newOptions.noMeta) {\n          kb.add(oldReq, this.ns.link('redirectedRequest'), newOptions.req, this.appNode)\n        }\n\n        return response\n      })\n  }\n\n  setRequestTimeout (\n    uri: string,\n    options: {\n      req: Quad_Subject\n      original: Quad_Subject\n    } & Options\n  ): Promise<number | FetchError> {\n    return new Promise((resolve) => {\n      this.timeouts[uri] = (this.timeouts[uri] || []).concat(setTimeout(() => {\n        if (this.isPending(uri) &&\n            !options.retriedWithNoCredentials &&\n            !options.proxyUsed) {\n          resolve(this.failFetch(options, `Request to ${uri} timed out`, 'timeout'))\n        }\n      }, this.timeout) as unknown as number)\n    })\n  }\n\n  addFetchCallback (\n    uri: string,\n    callback: UserCallback\n  ): void {\n    if (!this.fetchCallbacks[uri]) {\n      this.fetchCallbacks[uri] = [callback]\n    } else {\n      this.fetchCallbacks[uri].push(callback)\n    }\n  }\n\n  acceptString () {\n    let acceptstring = ''\n\n    for (let mediaType in this.mediatypes) {\n      if (acceptstring !== '') {\n        acceptstring += ', '\n      }\n\n      acceptstring += mediaType\n\n      for (let property in this.mediatypes[mediaType]) {\n        acceptstring += ';' + property + '=' + this.mediatypes[mediaType][property]\n      }\n    }\n\n    return acceptstring\n  }\n  // var updatesVia = new $rdf.UpdatesVia(this) // Subscribe to headers\n// @@@@@@@@ This is turned off because it causes a websocket to be set up for ANY fetch\n// whether we want to track it ot not. including ontologies loaed though the XSSproxy\n}\n\nFetcher.HANDLERS = defaultHandlers\nFetcher.CONTENT_TYPE_BY_EXT = CONTENT_TYPE_BY_EXT\n","export default (function () {\r\n  return {\r\n    parseJSON: function (data, source, store) {\r\n      var subject, predicate, object\r\n      var bnodes = {}\r\n      var why = store.sym(source)\r\n      for (var x in data) {\r\n        if (x.indexOf('_:') === 0) {\r\n          if (bnodes[x]) {\r\n            subject = bnodes[x]\r\n          } else {\r\n            subject = store.bnode(x)\r\n            bnodes[x] = subject\r\n          }\r\n        } else {\r\n          subject = store.sym(x)\r\n        }\r\n        var preds = data[x]\r\n        for (var y in preds) {\r\n          var objects = preds[y]\r\n          predicate = store.sym(y)\r\n          for (var z in objects) {\r\n            var obj = objects[z]\r\n            if (obj.type === 'uri') {\r\n              object = store.sym(obj.value)\r\n              store.add(subject, predicate, object, why)\r\n            } else if (obj.type === 'BlankNode') {\r\n              if (bnodes[obj.value]) {\r\n                object = bnodes[obj.value]\r\n              } else {\r\n                object = store.bnode(obj.value)\r\n                bnodes[obj.value] = object\r\n              }\r\n              store.add(subject, predicate, object, why)\r\n            } else if (obj.type === 'Literal') {\r\n              // var datatype\r\n              if (obj.datatype) {\r\n                object = store.literal(obj.value, undefined, store.sym(obj.datatype))\r\n              } else if (obj.lang) {\r\n                object = store.literal(obj.value, obj.lang)\r\n              } else {\r\n                object = store.literal(obj.value)\r\n              }\r\n              store.add(subject, predicate, object, why)\r\n            } else {\r\n              throw new Error('error: unexpected termtype: ' + z.type)\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n})()\r\n","import log from './log'\n\nexport default function queryToSPARQL (query) {\n  var indent = 0\n  function getSelect (query) {\n    var str = addIndent() + 'SELECT '\n    for (var i = 0; i < query.vars.length; i++) {\n      str += query.vars[i] + ' '\n    }\n    str += '\\n'\n    return str\n  }\n\n  function getPattern (pat) {\n    var str = ''\n    var st = pat.statements\n    for (var x in st) {\n      log.debug('Found statement: ' + st)\n      str += addIndent() + st[x] + '\\n'\n    }\n    return str\n  }\n\n  function getConstraints (pat) {\n    var str = ''\n    for (var v in pat.constraints) {\n      var foo = pat.constraints[v]\n      str += addIndent() + 'FILTER ( ' + foo.describe(v) + ' ) ' + '\\n'\n    }\n    return str\n  }\n\n  function getOptionals (pat) {\n    var str = ''\n    for (var x = 0; x < pat.optional.length; x++) {\n      // alert(pat.optional.termType)\n      log.debug('Found optional query')\n      str += addIndent() + 'OPTIONAL { ' + '\\n'\n      indent++\n      str += getPattern(pat.optional[x])\n      str += getConstraints(pat.optional[x])\n      str += getOptionals(pat.optional[x])\n      indent--\n      str += addIndent() + '}' + '\\n'\n    }\n    return str\n  }\n\n  function getWhere (pat) {\n    var str = addIndent() + 'WHERE \\n' + '{ \\n'\n    indent++\n    str += getPattern(pat)\n    str += getConstraints(pat)\n    str += getOptionals(pat)\n    indent--\n    str += '}'\n    return str\n  }\n\n  function addIndent () {\n    var str = ''\n    for (var i = 0; i < indent; i++) {\n      str += '    '\n    }\n    return str\n  }\n\n  function getSPARQL (query) {\n    return getSelect(query) + getWhere(query.pat)\n  }\n\n  return getSPARQL(query)\n}\n","// Converting between SPARQL queries and the $rdf query API\n/*\n\nfunction SQuery () {\n  this.terms = []\n  return this\n}\n\nSTerm.prototype.toString = STerm.val\nSQuery.prototype.add = function (str) {this.terms.push()}*/\n\nimport log from './log'\nimport { Query } from './query'\n\n/**\n * @SPARQL: SPARQL text that is converted to a query object which is returned.\n * @testMode: testing flag. Prevents loading of sources.\n */\nexport default function SPARQLToQuery (SPARQL, testMode, kb) {\n  // AJAR_ClearTable()\n  var variableHash = []\n  function makeVar (name) {\n    if (variableHash[name]) {\n      return variableHash[name]\n    }\n    var newVar = kb.variable(name)\n    variableHash[name] = newVar\n    return newVar\n  }\n\n  // term type functions\n  function isRealText (term) {\n    return (typeof term === 'string' && term.match(/[^ \\n\\t]/))\n  }\n  function isVar (term) {\n    return (typeof term === 'string' && term.match(/^[\\?\\$]/))\n  }\n  function fixSymbolBrackets (term) {\n    if (typeof term === 'string') {\n      return term.replace(/^&lt;/, '<').replace(/&gt;$/, '>')\n    } else {\n      return term\n    }\n  }\n  function isSymbol (term) {\n    return (typeof term === 'string' && term.match(/^<[^>]*>$/))\n  }\n  function isBnode (term) {\n    return (typeof term === 'string' && (term.match(/^_:/) || term.match(/^$/)))\n  }\n  function isPrefix (term) {\n    return (typeof term === 'string' && term.match(/:$/))\n  }\n  function isPrefixedSymbol (term) {\n    return (typeof term === 'string' && term.match(/^:|^[^_][^:]*:/))\n  }\n  function getPrefix (term) {\n    var a = term.split(':')\n    return a[0]\n  }\n  function getSuffix (term) {\n    var a = term.split(':')\n    return a[1]\n  }\n  function removeBrackets (term) {\n    if (isSymbol(term)) {\n      return term.slice(1, term.length - 1)\n    } else {\n      return term\n    }\n  }\n  // takes a string and returns an array of strings and Literals in the place of literals\n  function parseLiterals (str) {\n    // var sin = (str.indexOf(/[ \\n]\\'/)==-1)?null:str.indexOf(/[ \\n]\\'/), doub = (str.indexOf(/[ \\n]\\\"/)==-1)?null:str.indexOf(/[ \\n]\\\"/)\n    var sin = (str.indexOf(\"'\") === -1)\n      ? null\n      : str.indexOf(\"'\")\n    var doub = (str.indexOf('\"') === -1)\n      ? null\n      : str.indexOf('\"')\n    // alert(\"S: \"+sin+\" D: \"+doub)\n    if (!sin && !doub) {\n      var a = new Array(1)\n      a[0] = str\n      return a\n    }\n    var res = new Array(2)\n    var br\n    var ind\n    if (!sin || (doub && doub < sin)) {\n      br = '\"'\n      ind = doub\n    } else if (!doub || (sin && sin < doub)) {\n      br = \"'\"\n      ind = sin\n    } else {\n      log.error('SQARQL QUERY OOPS!')\n      return res\n    }\n    res[0] = str.slice(0, ind)\n    var end = str.slice(ind + 1).indexOf(br)\n    if (end === -1) {\n      log.error('SPARQL parsing error: no matching parentheses in literal ' + str)\n      return str\n    }\n    // alert(str.slice(end + ind + 2).match(/^\\^\\^/))\n    var end2\n    if (str.slice(end + ind + 2).match(/^\\^\\^/)) {\n      end2 = str.slice(end + ind + 2).indexOf(' ')\n      // alert(end2)\n      res[1] = kb.literal(\n        str.slice(ind + 1, ind + 1 + end),\n        kb.sym(removeBrackets(\n          str.slice(ind + 4 + end, ind + 2 + end + end2))\n        )\n      )\n      // alert(res[1].datatype.uri)\n      res = res.concat(parseLiterals(str.slice(end + ind + 3 + end2)))\n    } else if (str.slice(end + ind + 2).match(/^@/)) {\n      end2 = str.slice(end + ind + 2).indexOf(' ')\n      // alert(end2)\n      res[1] = kb.literal(\n        str.slice(ind + 1, ind + 1 + end),\n        str.slice(ind + 3 + end, ind + 2 + end + end2), null\n      )\n      // alert(res[1].datatype.uri)\n      res = res.concat(\n        parseLiterals(str.slice(end + ind + 2 + end2))\n      )\n    } else {\n      res[1] = kb.literal(str.slice(ind + 1, ind + 1 + end))\n      log.info('Literal found: ' + res[1])\n      res = res.concat(parseLiterals(str.slice(end + ind + 2))) // finds any other literals\n    }\n    return res\n  }\n\n  function spaceDelimit (str) {\n    str = str.replace(/\\(/g, ' ( ')\n      .replace(/\\)/g, ' ) ')\n      .replace(/</g, ' <')\n      .replace(/>/g, '> ')\n      .replace(/{/g, ' { ')\n      .replace(/}/g, ' } ')\n      .replace(/[\\t\\n\\r]/g, ' ')\n      .replace(/; /g, ' ; ')\n      .replace(/\\. /g, ' . ')\n      .replace(/, /g, ' , ')\n    log.info('New str into spaceDelimit: \\n' + str)\n    var res = []\n    var br = str.split(' ')\n    for (var x in br) {\n      if (isRealText(br[x])) {\n        res = res.concat(br[x])\n      }\n    }\n    return res\n  }\n\n  function replaceKeywords (input) {\n    var strarr = input\n    for (var x = 0; x < strarr.length; x++) {\n      if (strarr[x] === 'a') {\n        strarr[x] = '<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>'\n      }\n      if (strarr[x] === 'is' && strarr[x + 2] === 'of') {\n        strarr.splice(x, 1)\n        strarr.splice(x + 1, 1)\n        var s = strarr[x - 1]\n        strarr[x - 1] = strarr[x + 1]\n        strarr[x + 1] = s\n      }\n    }\n    return strarr\n  }\n\n  function toTerms (input) {\n    var res = []\n    for (var x = 0; x < input.length; x++) {\n      if (typeof input[x] !== 'string') {\n        res[x] = input[x]\n        continue\n      }\n      input[x] = fixSymbolBrackets(input[x])\n      if (isVar(input[x])) {\n        res[x] = makeVar(input[x].slice(1))\n      } else if (isBnode(input[x])) {\n        log.info(input[x] + ' was identified as a bnode.')\n        res[x] = kb.bnode()\n      } else if (isSymbol(input[x])) {\n        log.info(input[x] + ' was identified as a symbol.')\n        res[x] = kb.sym(removeBrackets(input[x]))\n      } else if (isPrefixedSymbol(input[x])) {\n        log.info(input[x] + ' was identified as a prefixed symbol')\n        if (prefixes[getPrefix(input[x])]) {\n          res[x] = kb.sym(input[x] = prefixes[getPrefix(input[x])] +\n            getSuffix(input[x]))\n        } else {\n          log.error('SPARQL error: ' + input[x] + ' with prefix ' +\n            getPrefix(input[x]) + ' does not have a correct prefix entry.')\n          res[x] = input[x]\n        }\n      } else {\n        res[x] = input[x]\n      }\n    }\n    return res\n  }\n\n  function tokenize (str) {\n    var token1 = parseLiterals(str)\n    var token2 = []\n    for (var x in token1) {\n      if (typeof token1[x] === 'string') {\n        token2 = token2.concat(spaceDelimit(token1[x]))\n      } else {\n        token2 = token2.concat(token1[x])\n      }\n    }\n    token2 = replaceKeywords(token2)\n    log.info('SPARQL Tokens: ' + token2)\n    return token2\n  }\n\n  // CASE-INSENSITIVE\n  function arrayIndexOf (str, arr) {\n    for (var i = 0; i < arr.length; i++) {\n      if (typeof arr[i] !== 'string') {\n        continue\n      }\n      if (arr[i].toLowerCase() === str.toLowerCase()) {\n        return i\n      }\n    }\n    // log.warn(\"No instance of \"+str+\" in array \"+arr)\n    return null\n  }\n\n  // CASE-INSENSITIVE\n  function arrayIndicesOf (str, arr) {\n    var ind = []\n    for (var i = 0; i < arr.length; i++) {\n      if (typeof arr[i] !== 'string') {\n        continue\n      }\n      if (arr[i].toLowerCase() === str.toLowerCase()) {\n        ind.push(i)\n      }\n    }\n    return ind\n  }\n\n  function setVars (input, query) {\n    log.info('SPARQL vars: ' + input)\n    for (var x in input) {\n      if (isVar(input[x])) {\n        log.info('Added ' + input[x] + ' to query variables from SPARQL')\n        var v = makeVar(input[x].slice(1))\n        query.vars.push(v)\n        v.label = input[x].slice(1)\n      } else {\n        log.warn('Incorrect SPARQL variable in SELECT: ' + input[x])\n      }\n    }\n  }\n\n  function getPrefixDeclarations (input) {\n    var prefInd = arrayIndicesOf('PREFIX', input)\n    var res = []\n    for (var i in prefInd) {\n      var a = input[prefInd[i] + 1]\n      var b = input[prefInd[i] + 2]\n      if (!isPrefix(a)) {\n        log.error('Invalid SPARQL prefix: ' + a)\n      } else if (!isSymbol(b)) {\n        log.error('Invalid SPARQL symbol: ' + b)\n      } else {\n        log.info('Prefix found: ' + a + ' -> ' + b)\n        var pref = getPrefix(a)\n        var symbol = removeBrackets(b)\n        res[pref] = symbol\n      }\n    }\n    return res\n  }\n\n  function getMatchingBracket (arr, open, close) {\n    log.info('Looking for a close bracket of type ' + close + ' in ' + arr)\n    var index = 0\n    for (var i = 0; i < arr.length; i++) {\n      if (arr[i] === open) {\n        index++\n      }\n      if (arr[i] === close) {\n        index--\n      }\n      if (index < 0) {\n        return i\n      }\n    }\n    log.error('Statement had no close parenthesis in SPARQL query')\n    return 0\n  }\n\n  function constraintGreaterThan (value) {\n    this.describe = function (varstr) {\n      return varstr + ' > ' + value.toNT()\n    }\n    this.test = function (term) {\n      if (term.value.match(/[0-9]+(\\.[0-9]+)?([eE][+-]?[0-9]+)?/)) {\n        return (parseFloat(term.value) > parseFloat(value))\n      } else {\n        return (term.toNT() > value.toNT())\n      }\n    }\n    return this\n  }\n\n  function constraintLessThan (value) { // this is not the recommended usage. Should only work on literal, numeric, dateTime\n    this.describe = function (varstr) {\n      return varstr + ' < ' + value.toNT()\n    }\n    this.test = function (term) {\n      // this.describe = function (varstr) { return varstr + \" < \"+value }\n      if (term.value.match(/[0-9]+(\\.[0-9]+)?([eE][+-]?[0-9]+)?/)) {\n        return (parseFloat(term.value) < parseFloat(value))\n      } else {\n        return (term.toNT() < value.toNT())\n      }\n    }\n    return this\n  }\n  // This should only work on literals but doesn't.\n  function ConstraintEqualTo (value) {\n    this.describe = function (varstr) {\n      return varstr + ' = ' + value.toNT()\n    }\n    this.test = function (term) {\n      return value.equals(term)\n    }\n    return this\n  }\n\n  // value must be a literal\n  function ConstraintRegexp (value) {\n    this.describe = function (varstr) {\n      return \"REGEXP( '\" + value + \"' , \" + varstr + ' )'\n    }\n    this.test = function (term) {\n      var str = value\n      // str = str.replace(/^//,\"\").replace(//$/,\"\")\n      var rg = new RegExp(str)\n      if (term.value) {\n        return rg.test(term.value)\n      } else {\n        return false\n      }\n    }\n  }\n\n  function setConstraint (input, pat) {\n    if (input.length === 3 && input[0].termType === 'Variable' &&\n      (input[2].termType === 'NamedNode' || input[2].termType === 'Literal')) {\n      if (input[1] === '=') {\n        log.debug('Constraint added: ' + input)\n        pat.constraints[input[0]] = new ConstraintEqualTo(input[2])\n      } else if (input[1] === '>') {\n        log.debug('Constraint added: ' + input)\n        pat.constraints[input[0]] = new ConstraintEqualTo(input[2])\n      } else if (input[1] === '<') {\n        log.debug('Constraint added: ' + input)\n        pat.constraints[input[0]] = new ConstraintEqualTo(input[2])\n      } else {\n        log.warn(\"I don't know how to handle the constraint: \" + input)\n      }\n    } else if (input.length === 6 && typeof input[0] === 'string' &&\n      input[0].toLowerCase() === 'regexp' &&\n      input[1] === '(' && input[5] === ')' && input[3] === ',' &&\n      input[4].termType === 'Variable' && input[2].termType === 'Literal') {\n      log.debug('Constraint added: ' + input)\n      pat.constraints[input[4]] = new ConstraintRegexp(input[2].value)\n    }\n  // log.warn(\"I don't know how to handle the constraint: \"+input)\n  // alert(\"length: \"+input.length+\" input 0 type: \"+input[0].termType+\" input 1: \"+input[1]+\" input[2] type: \"+input[2].termType)\n  }\n\n  function setOptional (terms, pat) {\n    log.debug('Optional query: ' + terms + ' not yet implemented.')\n    var opt = kb.formula()\n    setWhere(terms, opt)\n    pat.optional.push(opt)\n  }\n\n  function setWhere (input, pat) {\n    var terms = toTerms(input)\n    var end\n    log.debug('WHERE: ' + terms)\n    var opt\n    // var opt = arrayIndicesOf(\"OPTIONAL\",terms)\n    while (arrayIndexOf('OPTIONAL', terms)) {\n      opt = arrayIndexOf('OPTIONAL', terms)\n      log.debug('OPT: ' + opt + ' ' + terms[opt] + ' in ' + terms)\n      if (terms[opt + 1] !== '{') {\n        log.warn('Bad optional opening bracket in word ' + opt)\n      }\n      end = getMatchingBracket(terms.slice(opt + 2), '{', '}')\n      if (end === -1) {\n        log.error('No matching bracket in word ' + opt)\n      } else {\n        setOptional(terms.slice(opt + 2, opt + 2 + end), pat)\n        // alert(pat.statements[0].toNT())\n        opt = arrayIndexOf('OPTIONAL', terms)\n        end = getMatchingBracket(terms.slice(opt + 2), '{', '}')\n        terms.splice(opt, end + 3)\n      }\n    }\n    log.debug('WHERE after optionals: ' + terms)\n    while (arrayIndexOf('FILTER', terms)) {\n      var filt = arrayIndexOf('FILTER', terms)\n      if (terms[filt + 1] !== '(') {\n        log.warn('Bad filter opening bracket in word ' + filt)\n      }\n      end = getMatchingBracket(terms.slice(filt + 2), '(', ')')\n      if (end === -1) {\n        log.error('No matching bracket in word ' + filt)\n      } else {\n        setConstraint(terms.slice(filt + 2, filt + 2 + end), pat)\n        filt = arrayIndexOf('FILTER', terms)\n        end = getMatchingBracket(terms.slice(filt + 2), '(', ')')\n        terms.splice(filt, end + 3)\n      }\n    }\n    log.debug('WHERE after filters and optionals: ' + terms)\n    extractStatements(terms, pat)\n  }\n\n  function extractStatements (terms, formula) {\n    var arrayZero = new Array(1)\n    arrayZero[0] = -1 // this is just to add the beginning of the where to the periods index.\n    var per = arrayZero.concat(arrayIndicesOf('.', terms))\n    var stat = []\n    for (var x = 0; x < per.length - 1; x++) {\n      stat[x] = terms.slice(per[x] + 1, per[x + 1])\n    }\n    // Now it's in an array of statements\n    for (x in stat) { // THIS MUST BE CHANGED FOR COMMA, SEMICOLON\n      log.info('s+p+o ' + x + ' = ' + stat[x])\n      var subj = stat[x][0]\n      stat[x].splice(0, 1)\n      var sem = arrayZero.concat(arrayIndicesOf(';', stat[x]))\n      sem.push(stat[x].length)\n      var stat2 = []\n      for (var y = 0; y < sem.length - 1; y++) {\n        stat2[y] = stat[x].slice(sem[y] + 1, sem[y + 1])\n      }\n      for (x in stat2) {\n        log.info('p+o ' + x + ' = ' + stat[x])\n        var pred = stat2[x][0]\n        stat2[x].splice(0, 1)\n        var com = arrayZero.concat(arrayIndicesOf(',', stat2[x]))\n        com.push(stat2[x].length)\n        var stat3 = []\n        for (y = 0; y < com.length - 1; y++) {\n          stat3[y] = stat2[x].slice(com[y] + 1, com[y + 1])\n        }\n        for (x in stat3) {\n          var obj = stat3[x][0]\n          log.info('Subj=' + subj + ' Pred=' + pred + ' Obj=' + obj)\n          formula.add(subj, pred, obj)\n        }\n      }\n    }\n  }\n\n  // ******************************* Body of SPARQLToQuery ***************************//\n  log.info('SPARQL input: \\n' + SPARQL)\n  var q = new Query()\n  var sp = tokenize(SPARQL) // first tokenize everything\n  var prefixes = getPrefixDeclarations(sp)\n  if (!prefixes.rdf) {\n    prefixes.rdf = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'\n  }\n  if (!prefixes.rdfs) {\n    prefixes.rdfs = 'http://www.w3.org/2000/01/rdf-schema#'\n  }\n  var selectLoc = arrayIndexOf('SELECT', sp)\n  var whereLoc = arrayIndexOf('WHERE', sp)\n  if (selectLoc < 0 || whereLoc < 0 || selectLoc > whereLoc) {\n    log.error('Invalid or nonexistent SELECT and WHERE tags in SPARQL query')\n    return false\n  }\n  setVars(sp.slice(selectLoc + 1, whereLoc), q)\n\n  setWhere(sp.slice(whereLoc + 2, sp.length - 1), q.pat)\n\n  if (testMode) {\n    return q\n  }\n\n  for (var x in q.pat.statements) {\n    var st = q.pat.statements[x]\n    if (st.subject.termType === 'NamedNode') {\n      if (kb.fetcher) {\n        kb.fetcher.lookUpThing(st.subject, 'sparql:' + st.subject)\n      }\n    }\n    if (st.object.termType === 'NamedNode') {\n      if (kb.fetcher) {\n        kb.fetcher.lookUpThing(st.object, 'sparql:' + st.object)\n      }\n    }\n  }\n  // alert(q.pat)\n  return q\n// checkVars()\n// *******************************************************************//\n}\n","/* @file Update Manager Class\n**\n** 2007-07-15 original SPARQL Update module by Joe Presbrey <presbrey@mit.edu>\n** 2010-08-08 TimBL folded in Kenny's WEBDAV\n** 2010-12-07 TimBL added local file write code\n*/\nimport IndexedFormula from './store'\nimport { docpart, join as uriJoin } from './uri'\nimport Fetcher, { Options } from './fetcher'\nimport Namespace from './namespace'\nimport Serializer from './serializer'\nimport { isBlankNode, isStore } from './utils/terms'\nimport * as Util from './utils-js'\nimport Statement from './statement'\nimport RDFlibNamedNode from './named-node'\nimport { termValue } from './utils/termValue'\nimport { BlankNode, NamedNode, Quad, Quad_Graph, Quad_Object, Quad_Predicate, Quad_Subject, Term, } from './tf-types'\n\ninterface UpdateManagerFormula extends IndexedFormula {\n  fetcher: Fetcher\n}\n\ntype CallBackFunction = (uri: string, ok: boolean, message: string, response: Error | Response) => {} | void\n\n/**\n* The UpdateManager is a helper object for a store.\n* Just as a Fetcher provides the store with the ability to read and write,\n* the Update Manager provides functionality for making small patches in real time,\n* and also looking out for concurrent updates from other agents\n*/\nexport default class UpdateManager {\n\n  store: UpdateManagerFormula\n\n  ifps: {}\n\n  fps: {}\n\n  /** Index of objects for coordinating incoming and outgoing patches */\n  patchControl: []\n\n  /** Object of namespaces */\n  ns: any\n\n  /**\n   * @param  store - The quadstore to store data and metadata. Created if not passed.\n  */\n  constructor(store?: IndexedFormula) {\n    store = store || new IndexedFormula()\n    if (store.updater) {\n      throw new Error(\"You can't have two UpdateManagers for the same store\")\n    }\n    if (!(store as UpdateManagerFormula).fetcher) {\n      (store as UpdateManagerFormula).fetcher = new Fetcher(store)\n    }\n    this.store = store as UpdateManagerFormula\n    store.updater = this\n    this.ifps = {}\n    this.fps = {}\n    this.ns = {}\n    this.ns.link = Namespace('http://www.w3.org/2007/ont/link#')\n    this.ns.http = Namespace('http://www.w3.org/2007/ont/http#')\n    this.ns.httph = Namespace('http://www.w3.org/2007/ont/httph#')\n    this.ns.ldp = Namespace('http://www.w3.org/ns/ldp#')\n    this.ns.rdf = Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#')\n    this.ns.rdfs = Namespace('http://www.w3.org/2000/01/rdf-schema#')\n    this.ns.rdf = Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#')\n    this.ns.owl = Namespace('http://www.w3.org/2002/07/owl#')\n\n    this.patchControl = []\n  }\n\n  patchControlFor(doc: NamedNode) {\n    if (!this.patchControl[doc.value]) {\n      this.patchControl[doc.value] = []\n    }\n    return this.patchControl[doc.value]\n  }\n\n  isHttpUri(uri: string) {\n    return (uri.slice(0, 4) === 'http')\n  }\n\n  /** Remove from the store HTTP authorization metadata\n  * The editable function below relies on copies we have in the store\n  * of the results of previous HTTP transactions. However, when\n  * the user logs in, then that data misrepresents what would happen\n  * if the user tried again.\n  */\n  flagAuthorizationMetadata(kb?: IndexedFormula) {\n    if (!kb) {\n      kb = this.store\n    }\n    const meta = kb.fetcher?.appNode\n    const requests = kb.statementsMatching(undefined, this.ns.link('requestedURI'), undefined, meta).map(st => st.subject)\n    for (const request of requests) {\n      const response = kb.any(request, this.ns.link('response'), null, meta) as Quad_Subject\n      if (response != undefined) { // ts\n        kb.add(response, this.ns.link('outOfDate'), true as any, meta) // @@ Boolean is fine - fix types\n      }\n    }\n  }\n\n  /**\n   * Tests whether a file is editable.\n   * If the file has a specific annotation that it is machine written,\n   * for safety, it is editable (this doesn't actually check for write access)\n   * If the file has wac-allow and accept patch headers, those are respected.\n   * and local write access is determined by those headers.\n   * This async version not only looks at past HTTP requests, it also makes new ones if necessary.\n   *\n   * @returns The method string N3PATCH or SPARQL or DAV or\n   *   LOCALFILE or false if known, undefined if not known.\n   */\n  async checkEditable(uri: string | NamedNode, kb?: IndexedFormula): Promise<string | boolean | undefined> {\n    if (!uri) {\n      return false // Eg subject is bnode, no known doc to write to\n    }\n    if (!kb) {\n      kb = this.store\n    }\n\n    const initial = this.editable(uri, kb)\n    if (initial !== undefined) {\n      return initial\n    }\n    await kb.fetcher?.load(uri)\n    const final = this.editable(uri, kb)\n    // console.log(`Loaded ${uri} just to check editable, result: ${final}.`)\n    return final\n  }\n  /**\n   * Tests whether a file is editable.\n   * If the file has a specific annotation that it is machine written,\n   * for safety, it is editable (this doesn't actually check for write access)\n   * If the file has wac-allow and accept patch headers, those are respected.\n   * and local write access is determined by those headers.\n   * This synchronous version only looks at past HTTP requests, does not make new ones.\n   *\n   * @returns The method string SPARQL or DAV or\n   *   LOCALFILE or false if known, undefined if not known.\n   */\n  editable(uri: string | NamedNode, kb?: IndexedFormula): string | boolean | undefined {\n    if (!uri) {\n      return false // Eg subject is bnode, no known doc to write to\n    }\n    if (!kb) {\n      kb = this.store\n    }\n    uri = termValue(uri)\n\n    if (!this.isHttpUri(uri as string)) {\n      if (kb.holds(\n        kb.rdfFactory.namedNode(uri),\n        kb.rdfFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'),\n        kb.rdfFactory.namedNode('http://www.w3.org/2007/ont/link#MachineEditableDocument'))) {\n        return 'LOCALFILE'\n      }\n    }\n\n    var request\n    var definitive = false\n    const meta = kb.fetcher?.appNode\n    // const kb = s\n\n    // @ts-ignore passes a string to kb.each, which expects a term. Should this work?\n    var requests = kb.each(undefined, this.ns.link('requestedURI'), docpart(uri), meta)\n    var method: string\n    for (var r = 0; r < requests.length; r++) {\n      request = requests[r]\n      if (request !== undefined) {\n        const response = kb.any(request, this.ns.link('response'), null, meta) as Quad_Subject\n        if (response !== undefined) { // ts\n\n          const outOfDate = kb.anyJS(response, this.ns.link('outOfDate'), null, meta) as Quad_Subject\n          if (outOfDate) continue\n\n          var wacAllow = kb.anyValue(response, this.ns.httph('wac-allow'))\n          if (wacAllow) {\n            for (var bit of wacAllow.split(',')) {\n              var lr = bit.split('=')\n              if (lr[0].includes('user') && !lr[1].includes('write') && !lr[1].includes('append')) {\n                // console.log('    editable? excluded by WAC-Allow: ', wacAllow)\n                return false\n              }\n            }\n          }\n          var acceptPatch = kb.each(response, this.ns.httph('accept-patch'))\n          if (acceptPatch.length) {\n            for (let i = 0; i < acceptPatch.length; i++) {\n              method = acceptPatch[i].value.trim()\n              if (method.indexOf('text/n3') >= 0) return 'N3PATCH'\n              if (method.indexOf('application/sparql-update') >= 0) return 'SPARQL'\n              if (method.indexOf('application/sparql-update-single-match') >= 0) return 'SPARQL'\n            }\n          }\n          var authorVia = kb.each(response, this.ns.httph('ms-author-via'))\n          if (authorVia.length) {\n            for (let i = 0; i < authorVia.length; i++) {\n              method = authorVia[i].value.trim()\n              if (method.indexOf('SPARQL') >= 0) {\n                return 'SPARQL'\n              }\n              if (method.indexOf('DAV') >= 0) {\n                return 'DAV'\n              }\n            }\n          }\n\n          if (!this.isHttpUri(uri as string)) {\n            if (!wacAllow) return false;\n            else return 'LOCALFILE';\n          }\n\n          var status = kb.each(response, this.ns.http('status'))\n          if (status.length) {\n            for (let i = 0; i < status.length; i++) {\n              // @ts-ignore since statuses should be TFTerms, this should always be false\n              if (status[i] === 200 || status[i] === 404) {\n                definitive = true\n                // return false // A definitive answer\n              }\n            }\n          }\n        } else {\n          // console.log('UpdateManager.editable: No response for ' + uri + '\\n')\n        }\n      }\n    }\n    if (requests.length === 0) {\n      // console.log('UpdateManager.editable: No request for ' + uri + '\\n')\n    } else {\n      if (definitive) {\n        return false // We have got a request and it did NOT say editable => not editable\n      }\n    }\n    // console.log('UpdateManager.editable: inconclusive for ' + uri + '\\n')\n    return undefined // We don't know (yet) as we haven't had a response (yet)\n  }\n\n  anonymize(obj) {\n    let anonymized = (obj.toNT().substr(0, 2) === '_:' && this.mentioned(obj))\n      ? '?' + obj.toNT().substr(2)\n      : obj.toNT();\n\n    return anonymized;\n  }\n\n  anonymizeNT(stmt: Quad) {\n    return this.anonymize(stmt.subject) + ' ' +\n      this.anonymize(stmt.predicate) + ' ' +\n      this.anonymize(stmt.object) + ' .'\n  }\n\n  nTriples(stmt) {\n    return `${stmt.subject.toNT()} ${stmt.predicate.toNT()} ${stmt.object.toNT()} .`\n  }\n\n  /**\n   * Returns a list of all bnodes occurring in a statement\n   * @private\n   */\n  statementBnodes(st: Quad): BlankNode[] {\n    return [st.subject, st.predicate, st.object].filter(function (x) {\n      return isBlankNode(x)\n    }) as BlankNode[]\n  }\n\n  /**\n   * Returns a list of all bnodes occurring in a list of statements\n   * @private\n   */\n  statementArrayBnodes(sts: ReadonlyArray<Quad>) {\n    var bnodes: BlankNode[] = []\n    for (let i = 0; i < sts.length; i++) {\n      bnodes = bnodes.concat(this.statementBnodes(sts[i]))\n    }\n    bnodes.sort() // in place sort - result may have duplicates\n    var bnodes2: BlankNode[] = []\n    for (let j = 0; j < bnodes.length; j++) {\n      if (j === 0 || !bnodes[j].equals(bnodes[j - 1])) {\n        bnodes2.push(bnodes[j])\n      }\n    }\n    return bnodes2\n  }\n\n  /**\n   * Makes a cached list of [Inverse-]Functional properties\n   * @private\n   */\n  cacheIfps() {\n    this.ifps = {}\n    var a = this.store.each(undefined, this.ns.rdf('type'),\n      this.ns.owl('InverseFunctionalProperty'))\n    for (let i = 0; i < a.length; i++) {\n      this.ifps[a[i].value] = true\n    }\n    this.fps = {}\n    a = this.store.each(undefined, this.ns.rdf('type'), this.ns.owl('FunctionalProperty'))\n    for (let i = 0; i < a.length; i++) {\n      this.fps[a[i].value] = true\n    }\n  }\n\n  /**\n   * Returns a context to bind a given node, up to a given depth\n   * @private\n   */\n  bnodeContext2(x, source, depth) {\n    // Return a list of statements which indirectly identify a node\n    //  Depth > 1 if try further indirection.\n    //  Return array of statements (possibly empty), or null if failure\n    var sts = this.store.statementsMatching(undefined, undefined, x, source) // incoming links\n    var y\n    var res\n    for (let i = 0; i < sts.length; i++) {\n      if (this.fps[sts[i].predicate.value]) {\n        y = sts[i].subject\n        if (!y.isBlank) {\n          return [sts[i]]\n        }\n        if (depth) {\n          res = this.bnodeContext2(y, source, depth - 1)\n          if (res) {\n            return res.concat([sts[i]])\n          }\n        }\n      }\n    }\n    // outgoing links\n    sts = this.store.statementsMatching(x, undefined, undefined, source)\n    for (let i = 0; i < sts.length; i++) {\n      if (this.ifps[sts[i].predicate.value]) {\n        y = sts[i].object\n        if (!y.isBlank) {\n          return [sts[i]]\n        }\n        if (depth) {\n          res = this.bnodeContext2(y, source, depth - 1)\n          if (res) {\n            return res.concat([sts[i]])\n          }\n        }\n      }\n    }\n    return null // Failure\n  }\n\n  /**\n   * Returns the smallest context to bind a given single bnode\n   * @private\n   */\n  bnodeContext1(x, source) {\n    // Return a list of statements which indirectly identify a node\n    //   Breadth-first\n    for (var depth = 0; depth < 3; depth++) { // Try simple first\n      var con = this.bnodeContext2(x, source, depth)\n      if (con !== null) return con\n    }\n    // If we can't guarantee unique with logic just send all info about node\n    return this.store.connectedStatements(x, source) // was:\n    // throw new Error('Unable to uniquely identify bnode: ' + x.toNT())\n  }\n\n  /**\n   * @private\n   */\n  mentioned(x) {\n    return this.store.statementsMatching(x, null, null, null).length !== 0 || // Don't pin fresh bnodes\n      this.store.statementsMatching(null, x).length !== 0 ||\n      this.store.statementsMatching(null, null, x).length !== 0\n  }\n\n  /**\n   * @private\n   */\n  bnodeContext(bnodes, doc) {\n    var context = []\n    if (bnodes.length) {\n      this.cacheIfps()\n      for (let i = 0; i < bnodes.length; i++) { // Does this occur in old graph?\n        var bnode = bnodes[i]\n        if (!this.mentioned(bnode)) continue\n        context = context.concat(this.bnodeContext1(bnode, doc))\n      }\n    }\n    return context\n  }\n\n  /**\n   * Returns the best context for a single statement\n   * @private\n   */\n  statementContext(st: Quad) {\n    var bnodes = this.statementBnodes(st)\n    return this.bnodeContext(bnodes, st.graph)\n  }\n\n  /**\n   * @private\n   */\n  contextWhere(context) {\n    var updater = this\n    return (!context || context.length === 0)\n      ? ''\n      : 'WHERE { ' +\n      context.map(function (x) {\n        return updater.anonymizeNT(x)\n      }).join('\\n') + ' }\\n'\n  }\n\n  /**\n   * @private\n   */\n  fire(\n    uri: string,\n    query: string,\n    callbackFunction: CallBackFunction,\n    options: Options = {}\n  ): Promise<void> {\n    return Promise.resolve()\n      .then(() => {\n        if (!uri) {\n          throw new Error('No URI given for remote editing operation: ' + query)\n        }\n        // console.log('UpdateManager: sending update to <' + uri + '>')\n\n        options.noMeta = true;\n        options.contentType = options.contentType || 'application/sparql-update';\n        options.body = query;\n\n        return this.store.fetcher.webOperation('PATCH', uri, options)\n      })\n      .then(response => {\n        if (!response.ok) {\n          let message = 'UpdateManager: update failed for <' + uri + '> status=' +\n            response.status + ', ' + response.statusText +\n            '\\n   for query: ' + query\n          // console.log(message)\n          throw new Error(message)\n        }\n\n        // console.log('UpdateManager: update Ok for <' + uri + '>')\n\n        callbackFunction(uri, response.ok, response.responseText as string, response)\n      })\n      .catch(err => {\n        callbackFunction(uri, false, err.message, err)\n      })\n  }\n\n  // ARE THESE THREE FUNCTIONS USED? DEPRECATE?\n\n  /** return a statemnet updating function\n   *\n   * This does NOT update the statement.\n   * It returns an object which includes\n   *  function which can be used to change the object of the statement.\n   */\n  update_statement(statement: Quad) {\n    if (statement && !statement.graph) {\n      return\n    }\n    var updater = this\n    var context = this.statementContext(statement)\n\n    return {\n      statement: statement ? [statement.subject, statement.predicate, statement.object, statement.graph] : undefined,\n      statementNT: statement ? this.anonymizeNT(statement) : undefined,\n      where: updater.contextWhere(context),\n\n      set_object: function (obj, callbackFunction) {\n        var query = this.where\n        query += 'DELETE DATA { ' + this.statementNT + ' } ;\\n'\n        query += 'INSERT DATA { ' +\n          // @ts-ignore `this` might refer to the wrong scope. Does this work?\n          this.anonymize(this.statement[0]) + ' ' +\n          // @ts-ignore\n          this.anonymize(this.statement[1]) + ' ' +\n          // @ts-ignore\n          this.anonymize(obj) + ' ' + ' . }\\n'\n\n        updater.fire((this.statement as [Quad_Subject, Quad_Predicate, Quad_Object, Quad_Graph])[3].value, query, callbackFunction)\n      }\n    }\n  }\n\n  insert_statement(st: Quad, callbackFunction: CallBackFunction): void {\n    var st0 = st instanceof Array ? st[0] : st\n    var query = this.contextWhere(this.statementContext(st0))\n\n    if (st instanceof Array) {\n      var stText = ''\n      for (let i = 0; i < st.length; i++) stText += st[i] + '\\n'\n      query += 'INSERT DATA { ' + stText + ' }\\n'\n    } else {\n      query += 'INSERT DATA { ' +\n        this.anonymize(st.subject) + ' ' +\n        this.anonymize(st.predicate) + ' ' +\n        this.anonymize(st.object) + ' ' + ' . }\\n'\n    }\n\n    this.fire(st0.graph.value, query, callbackFunction)\n  }\n\n  delete_statement(st: Quad | Quad[], callbackFunction: CallBackFunction): void {\n    var st0 = st instanceof Array ? st[0] : st\n    var query = this.contextWhere(this.statementContext(st0))\n\n    if (st instanceof Array) {\n      var stText = ''\n      for (let i = 0; i < st.length; i++) stText += st[i] + '\\n'\n      query += 'DELETE DATA { ' + stText + ' }\\n'\n    } else {\n      query += 'DELETE DATA { ' +\n        this.anonymize(st.subject) + ' ' +\n        this.anonymize(st.predicate) + ' ' +\n        this.anonymize(st.object) + ' ' + ' . }\\n'\n    }\n\n    this.fire(st0.graph.value, query, callbackFunction)\n  }\n\n  /// //////////////////////\n\n  /**\n   * Requests a now or future action to refresh changes coming downstream\n   * This is designed to allow the system to re-request the server version,\n   * when a websocket has pinged to say there are changes.\n   * If the websocket, by contrast, has sent a patch, then this may not be necessary.\n   *\n   * @param doc\n   * @param action\n   */\n  requestDownstreamAction(doc: NamedNode, action): void {\n    var control = this.patchControlFor(doc)\n    if (!control.pendingUpstream) {\n      action(doc)\n    } else {\n      if (control.downstreamAction) {\n        if ('' + control.downstreamAction !== '' + action) {  // Kludge compare\n          throw new Error(\"Can't wait for > 1 different downstream actions\")\n        }\n      } else {\n        control.downstreamAction = action\n      }\n    }\n  }\n\n  /**\n   * We want to start counting websocket notifications\n   * to distinguish the ones from others from our own.\n   */\n  clearUpstreamCount(doc: NamedNode): void {\n    var control = this.patchControlFor(doc)\n    control.upstreamCount = 0\n  }\n\n  getUpdatesVia(doc: NamedNode): string | null {\n    var linkHeaders = this.store.fetcher.getHeader(doc, 'updates-via')\n    if (!linkHeaders || !linkHeaders.length) return null\n    return linkHeaders[0].trim()\n  }\n\n  addDownstreamChangeListener(doc: NamedNode, listener): void {\n    var control = this.patchControlFor(doc)\n    if (!control.downstreamChangeListeners) { control.downstreamChangeListeners = [] }\n    control.downstreamChangeListeners.push(listener)\n    this.setRefreshHandler(doc, (doc: NamedNode) => {\n      this.reloadAndSync(doc)\n    })\n  }\n\n  reloadAndSync(doc: NamedNode): void {\n    var control = this.patchControlFor(doc)\n    var updater = this\n\n    if (control.reloading) {\n      // console.log('   Already reloading - note this load may be out of date')\n      control.outOfDate = true\n      return // once only needed @@ Not true, has changed again\n    }\n    control.reloading = true\n    var retryTimeout = 1000 // ms\n    var tryReload = function () {\n      // console.log('try reload - timeout = ' + retryTimeout)\n      updater.reload(updater.store, doc, function (ok, message, response) {\n        if (ok) {\n          if (control.downstreamChangeListeners) {\n            for (let i = 0; i < control.downstreamChangeListeners.length; i++) {\n              // console.log('        Calling downstream listener ' + i)\n              control.downstreamChangeListeners[i]()\n            }\n          }\n          control.reloading = false\n          if (control.outOfDate) {\n            // console.log('   Extra reload because of extra update.')\n            control.outOfDate = false\n            tryReload()\n          }\n        } else {\n          control.reloading = false\n          if (response && (response as Response).status === 0) {\n            // console.log('Network error refreshing the data. Retrying in ' +\n            // retryTimeout / 1000)\n            control.reloading = true\n            retryTimeout = retryTimeout * 2\n            setTimeout(tryReload, retryTimeout)\n          } else {\n            // console.log('Error ' + (response as Response).status + 'refreshing the data:' +\n            //  message + '. Stopped' + doc)\n          }\n        }\n      })\n    }\n    tryReload()\n  }\n\n  /**\n   * Sets up websocket to listen on\n   *\n   * There is coordination between upstream changes and downstream ones\n   * so that a reload is not done in the middle of an upstream patch.\n   * If you use this API then you get called when a change happens, and you\n   * have to reload the file yourself, and then refresh the UI.\n   * Alternative is addDownstreamChangeListener(), where you do not\n   * have to do the reload yourself. Do mot mix them.\n   *\n   * kb contains the HTTP  metadata from previous operations\n   *\n   * @param doc\n   * @param handler\n   *\n   * @returns {boolean}\n   */\n  setRefreshHandler(doc: NamedNode, handler): boolean {\n    let wssURI = this.getUpdatesVia(doc) // relative\n    // var kb = this.store\n    var theHandler = handler\n    var self = this\n    var updater = this\n    var retryTimeout = 1500 // *2 will be 3 Seconds, 6, 12, etc\n    var retries = 0\n\n    if (!wssURI) {\n      // console.log('Server does not support live updates through Updates-Via :-(')\n      return false\n    }\n\n    wssURI = uriJoin(wssURI, doc.value)\n    const validWssURI = wssURI.replace(/^http:/, 'ws:').replace(/^https:/, 'wss:')\n    // console.log('Web socket URI ' + wssURI)\n\n    var openWebsocket = function () {\n      // From https://github.com/solid/solid-spec#live-updates\n      var socket\n      if (typeof WebSocket !== 'undefined') {\n        socket = new WebSocket(validWssURI)\n      } else if (typeof window !== 'undefined' && window.WebSocket) {\n        socket = (window as any).WebSocket(validWssURI)\n      } else {\n        // console.log('Live update disabled, as WebSocket not supported by platform :-(')\n        return\n      }\n      socket.onopen = function () {\n        // console.log('    websocket open')\n        retryTimeout = 1500 // reset timeout to fast on success\n        this.send('sub ' + doc.value)\n        if (retries) {\n          // console.log('Web socket has been down, better check for any news.')\n          updater.requestDownstreamAction(doc, theHandler)\n        }\n      }\n      var control = self.patchControlFor(doc)\n      control.upstreamCount = 0\n\n      socket.onerror = function onerror(err: Error) {\n        // console.log('Error on Websocket:', err)\n      }\n\n      // https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent\n      //\n      // 1000  CLOSE_NORMAL  Normal closure; the connection successfully completed whatever purpose for which it was created.\n      // 1001  CLOSE_GOING_AWAY  The endpoint is going away, either\n      //                                  because of a server failure or because the browser is navigating away from the page that opened the connection.\n      // 1002  CLOSE_PROTOCOL_ERROR  The endpoint is terminating the connection due to a protocol error.\n      // 1003  CLOSE_UNSUPPORTED  The connection is being terminated because the endpoint\n      //                                  received data of a type it cannot accept (for example, a text-only endpoint received binary data).\n      // 1004                             Reserved. A meaning might be defined in the future.\n      // 1005  CLOSE_NO_STATUS  Reserved.  Indicates that no status code was provided even though one was expected.\n      // 1006  CLOSE_ABNORMAL  Reserved. Used to indicate that a connection was closed abnormally (\n      //\n      //\n      socket.onclose = function (event: CloseEvent) {\n        // console.log('*** Websocket closed with code ' + event.code +\n        //   \", reason '\" + event.reason + \"' clean = \" + event.wasClean)\n        retryTimeout *= 2\n        retries += 1\n        // console.log('Retrying in ' + retryTimeout + 'ms') // (ask user?)\n        setTimeout(function () {\n          // console.log('Trying websocket again')\n          openWebsocket()\n        }, retryTimeout)\n      }\n      socket.onmessage = function (msg: MessageEvent) {\n        if (msg.data && msg.data.slice(0, 3) === 'pub') {\n          if ('upstreamCount' in control) {\n            control.upstreamCount -= 1\n            if (control.upstreamCount >= 0) {\n              // console.log('just an echo: ' + control.upstreamCount)\n              return // Just an echo\n            }\n          }\n          // console.log('Assume a real downstream change: ' + control.upstreamCount + ' -> 0')\n          control.upstreamCount = 0\n          self.requestDownstreamAction(doc, theHandler)\n        }\n      }\n    } // openWebsocket\n    openWebsocket()\n\n    return true\n  }\n\n  /**\n   * This high-level function updates the local store iff the web is changed successfully.\n   * Deletions, insertions may be undefined or single statements or lists or formulae (may contain bnodes which can be indirectly identified by a where clause).\n   * The `why` property of each statement must be the give the web document to be updated.\n   * The statements to be deleted and inserted may span more than one web document.\n   * @param deletions - Statement or statements to be deleted.\n   * @param insertions - Statement or statements to be inserted.\n   * @returns a promise\n   */\n  updateMany(\n    deletions: ReadonlyArray<Statement>,\n    insertions: ReadonlyArray<Statement> = []\n  ): Promise<void[]> {\n    const docs = deletions.concat(insertions).map(st => st.why)\n    const thisUpdater = this\n    const uniqueDocs: Array<NamedNode> = []\n    docs.forEach(doc => {\n      if (!uniqueDocs.find(uniqueDoc => uniqueDoc.equals(doc))) uniqueDocs.push(doc as NamedNode)\n    })\n    const updates = uniqueDocs.map(doc =>\n      thisUpdater.update(deletions.filter(st => st.why.equals(doc)),\n        insertions.filter(st => st.why.equals(doc))))\n    if (updates.length > 1) {\n      // console.log(`@@ updateMany to ${updates.length}: ${uniqueDocs}`)\n    }\n    return Promise.all(updates)\n  }\n\n  /**\n   * @private\n   * \n   * This helper function constructs SPARQL Update query from resolved arguments.\n   * \n   * @param ds: deletions array.\n   * @param is: insertions array.\n   * @param bnodes_context: Additional context to uniquely identify any blank nodes.\n   */\n  constructSparqlUpdateQuery(\n    ds: ReadonlyArray<Statement>,\n    is: ReadonlyArray<Statement>,\n    bnodes_context,\n  ): string {\n    var whereClause = this.contextWhere(bnodes_context)\n    var query = ''\n    if (whereClause.length) { // Is there a WHERE clause?\n      if (ds.length) {\n        query += 'DELETE { '\n        for (let i = 0; i < ds.length; i++) {\n          query += this.anonymizeNT(ds[i]) + '\\n'\n        }\n        query += ' }\\n'\n      }\n      if (is.length) {\n        query += 'INSERT { '\n        for (let i = 0; i < is.length; i++) {\n          query += this.anonymizeNT(is[i]) + '\\n'\n        }\n        query += ' }\\n'\n      }\n      query += whereClause\n    } else { // no where clause\n      if (ds.length) {\n        query += 'DELETE DATA { '\n        for (let i = 0; i < ds.length; i++) {\n          query += this.anonymizeNT(ds[i]) + '\\n'\n        }\n        query += ' } \\n'\n      }\n      if (is.length) {\n        if (ds.length) query += ' ; '\n        query += 'INSERT DATA { '\n        for (let i = 0; i < is.length; i++) {\n          query += this.nTriples(is[i]) + '\\n'\n        }\n        query += ' }\\n'\n      }\n    }\n    return query;\n  }\n\n  /**\n   * @private\n   * \n   * This helper function constructs n3-patch query from resolved arguments.\n   * \n   * @param ds: deletions array.\n   * @param is: insertions array.\n   * @param bnodes_context: Additional context to uniquely identify any blanknodes.\n   */\n  constructN3PatchQuery(\n    ds: ReadonlyArray<Statement>,\n    is: ReadonlyArray<Statement>,\n    bnodes_context,\n  ): string {\n    var query = `\n@prefix solid: <http://www.w3.org/ns/solid/terms#>.\n@prefix ex: <http://www.example.org/terms#>.\n\n_:patch\n`;\n    // If bnode context is non trivial, express it as ?conditions formula.\n    if (bnodes_context && bnodes_context.length > 0) {\n      query += `\n      solid:where {\n        ${bnodes_context.map((x) => this.anonymizeNT(x)).join('\\n        ')}\n      };`\n    }\n    if (ds.length > 0) {\n      query += `\n      solid:deletes {\n        ${ds.map((x) => this.anonymizeNT(x)).join('\\n        ')}\n      };`\n    }\n    if (is.length > 0) {\n      query += `\n      solid:inserts {\n        ${is.map((x) => this.anonymizeNT(x)).join('\\n        ')}\n      };`\n    }\n    query += \"   a solid:InsertDeletePatch .\\n\"\n\n    return query;\n  }\n\n  /**\n   * This high-level function updates the local store if the web is changed successfully.\n   * Deletions, insertions may be undefined or single statements or lists or formulae (may contain bnodes which can be indirectly identified by a where clause).\n   * The `why` property of each statement must be the same and give the web document to be updated.\n   * @param deletions - Statement or statements to be deleted.\n   * @param insertions - Statement or statements to be inserted.\n   * @param callback - called as callbackFunction(uri, success, errorbody)\n   *           OR returns a promise\n   * @param options - Options for the fetch call\n   */\n  update(\n    deletions: ReadonlyArray<Statement>,\n    insertions: ReadonlyArray<Statement>,\n    callback?: (\n      uri: string | undefined | null,\n      success: boolean,\n      errorBody?: string,\n      response?: Response | Error\n    ) => void,\n    secondTry?: boolean,\n    options: Options = {}\n  ): void | Promise<void> {\n    if (!callback) {\n      var thisUpdater = this\n      return new Promise(function (resolve, reject) { // Promise version\n        thisUpdater.update(deletions, insertions, function (uri, ok, errorBody) {\n          if (!ok) {\n            reject(new Error(errorBody))\n          } else {\n            resolve()\n          }\n        }, secondTry, options) // callbackFunction\n      }) // promise\n    } // if\n\n    try {\n      var kb = this.store\n      var ds = !deletions ? []\n        : isStore(deletions) ? deletions.statements\n          : deletions instanceof Array ? deletions : [deletions]\n      var is = !insertions ? []\n        : isStore(insertions) ? insertions.statements\n          : insertions instanceof Array ? insertions : [insertions]\n      if (!(ds instanceof Array)) {\n        throw new Error('Type Error ' + (typeof ds) + ': ' + ds)\n      }\n      if (!(is instanceof Array)) {\n        throw new Error('Type Error ' + (typeof is) + ': ' + is)\n      }\n      if (ds.length === 0 && is.length === 0) {\n        return callback(null, true) // success -- nothing needed to be done.\n      }\n      var doc = ds.length ? ds[0].graph : is[0].graph\n      if (!doc) {\n        let message = 'Error patching: statement does not specify which document to patch:' + ds[0] + ', ' + is[0]\n        // console.log(message)\n        throw new Error(message)\n      }\n      if (doc.termType !== 'NamedNode') {\n        let message = 'Error patching: document not a NamedNode:' + ds[0] + ', ' + is[0]\n        // console.log(message)\n        throw new Error(message)\n      }\n      var control = this.patchControlFor(doc)\n\n      var startTime = Date.now()\n\n      var props = ['subject', 'predicate', 'object', 'why']\n      var verbs = ['insert', 'delete']\n      var clauses = { 'delete': ds, 'insert': is }\n      verbs.map(function (verb) {\n        clauses[verb].map(function (st: Quad) {\n          if (!doc.equals(st.graph)) {\n            throw new Error('update: destination ' + doc +\n              ' inconsistent with delete quad ' + st.graph)\n          }\n          props.map(function (prop) {\n            if (typeof st[prop] === 'undefined') {\n              throw new Error('update: undefined ' + prop + ' of statement.')\n            }\n          })\n        })\n      })\n\n      var protocol = this.editable(doc.value, kb);\n\n      if (protocol === false) {\n        throw new Error('Update: Can\\'t make changes in uneditable ' + doc)\n      }\n      if (protocol === undefined) { // Not enough metadata\n        if (secondTry) {\n          throw new Error('Update: Loaded ' + doc + \"but still can't figure out what editing protocol it supports.\")\n        }\n        // console.log(`Update: have not loaded ${doc} before: loading now...`);\n        (this.store.fetcher.load(doc as NamedNode) as Promise<Response>).then(response => {\n          this.update(deletions, insertions, callback, true, options)\n        }, err => {\n          if (err.response.status === 404) { // nonexistent files are fine\n            this.update(deletions, insertions, callback, true, options)\n          } else {\n            throw new Error(`Update: Can't get updatability status ${doc} before patching: ${err}`)\n          }\n        })\n        return\n      } else if ((protocol as string).indexOf('SPARQL') >= 0 || (protocol as string).indexOf('N3PATCH') >= 0) {\n        var isSparql = (protocol as string).indexOf('SPARQL') >= 0\n\n        var bnodes: BlankNode[] = []\n        // change ReadOnly type to Mutable type\n        type Mutable<Type> = {\n          -readonly [Key in keyof Type]: Type[Key];\n        }\n\n        if (ds.length) bnodes = this.statementArrayBnodes(ds as Mutable<typeof ds>)\n        if (is.length) bnodes = bnodes.concat(this.statementArrayBnodes(is as Mutable<typeof is>))\n        var context = this.bnodeContext(bnodes, doc)\n\n        var query = isSparql ? this.constructSparqlUpdateQuery(ds, is, context) : this.constructN3PatchQuery(ds, is, context);\n        options.contentType = isSparql ? 'application/sparql-update' : 'text/n3' \n        \n        // Track pending upstream patches until they have finished their callbackFunction\n        control.pendingUpstream = control.pendingUpstream ? control.pendingUpstream + 1 : 1\n        if ('upstreamCount' in control) {\n          control.upstreamCount += 1 // count changes we originated ourselves\n          // console.log('upstream count up to : ' + control.upstreamCount)\n        }\n\n        this.fire(doc.value, query, (uri, success, body, response) => {\n          (response as any).elapsedTimeMs = Date.now() - startTime\n          /* console.log('    UpdateManager: Return ' +\n            (success ? 'success ' : 'FAILURE ') + (response as Response).status +\n            ' elapsed ' + (response as any).elapsedTimeMs + 'ms')\n            */\n          if (success) {\n            try {\n              kb.remove(ds as Mutable<typeof ds>)\n            } catch (e) {\n              success = false\n              body = 'Remote Ok BUT error deleting ' + ds.length + ' from store!!! ' + e\n            } // Add in any case -- help recover from weirdness??\n            for (let i = 0; i < is.length; i++) {\n              kb.add(is[i].subject, is[i].predicate, is[i].object, doc)\n            }\n          }\n\n          callback(uri, success, body, response)\n          control.pendingUpstream -= 1\n          // When upstream patches have been sent, reload state if downstream waiting\n          if (control.pendingUpstream === 0 && control.downstreamAction) {\n            var downstreamAction = control.downstreamAction\n            delete control.downstreamAction\n            // console.log('delayed downstream action:')\n            downstreamAction(doc)\n          }\n        }, options)\n      } else if ((protocol as string).indexOf('DAV') >= 0) {\n        this.updateDav(doc as NamedNode, ds, is, callback, options)\n      } else {\n        if ((protocol as string).indexOf('LOCALFILE') >= 0) {\n          try {\n            this.updateLocalFile(doc as NamedNode, ds, is, callback, options)\n          } catch (e) {\n            callback(doc.value, false,\n              'Exception trying to write back file <' + doc.value + '>\\n'\n              // + tabulator.Util.stackString(e))\n            )\n          }\n        } else {\n          throw new Error(\"Unhandled edit method: '\" + protocol + \"' for \" + doc)\n        }\n      }\n    } catch (e) {\n      callback(undefined, false, 'Exception in update: ' + e + '\\n' +\n        Util.stackString(e))\n    }\n  }\n\n  updateDav(\n    doc: Quad_Subject,\n    ds,\n    is,\n    callbackFunction,\n    options: Options = {}\n  ): null | Promise<void> {\n    let kb = this.store\n    // The code below is derived from Kenny's UpdateCenter.js\n    var request = kb.any(doc, this.ns.link('request'))\n    if (!request) {\n      throw new Error('No record of our HTTP GET request for document: ' +\n        doc)\n    } // should not happen\n    var response = kb.any(request as NamedNode, this.ns.link('response')) as Quad_Subject\n    if (!response) {\n      return null // throw \"No record HTTP GET response for document: \"+doc\n    }\n    var contentType = (kb.the(response, this.ns.httph('content-type')) as Term).value\n\n    // prepare contents of revised document\n    let newSts = kb.statementsMatching(undefined, undefined, undefined, doc).slice() // copy!\n    for (let i = 0; i < ds.length; i++) {\n      Util.RDFArrayRemove(newSts, ds[i])\n    }\n    for (let i = 0; i < is.length; i++) {\n      newSts.push(is[i])\n    }\n\n    const documentString = this.serialize(doc.value, newSts, contentType)\n\n    // Write the new version back\n    var candidateTarget = kb.the(response, this.ns.httph('content-location'))\n    var targetURI\n    if (candidateTarget) {\n      targetURI = uriJoin(candidateTarget.value, targetURI)\n    }\n\n    options.contentType = contentType\n    options.noMeta = true\n    options.body = documentString\n\n    return kb.fetcher.webOperation('PUT', targetURI, options)\n      .then(response => {\n        if (!response.ok) {\n          throw new Error(response.error)\n        }\n\n        for (let i = 0; i < ds.length; i++) {\n          kb.remove(ds[i])\n        }\n        for (let i = 0; i < is.length; i++) {\n          kb.add(is[i].subject, is[i].predicate, is[i].object, doc)\n        }\n\n        callbackFunction(doc.value, response.ok, response.responseText, response)\n      })\n      .catch(err => {\n        callbackFunction(doc.value, false, err.message, err)\n      })\n  }\n\n  /**\n   * Likely deprecated, since this lib no longer deals with browser extension\n   *\n   * @param doc\n   * @param ds\n   * @param is\n   * @param callbackFunction\n   * @param options\n   */\n  updateLocalFile(doc: NamedNode, ds, is, callbackFunction, options: Options = {}): void {\n    const kb = this.store\n    // console.log('Writing back to local file\\n')\n\n    // prepare contents of revised document\n    let newSts = kb.statementsMatching(undefined, undefined, undefined, doc).slice() // copy!\n\n    for (let i = 0; i < ds.length; i++) {\n      Util.RDFArrayRemove(newSts, ds[i])\n    }\n    for (let i = 0; i < is.length; i++) {\n      newSts.push(is[i])\n    }\n    // serialize to the appropriate format\n    var dot = doc.value.lastIndexOf('.')\n    if (dot < 1) {\n      throw new Error('Rewriting file: No filename extension: ' + doc.value)\n    }\n    var ext = doc.value.slice(dot + 1)\n\n    let contentType = Fetcher.CONTENT_TYPE_BY_EXT[ext]\n    if (!contentType) {\n      throw new Error('File extension .' + ext + ' not supported for data write')\n    }\n\n    options.body = this.serialize(doc.value, newSts, contentType);\n    options.contentType = contentType;\n\n    kb.fetcher.webOperation('PUT', doc.value, options).then((response) => {\n      if (!response.ok) return callbackFunction(doc.value, false, response.error)\n      for (let i = 0; i < ds.length; i++) {\n        kb.remove(ds[i]);\n      }\n      for (let i = 0; i < is.length; i++) {\n        kb.add(is[i].subject, is[i].predicate, is[i].object, doc);\n      }\n      callbackFunction(doc.value, true, '')  // success!\n    })\n  }\n\n  /**\n   * @throws {Error} On unsupported content type\n   *\n   * @returns {string}\n   */\n  serialize(uri: string, data: string | Quad[], contentType: string): string {\n    const kb = this.store\n    let documentString\n\n    if (typeof data === 'string') {\n      return data\n    }\n\n    // serialize to the appropriate format\n    var sz = Serializer(kb)\n    sz.suggestNamespaces(kb.namespaces)\n    sz.setBase(uri)\n    switch (contentType) {\n      case 'text/xml':\n      case 'application/rdf+xml':\n        documentString = sz.statementsToXML(data)\n        break\n      case 'text/n3':\n      case 'text/turtle':\n      case 'application/x-turtle': // Legacy\n      case 'application/n3': // Legacy\n        documentString = sz.statementsToN3(data)\n        break\n      default:\n        throw new Error('Content-type ' + contentType +\n          ' not supported for data serialization')\n    }\n\n    return documentString\n  }\n\n  /**\n   * This is suitable for an initial creation of a document.\n   */\n  put(\n    doc: RDFlibNamedNode,\n    data: string | Quad[],\n    contentType: string,\n    callback: (uri: string, ok: boolean, errorMessage?: string, response?: unknown) => void,\n  ): Promise<void> {\n    const kb = this.store\n    let documentString: string\n\n    return Promise.resolve()\n      .then(() => {\n        documentString = this.serialize(doc.value, data, contentType)\n\n        return kb.fetcher\n          .webOperation('PUT', doc.value, { contentType, body: documentString })\n      })\n      .then(response => {\n        if (!response.ok) {\n          return callback(doc.value, response.ok, response.error, response)\n        }\n\n        delete kb.fetcher.nonexistent[doc.value]\n        delete kb.fetcher.requested[doc.value] // @@ could this mess with the requested state machine? if a fetch is in progress\n\n        if (typeof data !== 'string') {\n          data.map((st) => {\n            kb.addStatement(st)\n          })\n        }\n\n        callback(doc.value, response.ok, '', response)\n      })\n      .catch(err => {\n        callback(doc.value, false, err.message)\n      })\n  }\n\n  /**\n   * Reloads a document.\n   *\n   * Fast and cheap, no metadata. Measure times for the document.\n   * Load it provisionally.\n   * Don't delete the statements before the load, or it will leave a broken\n   * document in the meantime.\n   *\n   * @param kb\n   * @param doc {RDFlibNamedNode}\n   * @param callbackFunction\n   */\n  reload(\n    kb: IndexedFormula,\n    doc: docReloadType,\n    callbackFunction: (ok: boolean, message?: string, response?: Error | Response) => {} | void\n  ): void {\n    var startTime = Date.now()\n    // force sets no-cache and\n    const options = {\n      force: true,\n      noMeta: true,\n      clearPreviousData: true,\n    };\n\n    (kb as any).fetcher.nowOrWhenFetched(doc.value, options, function (ok: boolean, body: Body, response: Response) {\n      if (!ok) {\n        // console.log('    ERROR reloading data: ' + body)\n        callbackFunction(false, 'Error reloading data: ' + body, response)\n        //@ts-ignore Where does onErrorWasCalled come from?\n      } else if (response.onErrorWasCalled || response.status !== 200) {\n        // console.log('    Non-HTTP error reloading data! onErrorWasCalled=' +\n        //@ts-ignore Where does onErrorWasCalled come from?\n        // response.onErrorWasCalled + ' status: ' + response.status)\n        callbackFunction(false, 'Non-HTTP error reloading data: ' + body, response)\n      } else {\n        var elapsedTimeMs = Date.now() - startTime\n\n        if (!doc.reloadTimeTotal) doc.reloadTimeTotal = 0\n        if (!doc.reloadTimeCount) doc.reloadTimeCount = 0\n\n        doc.reloadTimeTotal += elapsedTimeMs\n        doc.reloadTimeCount += 1\n\n        // console.log('    Fetch took ' + elapsedTimeMs + 'ms, av. of ' +\n        // doc.reloadTimeCount + ' = ' +\n        // (doc.reloadTimeTotal / doc.reloadTimeCount) + 'ms.')\n\n        callbackFunction(true)\n      }\n    })\n  }\n}\n\ninterface docReloadType extends NamedNode {\n  reloadTimeCount?: number\n  reloadTimeTotal?: number\n}\n","import {\n  IRDFlibDataFactory,\n} from '../types'\nimport Literal from '../literal'\nimport Statement from '../statement'\nimport IndexedFormula from '../store'\nimport Fetcher from '../fetcher'\nimport ExtendedTermFactory from './extended-term-factory'\nimport { NamedNode, Quad_Subject, Quad_Predicate, Quad_Object, Quad_Graph } from '../tf-types'\n\n/** Full RDFLib.js Data Factory */\nconst RDFlibDataFactory: IRDFlibDataFactory = {\n  ...ExtendedTermFactory,\n\n  /**\n   * Creates a new fetcher\n   * @param store - The store to use\n   * @param options - The options\n   */\n  fetcher (store: IndexedFormula, options: any): Fetcher {\n    return new Fetcher(store, options)\n  },\n\n  /**\n   * Creates a new graph (store)\n   */\n  graph (features = undefined, opts = undefined): IndexedFormula {\n    return new IndexedFormula(features, opts || {rdfFactory: ExtendedTermFactory})\n  },\n\n  /**\n   * Creates a new literal node\n   * @param val The lexical value\n   * @param lang The language\n   * @param dt The datatype\n   */\n  lit (val: string, lang?: string, dt?: NamedNode): Literal {\n    return this.literal('' + val, lang || dt)\n  },\n\n  /**\n   * Creates a new statement\n   * @param subject The subject\n   * @param predicate The predicate\n   * @param object The object\n   * @param graph The containing graph\n   */\n  st (\n    subject: Quad_Subject,\n    predicate: Quad_Predicate,\n    object: Quad_Object,\n    graph?: Quad_Graph\n  ): Statement {\n    return this.quad(subject, predicate, object, graph)\n  },\n}\n\nexport default RDFlibDataFactory\n","/*\n * Updates-Via\n */\nimport DataFactory from './factories/rdflib-data-factory'\n\nexport class UpdatesSocket {\n  constructor (parent, via) {\n    this.parent = parent\n    this.via = via\n    this.connected = false\n    this.pending = {}\n    this.subscribed = {}\n    this.socket = {}\n    try {\n      this.socket = new WebSocket(via)\n      this.socket.onopen = this.onOpen\n      this.socket.onclose = this.onClose\n      this.socket.onmessage = this.onMessage\n      this.socket.onerror = this.onError\n    } catch (error) {\n      this.onError(error)\n    }\n  }\n  _decode (q) {\n    var elt\n    var i\n    var k\n    var r\n    var ref\n    var ref1\n    var v\n    r = {}\n    ref = (function () {\n      var j, len, ref, results\n      ref = q.split('&')\n      results = []\n      for (j = 0, len = ref.length; j < len; j++) {\n        elt = ref[j]\n        results.push(elt.split('='))\n      }\n      return results\n    })()\n    for (i in ref) {\n      elt = ref[i]\n      ref1 = [decodeURIComponent(elt[0]), decodeURIComponent(elt[1])]\n      k = ref1[0]\n      v = ref1[1]\n      if (r[k] == null) {\n        r[k] = []\n      }\n      r[k].push(v)\n    }\n    return r\n  }\n  _send (method, uri, data) {\n    var base, message\n    message = [method, uri, data].join(' ')\n    return typeof (base = this.socket).send === 'function' ? base.send(message) : void 0\n  }\n  _subscribe (uri) {\n    this._send('sub', uri, '')\n    this.subscribed[uri] = true\n    return this.subscribed[uri]\n  }\n  onClose (e) {\n    var uri\n    this.connected = false\n    for (uri in this.subscribed) {\n      this.pending[uri] = true\n    }\n    this.subscribed = {}\n    return this.subscribed\n  }\n  onError (e) {\n    throw new Error('onError' + e)\n  }\n  onMessage (e) {\n    var base, message\n    message = e.data.split(' ')\n    if (message[0] === 'ping') {\n      return typeof (base = this.socket).send === 'function' ? base.send('pong ' + message.slice(1).join(' ')) : void 0\n    } else if (message[0] === 'pub') {\n      return this.parent.onUpdate(message[1], this._decode(message[2]))\n    }\n  }\n  onOpen (e) {\n    var results, uri\n    this.connected = true\n    results = []\n    for (uri in this.pending) {\n      delete this.pending[uri]\n      results.push(this._subscribe(uri))\n    }\n    return results\n  }\n  subscribe (uri) {\n    if (this.connected) {\n      return this._subscribe(uri)\n    } else {\n      this.pending[uri] = true\n      return this.pending[uri]\n    }\n  }\n}\n\nexport class UpdatesVia {\n  constructor (fetcher) {\n    this.fetcher = fetcher\n    this.graph = {}\n    this.via = {}\n    this.fetcher.addCallback('headers', this.onHeaders)\n  }\n  onHeaders (d) {\n    var etag, uri, via\n    if (d.headers == null) {\n      return true\n    }\n    if (typeof WebSocket === 'undefined' || WebSocket === null) {\n      return true\n    }\n    etag = d.headers['etag']\n    via = d.headers['updates-via']\n    uri = d.uri\n    if (etag && via) {\n      this.graph[uri] = {\n        etag: etag,\n        via: via\n      }\n      this.register(via, uri)\n    }\n    return true\n  }\n  onUpdate (uri, d) {\n    return this.fetcher.refresh(DataFactory.namedNode(uri))\n  }\n  register (via, uri) {\n    if (this.via[via] == null) {\n      this.via[via] = new UpdatesSocket(this, via)\n    }\n    return this.via[via].subscribe(uri)\n  }\n}\n","import { IRDFlibDataFactory } from './types'\n\nimport BlankNode from './blank-node'\nimport Collection from './collection'\nimport Empty from './empty'\nimport Fetcher from './fetcher'\nimport Formula from './formula'\nimport Store from './store'\nimport jsonParser from './jsonparser'\nimport Literal from './literal'\nimport log from './log'\nimport N3Parser from './n3parser'\nimport NamedNode from './named-node'\nimport Namespace from './namespace'\nimport Node from './node'\nimport parse from './parse'\nimport { Query } from './query'\nimport queryToSPARQL from './query-to-sparql'\nimport RDFaProcessor from './rdfaparser'\nimport RDFParser from './rdfxmlparser'\nimport serialize from './serialize'\nimport Serializer from './serializer'\nimport SPARQLToQuery from './sparql-to-query'\nimport sparqlUpdateParser from './patch-parser'\nimport Statement from './statement'\nimport UpdateManager from './update-manager'\nimport { UpdatesSocket } from './updates-via'\nimport { UpdatesVia } from './updates-via'\nimport * as uri from './uri'\nimport * as Util from './utils-js'\nimport Variable from './variable'\nimport DataFactory from './factories/rdflib-data-factory'\n\n// Prepare bound versions of data factory methods for export\nconst boundDataFactory = {} as IRDFlibDataFactory\nfor (const name in DataFactory) {\n  if (typeof DataFactory[name] === 'function')\n    boundDataFactory[name] = DataFactory[name].bind(DataFactory);\n}\nconst {\n  fetcher,\n  graph,\n  lit,\n  st,\n  namedNode,\n  variable,\n  blankNode,\n  defaultGraph,\n  literal,\n  quad,\n  triple,\n} = boundDataFactory\n\nconst formula = new Formula();\nconst fromNT = str => formula.fromNT(str);\n\nconst term = Node.fromValue\n\n// TODO: this export is broken;\n// it exports the _current_ value of nextId, which is always 0\nconst NextId = BlankNode.nextId\n\nexport * from './utils/terms'\nexport type { AutoInitOptions, ExtendedResponse, FetchError } from './fetcher'\nexport {\n  BlankNode,\n  Collection,\n  DataFactory,\n  Empty,\n  Fetcher,\n  Formula,\n  Store,\n  jsonParser,\n  Literal,\n  log,\n  N3Parser,\n  NamedNode,\n  Namespace,\n  Node,\n  parse,\n  Query,\n  queryToSPARQL,\n  RDFaProcessor,\n  RDFParser,\n  serialize,\n  Serializer,\n  SPARQLToQuery,\n  sparqlUpdateParser,\n  Statement,\n  term,\n  UpdateManager,\n  UpdatesSocket,\n  UpdatesVia,\n  uri,\n  Util,\n  Variable,\n\n  Store as IndexedFormula, // Alias\n\n  NextId,\n\n  fromNT,\n  fetcher,\n  graph,\n  lit,\n  st,\n  namedNode as sym,\n\n  // RDFJS DataFactory interface\n  blankNode,\n  defaultGraph,\n  literal,\n  namedNode,\n  quad,\n  triple,\n  variable,\n}\nexport { termValue } from './utils/termValue'\n\nexport class ConnectedStore extends Store {\n\n  fetcher: Fetcher;\n\n  constructor (features) {\n    super(features)\n    this.fetcher = new Fetcher(this, {})\n  }\n}\n\nexport class  LiveStore extends ConnectedStore {\n\n  updater: UpdateManager;\n  \n  constructor (features) {\n    super(features)\n    this.updater = new UpdateManager(this)\n  }\n}\n"],"names":["root","factory","exports","module","require","define","amd","self","__WEBPACK_EXTERNAL_MODULE__8392__","leafPrototypes","getProto","inProgress","dataWebpackPrefix","debug","x","warn","info","error","success","msg","NamedNode","_Node","iri","_this","_classCallCheck","_callSuper","termValue","_defineProperty","NamedNodeTermType","ClassOrder","value","Error","includes","_inherits","_createClass","key","str","this","split","p","slice","lastIndexOf","q","indexOf","get","set","uri","isTerm","Node","bindings","other","classOrder","termType","toCanonical","equals","toNT","toString","BlankNodeTermType","LiteralTermType","VariableTermType","DefaultGraphTermType","CollectionTermType","EmptyTermType","GraphTermType","HTMLContentType","JSONLDContentType","N3ContentType","N3LegacyContentType","NQuadsAltContentType","NQuadsContentType","NTriplesContentType","RDFXMLContentType","SPARQLUpdateContentType","SPARQLUpdateSingleMatchContentType","TurtleContentType","TurtleLegacyContentType","XHTMLContentType","alert","console","log","docpart","i","document","RDFlibNamedNode","hostpart","u","m","exec","join","given","base","baseColon","baseScheme","baseSingle","lastSlash","path","baseHash","length","match","replace","protocol","refTo","k","l","len","len1","n","o","ref","ref1","s","commonHost","RegExp","string","template","subs","baseA","result","mediaTypeClass","mediaType","trim","linkRelationProperty","relation","callbackify","obj","callbacks","addHook","hook","addCallback","func","push","removeCallback","funcName","name","splice","insertCallback","unshift","fireCallbacks","args","callback","newCallbacks","replaceCallbacks","apply","DOMParserFactory","window","DOMParser","ActiveXObject","domToString","node","options","selfClosing","forEach","skipAttributes","dumpNode","out","noEsc","nodeType","hasAttribute","classWithChildText","matches","class","querySelector","element","textContent","skipNodeWithClass","ename","nodeName","toLowerCase","attrList","attributes","atn","test","replaceClassItemWith","source","re","target","skipClassWithValue","sortAttributes","sort","a","b","localeCompare","childNodes","pop","nodeValue","nl","dtstamp","now","Date","year","getYear","month","getMonth","day","getDate","hour","getUTCHours","minute","getUTCMinutes","second","getSeconds","heavyCompare","y","g","uriMap","nonBlank","signature","lis","statementsMatching","map","st","subject","predicate","object","concat","undefined","comparison","Object","prototype","hasOwnProperty","call","compareTerms","compareTerm","heavyCompareSPO","output","createElement","body","appendChild","parseXML","parseFromString","contentType","RDFArrayRemove","why","string_startswith","pref","stackString","e","stack","lines","toprint","line","charAt","chunks","isStatement","_typeof","isStore","isCollection","isRDFlibObject","isRDFlibSubject","isRDFlibPredicate","isVariable","isLiteral","isQuad","isNamedNode","isBlankNode","isSubject","isPredicate","isRDFObject","isGraph","peg$SyntaxError","message","expected","found","location","captureStackTrace","child","parent","ctor","constructor","peg$subclass","buildMessage","DESCRIBE_EXPECTATION_FNS","literal","expectation","literalEscape","text","escapedParts","parts","Array","classEscape","inverted","any","end","description","hex","ch","charCodeAt","toUpperCase","j","descriptions","type","describeExpected","describeFound","SyntaxError","parse","input","peg$result","peg$FAILED","peg$startRuleFunctions","turtleDoc","peg$parseturtleDoc","peg$startRuleFunction","peg$c0","statements","jsonld","context","toJSON","filter","isArray","assign","peg$c1","peg$c2","peg$literalExpectation","peg$c3","peg$c4","peg$c5","peg$c6","peg$c7","peg$classExpectation","peg$c8","peg$c9","peg$c10","peg$c11","peg$c12","peg$c13","addPrefix","peg$c14","peg$c15","peg$c16","addBase","peg$c17","peg$c18","peg$c19","peg$c20","peg$c21","peg$c22","peg$c23","peg$c24","peg$c25","peg$c26","peg$c27","peg$c28","peg$c29","peg$c30","peg$c31","peg$c32","peg$c33","peg$c34","peg$c35","peg$c36","peg$c37","peg$c38","peg$c39","f","peg$c40","d","peg$c41","c","property","createObject","t","keys","val","peg$c42","peg$c43","peg$c44","peg$c45","peg$c46","peg$c47","peg$c48","peg$c49","expandList","peg$c50","peg$c51","peg$c52","peg$c53","peg$c54","peg$c55","peg$c56","peg$c57","peg$c58","peg$c59","peg$c60","peg$c61","peg$c62","peg$c63","peg$c64","peg$c65","parseInt","parseFloat","resolve","prefix","decrement","peg$c66","peg$c67","peg$c68","peg$c69","peg$c70","peg$c71","peg$c72","peg$c73","peg$c74","peg$c75","peg$c76","peg$c77","peg$c78","peg$c79","decoded","codePointAt","String","fromCharCode","substring","fromCodePoint","peg$c80","peg$c81","peg$c82","hasPrefix","peg$c83","peg$c84","increment","peg$c85","peg$c86","peg$c87","peg$c88","peg$c89","peg$c90","peg$c91","peg$c92","peg$c93","peg$c94","peg$c95","peg$c96","peg$c97","peg$c98","peg$c99","peg$c100","peg$c101","peg$c102","peg$c103","peg$c104","peg$c105","peg$c106","peg$c107","peg$c108","peg$c109","peg$c110","peg$c111","peg$c112","peg$c113","peg$c114","peg$c115","peg$c116","peg$c117","peg$c118","peg$c119","peg$c120","head","peg$c121","peg$c122","peg$c123","peg$c124","peg$c125","peg$c126","peg$c127","peg$c128","peg$c129","peg$c130","peg$c131","peg$c132","peg$c133","peg$c134","peg$c135","peg$c136","peg$c137","peg$c138","peg$c139","peg$c140","peg$c141","peg$c142","peg$c143","peg$c144","peg$c145","peg$c146","peg$c147","peg$c148","peg$c149","peg$c150","peg$c151","peg$c152","peg$c153","peg$c154","peg$c155","peg$c156","peg$c157","peg$c158","peg$c159","peg$c160","peg$c161","peg$c162","peg$c163","peg$c164","peg$c165","peg$c166","peg$c167","peg$c168","peg$c169","peg$c170","peg$c171","peg$c172","peg$c173","peg$c174","peg$c175","peg$c176","peg$c177","peg$c178","peg$c179","peg$c180","tail","peg$c181","peg$c182","peg$c183","peg$c184","peg$c185","peg$c186","peg$c187","peg$c188","peg$currPos","peg$savedPos","peg$posDetailsCache","column","peg$maxFailPos","peg$maxFailExpected","peg$silentFails","startRule","peg$buildSimpleError","peg$computeLocation","ignoreCase","peg$computePosDetails","pos","details","startPos","endPos","startPosDetails","endPosDetails","start","offset","peg$fail","s0","s1","s2","s3","peg$parsestatement","peg$parseIGNORE","s4","s5","s6","s7","s8","substr","peg$parsePNAME_NS_NO_CHECK","peg$parseIRIREF","peg$parseprefixID","peg$parsebase","s9","s10","s11","peg$parsesparqlPrefix","peg$parsesparqlBase","peg$parsedirective","peg$parsecollection","peg$parseBlankNode","peg$parseiri","peg$parsesubject","peg$parsepredicateObjectList","peg$parseblankNodePropertyList","peg$parsetriples","peg$parseWS","peg$parseCOMMENT","peg$parseverb","peg$parseobjectList","peg$parseobject","peg$parsepredicate","peg$parseString","peg$parseLANGTAG","peg$parseRDFLiteral","peg$parseEXPONENT","peg$parseDOUBLE","peg$parseDECIMAL","peg$parseINTEGER","peg$parseNumericLiteral","peg$parseBooleanLiteral","peg$parseliteral","peg$parseECHAR","peg$parseUCHAR","peg$parseSTRING_LITERAL_LONG_SINGLE_QUOTE","peg$parseSTRING_LITERAL_LONG_QUOTE","peg$parseSTRING_LITERAL_SINGLE_QUOTE","peg$parseSTRING_LITERAL_QUOTE","peg$parsePNAME_NS","peg$parsePN_CHARS_U","peg$parsePLX","peg$parsePN_CHARS","peg$parsePN_LOCAL","peg$parsePNAME_LN","peg$parsePrefixedName","peg$parseBLANK_NODE_LABEL","peg$parseANON","peg$parsePN_PREFIX","peg$parseHEX","peg$parsePN_CHARS_BASE","peg$parsePERCENT","peg$parsePN_LOCAL_ESC","URL","Function","isBrowser","isIRI","data","last","list","count","pname","force","find","baseIRI","container","focus","Symbol","iterator","isDeepEqual","isDeepStrictEqual","_require$codes","codes","ERR_AMBIGUOUS_ARGUMENT","ERR_INVALID_ARG_TYPE","ERR_INVALID_ARG_VALUE","ERR_INVALID_RETURN_VALUE","ERR_MISSING_ARGS","AssertionError","inspect","_require$types","isPromise","isRegExp","objectAssign","objectIs","is","lazyLoadComparison","Map","warned","assert","ok","NO_EXCEPTION_SENTINEL","innerFail","innerOk","fn","argLen","generatedMessage","err","actual","operator","stackStartFn","_len","arguments","_key","fail","internalMessage","argsLen","process","emitWarning","bind","errArgs","equal","notEqual","deepEqual","notDeepEqual","deepStrictEqual","notDeepStrictEqual","strictEqual","notStrictEqual","Comparison","instance","Constructor","TypeError","expectedException","compareExceptionKey","isPrototypeOf","getActual","checkIsPromise","then","catch","waitForActual","promiseFn","Promise","resultPromise","expectsError","fnType","expectsNoError","strict","_len6","_key6","throws","_len2","_key2","rejects","_len3","_key3","doesNotThrow","_len4","_key4","doesNotReject","_len5","_key5","ifError","newErr","origStack","tmp2","shift","tmp1","defineProperty","enumerable","configurable","writable","_defineProperties","props","descriptor","_possibleConstructorReturn","_assertThisInitialized","ReferenceError","_wrapNativeSuper","Class","_cache","has","Wrapper","_construct","_getPrototypeOf","create","_setPrototypeOf","Parent","Reflect","construct","sham","Proxy","isNativeReflectConstruct","setPrototypeOf","__proto__","getPrototypeOf","endsWith","search","this_len","blue","green","red","white","kReadableOperator","strictEqualObject","notStrictEqualObject","notIdentical","copyError","inspectValue","compact","customInspect","depth","maxArrayLength","Infinity","showHidden","breakLength","showProxy","sorted","getters","_Error","limit","stackTraceLimit","stderr","isTTY","getColorDepth","res","lastPos","skipped","actualInspected","actualLines","expectedLines","indicator","inputLength","columns","Math","floor","maxCount","repeat","maxLines","max","_actualLines","printedLines","skippedMsg","cur","expectedLine","actualLine","divergingLines","createErrDiff","_res","knownOperators","code","protoProps","subClass","superClass","custom","recurseTimes","ctx","ownKeys","getOwnPropertySymbols","sym","getOwnPropertyDescriptor","_objectSpread","util","createErrorType","Base","NodeError","_Base","arg1","arg2","arg3","getMessage","oneOf","thing","determiner","reason","inspected","RangeError","_slicedToArray","arr","_arrayWithHoles","_arr","_n","_d","_e","_s","_i","next","done","_iterableToArrayLimit","_nonIterableRest","regexFlagsSupported","flags","arrayFromSet","array","arrayFromMap","objectGetOwnPropertySymbols","numberIsNaN","Number","isNaN","uncurryThis","propertyIsEnumerable","objectToString","isAnyArrayBuffer","isArrayBufferView","isDate","isMap","isSet","isNativeError","isBoxedPrimitive","isNumberObject","isStringObject","isBooleanObject","isBigIntObject","isSymbolObject","isFloat32Array","isFloat64Array","isNonIndex","pow","getOwnNonIndexProperties","compare","min","kNoIterator","kIsArray","kIsSet","kIsMap","innerDeepEqual","val1","val2","memos","buf1","buf2","val1Tag","keys1","keys2","keyCheck","getTime","byteLength","Uint8Array","buffer","byteOffset","areSimilarTypedArrays","areSimilarFloatArrays","_keys","_keys2","size","valueOf","Boolean","BigInt","isEqualBoxedPrimitive","getEnumerables","iterationType","aKeys","bKeys","symbolKeysA","symbolKeysB","_symbolKeysB","position","val2MemoA","val2MemoB","areEq","memo","aValues","Set","add","setMightHaveLoosePrim","bValues","_val","setHasEqualElement","setEquiv","aEntries","_aEntries$i","item1","item2","mapMightHaveLoosePrim","bEntries","_i2","_bEntries$_i","item","mapHasEqualEntry","mapEquiv","keysA","objEquiv","delete","setValues","findLooseMatchingPrimitives","prim","altValue","curB","key1","key2","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","Arr","_byteLength","curByte","revLookup","fromByteArray","uint8","extraBytes","maxChunkLength","len2","encodeChunk","lookup","num","base64","ieee754","customInspectSymbol","Buffer","K_MAX_LENGTH","createBuffer","buf","arg","encodingOrOffset","allocUnsafe","from","encoding","isEncoding","write","fromString","ArrayBuffer","isView","arrayView","isInstance","copy","fromArrayBuffer","fromArrayLike","fromArrayView","SharedArrayBuffer","isBuffer","checked","fromObject","toPrimitive","assertSize","mustMatch","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","bidirectionalIndexOf","dir","arrayIndexOf","indexSize","arrLength","valLength","read","readUInt16BE","foundIndex","hexWrite","remaining","strLen","parsed","utf8Write","blitBuffer","asciiWrite","byteArray","asciiToBytes","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","codePoints","MAX_ARGUMENTS_LENGTH","decodeCodePointsArray","TYPED_ARRAY_SUPPORT","proto","foo","typedArraySupport","poolSize","alloc","fill","allocUnsafeSlow","_isBuffer","swap16","swap32","swap64","toLocaleString","thisStart","thisEnd","thisCopy","targetCopy","isFinite","ret","hexSliceLookupTable","bytes","checkOffset","ext","checkInt","wrtBigUInt64LE","checkIntBI","wrtBigUInt64BE","checkIEEE754","writeFloat","littleEndian","noAssert","writeDouble","newBuf","subarray","readUintLE","readUIntLE","mul","readUintBE","readUIntBE","readUint8","readUInt8","readUint16LE","readUInt16LE","readUint16BE","readUint32LE","readUInt32LE","readUint32BE","readUInt32BE","readBigUInt64LE","defineBigIntMethod","validateNumber","first","boundsError","readBigUInt64BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readBigInt64LE","readBigInt64BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUintLE","writeUIntLE","writeUintBE","writeUIntBE","writeUint8","writeUInt8","writeUint16LE","writeUInt16LE","writeUint16BE","writeUInt16BE","writeUint32LE","writeUInt32LE","writeUint32BE","writeUInt32BE","writeBigUInt64LE","writeBigUInt64BE","writeIntLE","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeBigInt64LE","writeBigInt64BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","errors","E","super","addNumericalSeparator","range","ERR_OUT_OF_RANGE","checkBounds","ERR_BUFFER_OUT_OF_BOUNDS","received","isInteger","abs","INVALID_BASE64_RE","leadSurrogate","base64clean","src","dst","alphabet","table","i16","BufferBigIntNotDefined","GetIntrinsic","callBind","$indexOf","allowMissing","intrinsic","$apply","$call","$reflectApply","$gOPD","$defineProperty","$max","originalFunction","applyBind","times","functions","label","time","duration","format","expression","tuple","global","__self__","F","fetch","DOMException","support","Blob","viewClasses","normalizeName","normalizeValue","iteratorFor","items","Headers","headers","append","header","getOwnPropertyNames","consumed","bodyUsed","reject","fileReaderReady","reader","onload","onerror","readBlobAsArrayBuffer","blob","FileReader","promise","readAsArrayBuffer","bufferClone","view","Body","_initBody","_bodyInit","_bodyText","_bodyBlob","FormData","_bodyFormData","URLSearchParams","DataView","_bodyArrayBuffer","rejected","arrayBuffer","readAsText","chars","readArrayBufferAsText","formData","decode","json","JSON","oldValue","thisArg","values","entries","methods","Request","method","upcased","url","credentials","mode","signal","referrer","form","decodeURIComponent","Response","bodyInit","status","statusText","clone","response","redirectStatuses","redirect","init","request","aborted","xhr","XMLHttpRequest","abortXhr","abort","rawHeaders","getAllResponseHeaders","responseURL","responseText","ontimeout","onabort","open","withCredentials","responseType","setRequestHeader","addEventListener","onreadystatechange","readyState","removeEventListener","send","polyfill","ponyfill","hasSymbols","toStr","origDefineProperty","hasPropertyDescriptors","supportsDescriptors","defineProperties","predicates","firstSource","to","nextSource","keysArray","nextIndex","nextKey","desc","isCallable","receiver","forEachArray","forEachString","forEachObject","that","bound","boundLength","boundArgs","Empty","implementation","$SyntaxError","$Function","$TypeError","getEvalledConstructor","expressionSyntax","throwTypeError","ThrowTypeError","calleeThrows","gOPDthrows","needsEval","TypedArray","INTRINSICS","AggregateError","Atomics","BigInt64Array","BigUint64Array","decodeURI","encodeURI","encodeURIComponent","eval","EvalError","Float32Array","Float64Array","FinalizationRegistry","Int8Array","Int16Array","Int32Array","Uint8ClampedArray","Uint16Array","Uint32Array","URIError","WeakMap","WeakRef","WeakSet","errorProto","doEval","gen","LEGACY_ALIASES","hasOwn","$concat","$spliceApply","$replace","$strSlice","$exec","rePropName","reEscapeChar","getBaseIntrinsic","alias","intrinsicName","number","quote","subString","stringToPath","intrinsicBaseName","intrinsicRealName","skipFurtherCaching","isOwn","part","hasArrayLengthDefineBug","origSymbol","hasSymbolSham","symObj","syms","toStringTag","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","rt","LN2","superCtor","super_","TempCtor","hasToStringTag","$toString","callBound","isStandardArguments","isLegacyArguments","callee","supportsStandardArguments","badArrayLike","isCallableMarker","fnToStr","reflectApply","_","constructorRegex","isES6ClassFn","fnStr","tryFunctionObject","isIE68","isDDA","all","strClass","GeneratorFunction","isFnRegex","generatorFunc","getGeneratorFunc","getPolyfill","shim","availableTypedArrays","gOPD","globalThis","typedArrays","$slice","toStrTags","typedArray","superProto","tag","anyTrue","getter","tryTypedArrays","keysShim","isArgs","isEnumerable","hasDontEnumBug","hasProtoEnumBug","dontEnums","equalsConstructorPrototype","excludedKeys","$applicationCache","$console","$external","$frame","$frameElement","$frames","$innerHeight","$innerWidth","$onmozfullscreenchange","$onmozfullscreenerror","$outerHeight","$outerWidth","$pageXOffset","$pageYOffset","$parent","$scrollLeft","$scrollTop","$scrollX","$scrollY","$self","$webkitIndexedDB","$webkitStorageInfo","$window","hasAutomationEqualityBug","isObject","isFunction","isArguments","isString","theKeys","skipProto","skipConstructor","equalsConstructorPrototypeIfNotBuggy","origKeys","originalKeys","keysWorksWithArguments","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","marker","runClearTimeout","Item","noop","nextTick","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","umask","prop","qs","sep","eq","regexp","maxKeys","kstr","vstr","v","idx","stringifyPrimitive","ks","encode","stringify","queueMicrotask","cb","aliases","acl","as","cal","cert","contact","dc","dct","doap","foaf","geo","gpx","http","httph","icalTZ","ldp","link","meeting","mo","org","owl","pad","patch","prov","qu","trip","rdf","rdfs","rss","sched","schema","sioc","solid","space","stat","tab","tabont","ui","vcard","wf","xsd","cco","skos","bookmark","vann","namedNode","namespaces","expansion","localName","freeGlobal","punycode","maxInt","tMax","skew","damp","regexPunycode","regexNonASCII","regexSeparators","baseMinusTMin","stringFromCharCode","mapDomain","ucs2decode","extra","counter","ucs2encode","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","basic","index","oldi","w","baseMinusT","bias","handledCPCount","basicLength","currentValue","handledCPCountPlusOne","qMinusT","Url","slashes","auth","host","port","hostname","hash","query","pathname","href","protocolPattern","portPattern","simplePathPattern","unwise","autoEscape","nonHostChars","hostEndingChars","hostnamePartPattern","hostnamePartStart","unsafeProtocol","hostlessProtocol","slashedProtocol","querystring","parseQueryString","slashesDenoteHost","queryIndex","splitter","uSplit","rest","simplePath","lowerProto","atSign","hostEnd","hec","parseHost","ipv6Hostname","hostparts","newpart","validParts","notHost","bit","toASCII","h","ae","esc","escape","qm","relative","resolveObject","urlParse","rel","tkeys","tk","tkey","rkeys","rk","rkey","relPath","isSourceAbs","isRelAbs","mustEndAbs","removeAllDots","srcPath","psychotic","isNullOrUndefined","authInHost","isNull","hasTrailingSlash","up","isAbsolute","isArgumentsObject","isGeneratorFunction","whichTypedArray","isTypedArray","BigIntSupported","SymbolSupported","ObjectToString","numberValue","stringValue","booleanValue","bigIntValue","symbolValue","checkBoxedPrimitive","prototypeValueOf","isMapToString","isSetToString","isWeakMapToString","isWeakSetToString","isArrayBufferToString","isArrayBuffer","working","isDataViewToString","isDataView","isUint8Array","isUint8ClampedArray","isUint16Array","isUint32Array","isInt8Array","isInt16Array","isInt32Array","isBigInt64Array","isBigUint64Array","isWeakMap","isWeakSet","SharedArrayBufferCopy","isSharedArrayBufferToString","isSharedArrayBuffer","isAsyncFunction","isMapIterator","isSetIterator","isGeneratorObject","isWebAssemblyCompiledModule","getOwnPropertyDescriptors","descriptors","formatRegExp","objects","deprecate","noDeprecation","throwDeprecation","traceDeprecation","trace","debugs","debugEnvRegex","NODE_DEBUG","debugEnv","opts","seen","stylize","stylizeNoColor","colors","isBoolean","_extend","isUndefined","stylizeWithColor","formatValue","styleType","style","styles","primitive","simple","isNumber","formatPrimitive","visibleKeys","arrayToHash","isError","formatError","braces","toUTCString","formatProperty","formatArray","reduce","prev","reduceToSingleString","ar","debuglog","pid","types","isSymbol","isPrimitive","months","getHours","getMinutes","inherits","origin","kCustomPromisifiedSymbol","callbackifyOnRejected","newReason","promisify","original","promiseResolve","promiseReject","callbackified","maybeCb","rej","foundName","_regeneratorRuntime","__esModule","r","asyncIterator","wrap","Generator","Context","makeInvokeMethod","tryCatch","GeneratorFunctionPrototype","defineIteratorMethods","_invoke","AsyncIterator","invoke","__await","callInvokeWithMethodAndArg","delegate","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","resultName","nextLoc","pushTryEntry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","displayName","mark","awrap","async","reverse","stop","rval","handle","complete","finish","delegateYield","runtime","regeneratorRuntime","accidentalStrictMode","possibleNames","staticProps","toPropertyKey","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","id","loaded","__webpack_modules__","ns","def","current","definition","chunkId","promises","hmd","children","script","needAttach","scripts","getElementsByTagName","getAttribute","charset","nc","setAttribute","onScriptComplete","event","doneFns","parentNode","removeChild","nmd","paths","scriptUrl","importScripts","currentScript","installedChunks","installedChunkData","errorType","realSrc","webpackJsonpCallback","parentChunkLoadingFunction","chunkIds","moreModules","some","chunkLoadingGlobal","BlankNode","getId","formula","bnodeNew","copyTo","NTAnonymousNodePrefix","fragments","nextId","boolean","dateTime","decimal","double","integer","langString","Literal","language","datatype","XSD","fromValue","lang","d2","getUTCFullYear","getUTCMonth","getUTCDate","getUTCSeconds","strValue","MAX_SAFE_INTEGER","fromDate","fromBoolean","fromNumber","Collection","initial","RdflibBlankNode","elements","closed","ea","substitute","collection","asyncGeneratorStep","_next","_throw","_asyncToGenerator","defaultGraphURI","DefaultGraph","isDefaultGraph","defaultGraph","DefaultGraphNode","Statement","graph","terms","Variable","Uri","variable","Feature","CanonicalDataFactory","supports","collections","defaultGraphType","equalsMethod","identity","reversibleId","variableType","blankNode","term","quadToNQ","nq","termToNQ","languageOrDatatype","quad","triple","toNQ","Namespace","nsuri","dataFactory","ln","createXSD","localFactory","createSerializer","store","Serializer","_notQNameChars","prefixes","nsKeys","solidNs","suggestPrefix","namespacesUsed","keywords","prefixchars","incoming","formulas","rdfFactory","fromNT","px","setPrefix","existingNs","prefixs","canUse","pp","validPrefix","slash","sts","subjects","allBnodes","checkMentions","z","ss","roots","xNT","fromStr","rootsHash","statementsToN3","backslashUify","rdfns","kb","termToNT","atomicTermToN3","bnode","Util","defaultNamespace","predMap","spaces","treeToLine","tree","branch","statementListToTree","stats","rootSubjects","results","subjectTree","termToN3","propertyTree","objectTree","lastPred","expr","prefixDirectives","explicitURI","treeToString","level","lastLength","eNotation","stringToN3","symbolToN3","delim","forbidden","forbidden3","forbidden1","lastIndex","canSplit","_notNameChars","localid","namesp","keyords","makeUpPrefix","fetcher","session","appNode","sources","metaSources","metadata","namespaceCounts","liPrefix","XMLtreeToLine","statementListToXMLTree","subjectXMLTree","escapeForXML","relURI","pred","propertyXMLTree","ap","bp","bs","an","bn","qname","collectionXMLTree","attrs","ns2","XMLtreeToString","jsonldObj","ttl2jsonld","serialize","sz","setFlags","newSts","suggestNamespaces","setNamespaces","setBase","executeCallback","statementsToXML","statementsToNTriples","statementsToJsonld","appliedFactoryMethods","nil","arrayToStatements","_listObj","listData","nextNode","ArrayIndexOf","Formula","constraints","initBindings","optional","Graph","_step","_iterator","_createForOfIteratorHelper","_loop","factoryMethod","_this$rdfFactory","_this2","statement","_this3","anyStatementMatching","toJS","justOne","bots","bottom","each","len3","hashString","thisClass","len4","members","ref2","ref3","ref4","ref5","seeds","transitiveClosure","NTtoURI","findMembersNT","findTypesNT","doc","excludePredicateURIs","todo","doneArcs","follow","_features","dt","holds","addAll","uris","provenance","statementsCopy","inverse","sups","agenda","tops","Query","pat","IndexedFormula","vars","indexedFormulaQuery","myQuery","onDone","bindingDebug","bindingsDebug","nbs","unifyContents","nbs2","isVar","complexType","redirections","defaultDocumentURI","unifyTerm","nb","nb2","bindings2","union","OptionalBranchJunction","originalCallback","trunkBindings","branches","MandatoryBranch","checkAllDone","doCallBacks","reportMatch","reportDone","OptionalBranch","junction","prepare","termIndex","ind","nvars","subjectIndex","predicateIndex","objectIndex","whyIndex","easiestQuery","bindingsSoFar","localCallback","pattern_debug","pattern","br","fetchResource","requestedTerm","docuri","nowOrWhenFetched","getState","match2","constraintsSatisfied","nk","newBindings1","nbs1","onward","trunck","sync","owlNamespaceURI","handleFP","subj","o1","equate","handleIFP","handleRDFType","typeCallback","classActions","_Formula","features","propertyActions","HTTPRedirects","rdfArrayRemove","dataCallback","dataCallbacks","initPropertyActions","patchCallback","ds","targetKB","doPatch","onDonePatch","bad","ds2","remove","where","bindingsFound","_existentialVariables","addFn","newPropertyAction","proj","actions","objNode","predicateCallback","predHash","canon","ix","checkStatementList","arrayContains","u1","u2","statList","u1in","u2in","replaceWith","declareExistential","action","toBeFixed","_universalVariables","mentionsURI","removeStatement","removeMetadata","removeMatches","meta","linkNamespaceURI","requests","removeMany","big","small","oldhash","newhash","moveIndex","oldlist","newlist","nowKnownAs","x1","y1","existingPrefix","wild","iBest","best","pBest","possibles","check","cterm","_options","RDF","convertFirstRestNil","preceding","ele","listSoFar","trash","rests","firsts","total","totalTrash","pres","newList","newStatement","_step2","_iterator2","_step3","_iterator3","substituteInDoc","pre","_step4","_iterator4","_step5","_iterator5","sameTerm","substituteNillsInDoc","Logic_NS","pyjslib_Tuple","theList","pyjslib_List","pyjslib_Dict","listOfPairs","pyjslib_len","pyjslib_slice","StopIteration","pyjslib_Iterator","li","string_find","assertFudge","condition","utftext","Utf8","uripath_join","RDF_nil_URI","DAML_sameAs_URI","number_syntax","datetime_syntax","interesting","langcode","openFormula","thisDoc","baseURI","genPrefix","metaURI","SinkParser","_bindings","_flags","_store","setGenPrefix","_thisDoc","statementCount","hasNil","startOfLine","previousLine","_genPrefix","keywordsSet","_anonymousNodes","_variables","_parentVariables","_reason","_reason2","_baseURI","RDFSink_uniqueURI","_formula","_context","_parentContext","stream","loadBuf","startDoc","feed","endDoc","octets","skipSpace","directiveOrStatement","BadSyntax","directive","checkDot","tok","commaSeparatedList","setKeywords","__x","newUniversal","uri_ref2","hexify","qn","setPrefixForURI","property_list","nodeOrLiteral","ahead","here","makeStatement","subjectAlready","bnodeID","objs","objectList","__obj","mylist","first_run","newSet","oldParentContext","parentAnonymousNodes","grandParentVariables","reason2","close","thing_type","verb","pairFudge","ofUris","bareWord","pfx","anonymousNode","symb","uref","strconst","startline","res2","ustr","uEscape","UEscape","uch","uesc","lineNo","characterInFile","syntaxProblem","ExtendedTermFactory","jsonldObjectToTerm","listToCollection","listId","listItem","listToStatements","jsonldParser","baseString","flatten","flattened","flatResource","processResource","startsWith","_Object$keys","graphId","nestedFlatResources","addStatement","createStatement","SWAP","sameAs","forSome","forAll","implies","escapeSequence","escapeReplacements","illegalIriChars","lineModeRegExps","_iri","_unescapedIri","_simpleQuotedString","_langcode","_blank","_newline","_comment","_whitespace","_endOfFile","invalidRegExp","N3Lexer","_simpleApostropheString","_prefix","_prefixed","_variable","_number","_boolean","_keyword","_sparqlKeyword","_shortPredicates","_lineMode","lineMode","_n3Mode","n3","_comments","comments","_literalClosingPos","_tokenizeToEnd","inputFinished","_input","currentLineLength","whiteSpaceMatch","comment","emitToken","_line","firstChar","matchLength","inconclusive","_previousMarker","_unescape","reportSyntaxError","_parseLiteral","token","previousToken","_syntaxError","invalid","replaced","sequence","unicode4","unicode8","escapedChar","charCode","opening","openingLength","closingPos","backslashCount","raw","issue","_readStartingBom","tokenize","tokens","_pendingBuffer","setEncoding","DEFAULTGRAPH","_blankNodeCounter","languageOrDataType","Term","hashCode","atPos","datatypeString","dtPos","char","Quad","_subject","_predicate","_object","_graph","blankNodePrefix","N3Parser","_contextStack","_setBase","initDataFactory","isTurtle","isTriG","isNTriples","isNQuads","isN3","isLineMode","_supportsNamedGraphs","_readPredicateOrNamedGraph","_readPredicate","_supportsQuads","_supportsRDFStar","_resolveRelativeIRI","_blankNodePrefix","_lexer","lexer","_explicitQuantifiers","explicitQuantifiers","_resetBlankNodePrefix","fragmentPos","_base","_basePath","_baseRoot","_baseScheme","_saveContext","n3Mode","_inversePredicate","blankPrefix","_prefixes","quantified","_quantified","_restoreContext","_error","_readInTopContext","_callback","_sparqlStyle","_readPrefix","_readBaseIRI","_readSubject","_readNamedGraphLabel","_readEntity","quantifier","_resolveIRI","_namedNode","_blankNode","_readBlankNodeHead","RDF_NIL","_readListItem","_readPunctuation","N3_FORSOME","_quantifier","_readQuantifierList","N3_FORALL","_literalValue","_completeSubjectLiteral","_literal","_getPathReader","ABBREVIATIONS","_readBlankNodeTail","_readObject","_readDataTypeOrLang","_getContextEndReader","_readGraph","_readBlankNodePunctuation","_emit","empty","_readPredicateAfterBlank","previousList","RDF_FIRST","_readListItemDataTypeOrLang","RDF_REST","_completeObjectLiteral","_completeLiteral","completed","_readCallback","_readFormulaTail","inversePredicate","_quad","_readQuadPunctuation","_readPrefixIRI","prefixNode","_prefixCallback","_readDeclarationPunctuation","_readNamedGraphBlankLabel","entity","QUANTIFIERS_GRAPH","_readQuantifierPunctuation","afterPath","_afterPath","_readPath","_readForwardPath","_readBackwardPath","_readRDFStarTailOrGraph","_readRDFStarTail","contextStack","_removeDotSegments","pathStart","segmentStart","quadCallback","prefixCallback","quads","every","parser","N3DataFactory","ELEMENT_NODE","ATTRIBUTE_NODE","TEXT_NODE","CDATA_SECTION_NODE","ENTITY_REFERENCE_NODE","ENTITY_NODE","PROCESSING_INSTRUCTION_NODE","COMMENT_NODE","DOCUMENT_NODE","DOCUMENT_TYPE_NODE","DOCUMENT_FRAGMENT_NODE","NOTATION_NODE","RDFaProcessor","blankNodes","htmlOptions","theOne","vocabulary","blankCounter","langAttributes","namespaceURI","inXHTMLMode","absURIRE","finishedHandlers","su","ob","pr","or","toRDFNodeObject","mappings","newMappings","dateTimeTypes","matched","colon","NCNAME","parseCURIE","resolveAndNormalize","defaultVocabulary","ignoreTerms","parseTermOrCURIEOrAbsURI","parseCURIEOrURI","curie","documentElement","setContext","removeHash","baseURIMap","listMapping","bnodes","newBlankNode","addTriple","objectURI","skip","newSubject","currentObjectResource","typedResource","prefixesCopied","incomplete","listMappingDifferent","parseURI","vocabAtt","getAttributeNode","baseSubject","spec","att","copyMappings","prefixAtt","parsePrefixMappings","xmlLangAtt","getAttributeNodeNS","relAtt","revAtt","typeofAtt","propertyAtt","datatypeAtt","datetimeAtt","inHTMLMode","contentAtt","aboutAtt","srcAtt","resourceAtt","hrefAtt","inlistAtt","relAttPredicates","parsePredicate","revAttPredicates","parseSafeCURIEOrCURIEOrURI","parentObject","newSubjectOrigin","typeURI","forward","content","PlainLiteralURI","XMLLiteralURI","HTMLLiteralURI","deriveDateTimeType","childContext","listSubject","lastChild","previousSibling","copyProperties","setXHTMLContext","doctype","publicId","systemId","setHTMLContext","setXMLContext","setInitialContext","dom","nameChar","nameStartChar","parseRDFaDOM","RDFParser","reify","uriUtil","rdfid","NODE","ARC","addSymbol","isTripleToLoad","loadTriple","listIndex","attributeNode","potentialNode","cleanParser","DOCUMENT","ELEMENT","frameFactory","parseDOM","buildFrame","frame","elementURI","el","dig","TEXT","CDATA_SECTION","addArc","addLiteral","addCollectionArc","removeAttributeNode","parsetype","nv","innerHTML","addBNode","addCollection","resource","bnid2","addNode","about","bnid","rdftype","pframe","candidate","terminateFrame","removeAttribute","sparqlUpdateParser","SQNS","clauses","badSyntax","n3Parser","N3jsParser","DataFactory","nquads","tripleCallback","nquadCallback","e2","cause","executeErrorCallback","handled","Parsable","CONTENT_TYPE_BY_EXT","getNS","Handler","RDFXMLHandler","_Handler2","failFetch","noMeta","doneFetch","mediatypes","XHTMLHandler","_Handler3","links","linkData","rdfParse","noRDFa","XMLHandler","_Handler4","isElement","addStatus","req","html","xmlns","HTMLHandler","_Handler5","isXML","docTypeStart","docTypeEnd","isXHTML","isXMLNS","titleMatch","JsonLdHandler","_Handler6","TextHandler","_Handler7","N3Handler","_Handler8","defaultHandlers","Fetcher","_fetch","solidFetcher","solidFetch","crossFetch","requested","timeouts","redirectedTo","fetchQueue","fetchCallbacks","nonexistent","lookedUp","handlers","addHandler","load","uriIn","initFetchOptions","clearPreviousData","initialisedOptions","pendingFetchPromise","_pendingFetchPromise","_callee","originalUri","pendingPromise","t0","race","setRequestTimeout","fetchUri","cleanupFetchRequest","_x","_x2","_x3","_this4","isPending","cache","acceptString","requestedURI","offlineOverride","setCredentials","actualProxyURI","proxyIfNecessary","proxyUsed","_this5","unsupportedProtocol","state","dummyResponse","saveRequestMetadata","handleResponse","errno","handleError","p2","userCallback","referringTerm","fetchResponse","oops","statusMessage","getMilliseconds","statusNode","the","errorMessage","statusCode","meth","linkHeader","reqNode","paramexp","was","lookUpThing","_this6","uriSting","jsonString","webOperation","there","_this7","_this8","unload","_createIfNotExists","_callee2","_args2","_context2","t1","_x4","parentURI","folderName","invalidateCache","rterm","_this9","anyValue","timeNow","_this10","responseNode","refresh","exp","getHeader","removeDocument","handler","register","retriedWithNoCredentials","newOptions","isCrossSite","retryNoCredentials","proxyUri","crossSiteProxy","redirectToProxy","rdfType","locURI","reqURI","redirection","_this11","saveResponseMetadata","normalizedContentType","contentLocation","saveErrorResponse","diffLocation","absContentLocation","addType","isImage","parseLinkHeader","handlerForContentType","_this12","forceContentType","guess","guessContentType","newURI","_this13","oldReq","_this14","acceptstring","crossSiteProxyTemplate","UI","panes","preferences","isExtension","$SolidTestEnvironment","localSiteMap","pcol","HANDLERS","parseJSON","preds","queryToSPARQL","indent","getPattern","addIndent","getConstraints","describe","getOptionals","getWhere","getSelect","getSPARQL","SPARQLToQuery","SPARQL","testMode","variableHash","makeVar","newVar","isRealText","fixSymbolBrackets","isBnode","isPrefix","isPrefixedSymbol","getPrefix","getSuffix","removeBrackets","parseLiterals","sin","doub","end2","spaceDelimit","arrayIndicesOf","getMatchingBracket","ConstraintEqualTo","varstr","ConstraintRegexp","rg","setConstraint","setOptional","opt","setWhere","toTerms","filt","arrayZero","per","sem","stat2","com","stat3","extractStatements","sp","token1","token2","strarr","replaceKeywords","prefInd","symbol","getPrefixDeclarations","selectLoc","whereLoc","setVars","UpdateManager","updater","ifps","fps","patchControl","_kb$fetcher","_checkEditable","_kb$fetcher2","final","editable","_kb$fetcher3","isHttpUri","definitive","anyJS","wacAllow","lr","acceptPatch","authorVia","mentioned","stmt","anonymize","statementBnodes","bnodes2","isBlank","bnodeContext2","con","connectedStatements","cacheIfps","bnodeContext1","bnodeContext","anonymizeNT","callbackFunction","statementContext","statementNT","contextWhere","set_object","fire","st0","stText","control","patchControlFor","pendingUpstream","downstreamAction","upstreamCount","linkHeaders","listener","downstreamChangeListeners","setRefreshHandler","reloadAndSync","reloading","outOfDate","retryTimeout","tryReload","reload","wssURI","getUpdatesVia","theHandler","retries","validWssURI","uriJoin","openWebsocket","socket","WebSocket","onopen","requestDownstreamAction","onclose","onmessage","deletions","insertions","docs","thisUpdater","uniqueDocs","uniqueDoc","updates","update","bnodes_context","whereClause","nTriples","secondTry","errorBody","startTime","isSparql","statementArrayBnodes","constructSparqlUpdateQuery","constructN3PatchQuery","elapsedTimeMs","updateDav","updateLocalFile","targetURI","documentString","candidateTarget","dot","onErrorWasCalled","reloadTimeTotal","reloadTimeCount","RDFlibDataFactory","lit","UpdatesSocket","via","connected","pending","subscribed","onOpen","onClose","onMessage","onError","elt","_send","onUpdate","_decode","_subscribe","UpdatesVia","onHeaders","etag","subscribe","boundDataFactory","NextId","ConnectedStore","_Store","Store","LiveStore","_ConnectedStore2"],"sourceRoot":""}