@openhps/rdf 0.1.11 → 0.1.14

package/dist/web/openhps-rdf.serialization.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"web/openhps-rdf.serialization.min.js","mappings":"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","sources":["webpack://OpenHPS.rdf/webpack/universalModuleDefinition","webpack://OpenHPS.rdf/./node_modules/base64-js/index.js","webpack://OpenHPS.rdf/./node_modules/buffer/index.js","webpack://OpenHPS.rdf/./node_modules/events/events.js","webpack://OpenHPS.rdf/./node_modules/ieee754/index.js","webpack://OpenHPS.rdf/./node_modules/inherits/inherits_browser.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/errors-browser.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/_stream_duplex.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/_stream_passthrough.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/_stream_readable.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/_stream_transform.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/_stream_writable.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/async_iterator.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/buffer_list.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/destroy.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/end-of-stream.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/from-browser.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/pipeline.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/state.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/readable-browser.js","webpack://OpenHPS.rdf/./node_modules/safe-buffer/index.js","webpack://OpenHPS.rdf/./node_modules/string_decoder/lib/string_decoder.js","webpack://OpenHPS.rdf/./node_modules/util-deprecate/browser.js","webpack://OpenHPS.rdf/external umd {\"commonjs\":\"@openhps/core\",\"commonjs2\":\"@openhps/core\",\"amd\":\"core\",\"root\":[\"OpenHPS\",\"core\"]}","webpack://OpenHPS.rdf/webpack/bootstrap","webpack://OpenHPS.rdf/webpack/runtime/define property getters","webpack://OpenHPS.rdf/webpack/runtime/global","webpack://OpenHPS.rdf/webpack/runtime/hasOwnProperty shorthand","webpack://OpenHPS.rdf/webpack/runtime/make namespace object","webpack://OpenHPS.rdf/./node_modules/n3/src/IRIs.js","webpack://OpenHPS.rdf/./node_modules/n3/src/N3Util.js","webpack://OpenHPS.rdf/./node_modules/n3/src/N3DataFactory.js","webpack://OpenHPS.rdf/./dist/esm/decorators/index.js","webpack://OpenHPS.rdf/./dist/esm/rdf/utils.js","webpack://OpenHPS.rdf/./dist/esm/rdf/InternalRDFSerializer.js","webpack://OpenHPS.rdf/./dist/esm/vocab/rdf.js","webpack://OpenHPS.rdf/./dist/esm/vocab/index.js","webpack://OpenHPS.rdf/./dist/esm/rdf/InternalRDFDeserializer.js","webpack://OpenHPS.rdf/./node_modules/n3/src/N3Store.js","webpack://OpenHPS.rdf/./node_modules/n3/src/N3Writer.js","webpack://OpenHPS.rdf/./dist/esm/namespaces.js","webpack://OpenHPS.rdf/./dist/esm/rdf/RDFSerializer.js","webpack://OpenHPS.rdf/./dist/esm/rdf/SerializableNamedNode.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"@openhps/core\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"OpenHPS\", [\"core\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"OpenHPS\"] = factory(require(\"@openhps/core\"));\n\telse\n\t\troot[\"OpenHPS\"] = root[\"OpenHPS\"] || {}, root[\"OpenHPS\"][\"rdf\"] = factory(root[\"OpenHPS\"][\"core\"]);\n})((typeof self !== 'undefined' ? self : this), function(__WEBPACK_EXTERNAL_MODULE__0__) {\nreturn ","'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","// 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 R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\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\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nvar codes = {};\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    _inheritsLoose(NodeError, _Base);\n\n    function NodeError(arg1, arg2, arg3) {\n      return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;\n    }\n\n    return NodeError;\n  }(Base);\n\n  NodeError.prototype.name = Base.name;\n  NodeError.prototype.code = code;\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_INVALID_OPT_VALUE', function (name, value) {\n  return 'The value \"' + value + '\" is invalid for option \"' + name + '\"';\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n  // determiner: 'must be' or 'must not be'\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  }\n\n  msg += \". Received type \".concat(typeof actual);\n  return msg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');\ncreateErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {\n  return 'The ' + name + ' method is not implemented';\n});\ncreateErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');\ncreateErrorType('ERR_STREAM_DESTROYED', function (name) {\n  return 'Cannot call ' + name + ' after a stream was destroyed';\n});\ncreateErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');\ncreateErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');\ncreateErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');\ncreateErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);\ncreateErrorType('ERR_UNKNOWN_ENCODING', function (arg) {\n  return 'Unknown encoding: ' + arg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');\nmodule.exports.codes = codes;\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// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n'use strict';\n/*<replacement>*/\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n\n  for (var key in obj) {\n    keys.push(key);\n  }\n\n  return keys;\n};\n/*</replacement>*/\n\n\nmodule.exports = Duplex;\n\nvar Readable = require('./_stream_readable');\n\nvar Writable = require('./_stream_writable');\n\nrequire('inherits')(Duplex, Readable);\n\n{\n  // Allow the keys array to be GC'ed.\n  var keys = objectKeys(Writable.prototype);\n\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n  Readable.call(this, options);\n  Writable.call(this, options);\n  this.allowHalfOpen = true;\n\n  if (options) {\n    if (options.readable === false) this.readable = false;\n    if (options.writable === false) this.writable = false;\n\n    if (options.allowHalfOpen === false) {\n      this.allowHalfOpen = false;\n      this.once('end', onend);\n    }\n  }\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.highWaterMark;\n  }\n});\nObject.defineProperty(Duplex.prototype, 'writableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\nObject.defineProperty(Duplex.prototype, 'writableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.length;\n  }\n}); // the no-half-open enforcer\n\nfunction onend() {\n  // If the writable side ended, then we're ok.\n  if (this._writableState.ended) return; // no more data can be written.\n  // But allow more writes to happen in this tick.\n\n  process.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\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// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\nrequire('inherits')(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\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'use strict';\n\nmodule.exports = Readable;\n/*<replacement>*/\n\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n/*<replacement>*/\n\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*<replacement>*/\n\n\nvar debugUtil = require('util');\n\nvar debug;\n\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function debug() {};\n}\n/*</replacement>*/\n\n\nvar BufferList = require('./internal/streams/buffer_list');\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n    getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n    ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; // Lazy loaded to improve the startup performance.\n\n\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\nvar from;\n\nrequire('inherits')(Readable, Stream);\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n\n  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\n\nfunction ReadableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {}; // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n\n  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n\n  this.sync = true; // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n  this.paused = true; // Should close be emitted on destroy. Defaults to true.\n\n  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish')\n\n  this.autoDestroy = !!options.autoDestroy; // has it been destroyed\n\n  this.destroyed = false; // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n\n  this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s\n\n  this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled\n\n  this.readingMore = false;\n  this.decoder = null;\n  this.encoding = null;\n\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n  if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the ReadableState constructor, at least with V8 6.5\n\n  var isDuplex = this instanceof Duplex;\n  this._readableState = new ReadableState(options, this, isDuplex); // legacy\n\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._readableState === undefined) {\n      return false;\n    }\n\n    return this._readableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._readableState.destroyed = value;\n  }\n});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\n\nReadable.prototype._destroy = function (err, cb) {\n  cb(err);\n}; // Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\n\n\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n}; // Unshift should *always* be something directly out of read()\n\n\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  debug('readableAddChunk', chunk);\n  var state = stream._readableState;\n\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n\n    if (er) {\n      errorOrDestroy(stream, er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());\n      } else if (state.destroyed) {\n        return false;\n      } else {\n        state.reading = false;\n\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n      maybeReadMore(stream, state);\n    }\n  } // We can push more data if we are below the highWaterMark.\n  // Also, if we have no data yet, we can stand some more bytes.\n  // This is to work around cases where hwm=0, such as the repl.\n\n\n  return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    state.awaitDrain = 0;\n    stream.emit('data', chunk);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n    if (state.needReadable) emitReadable(stream);\n  }\n\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);\n  }\n\n  return er;\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n}; // backwards compatibility.\n\n\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  var decoder = new StringDecoder(enc);\n  this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8\n\n  this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers:\n\n  var p = this._readableState.buffer.head;\n  var content = '';\n\n  while (p !== null) {\n    content += decoder.write(p.data);\n    p = p.next;\n  }\n\n  this._readableState.buffer.clear();\n\n  if (content !== '') this._readableState.buffer.push(content);\n  this._readableState.length = content.length;\n  return this;\n}; // Don't raise the hwm > 1GB\n\n\nvar MAX_HWM = 0x40000000;\n\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n\n  return n;\n} // This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\n\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  } // If we're asking for more than the current hwm, then raise the hwm.\n\n\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n; // Don't have enough\n\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n\n  return state.length;\n} // you can override either this method, or the async _read(n) below.\n\n\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n  if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n\n  if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.\n\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  } // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n  // if we need a readable event, then we need to do some reading.\n\n\n  var doRead = state.needReadable;\n  debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some\n\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  } // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n\n\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true; // if the length is currently zero, then we *need* a readable event.\n\n    if (state.length === 0) state.needReadable = true; // call internal read method\n\n    this._read(state.highWaterMark);\n\n    state.sync = false; // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = state.length <= state.highWaterMark;\n    n = 0;\n  } else {\n    state.length -= n;\n    state.awaitDrain = 0;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick.\n\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  debug('onEofChunk');\n  if (state.ended) return;\n\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n\n  state.ended = true;\n\n  if (state.sync) {\n    // if we are sync, wait until next tick to emit the data.\n    // Otherwise we risk emitting data in the flow()\n    // the readable code triggers during a read() call\n    emitReadable(stream);\n  } else {\n    // emit 'readable' now to make sure it gets picked up.\n    state.needReadable = false;\n\n    if (!state.emittedReadable) {\n      state.emittedReadable = true;\n      emitReadable_(stream);\n    }\n  }\n} // Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\n\n\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  debug('emitReadable', state.needReadable, state.emittedReadable);\n  state.needReadable = false;\n\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    process.nextTick(emitReadable_, stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  var state = stream._readableState;\n  debug('emitReadable_', state.destroyed, state.length, state.ended);\n\n  if (!state.destroyed && (state.length || state.ended)) {\n    stream.emit('readable');\n    state.emittedReadable = false;\n  } // The stream needs another readable event if\n  // 1. It is not flowing, as the flow mechanism will take\n  //    care of it.\n  // 2. It is not ended.\n  // 3. It is below the highWaterMark, so we can schedule\n  //    another readable later.\n\n\n  state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n  flow(stream);\n} // at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\n\n\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    process.nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  // Attempt to read more data if we should.\n  //\n  // The conditions for reading more data are (one of):\n  // - Not enough data buffered (state.length < state.highWaterMark). The loop\n  //   is responsible for filling the buffer with enough data if such data\n  //   is available. If highWaterMark is 0 and we are not in the flowing mode\n  //   we should _not_ attempt to buffer any extra data. We'll get more data\n  //   when the stream consumer calls read() instead.\n  // - No data in the buffer, and the stream is in flowing mode. In this mode\n  //   the loop below is responsible for ensuring read() is called. Failing to\n  //   call read here would abort the flow and there's no other mechanism for\n  //   continuing the flow if the stream consumer has just subscribed to the\n  //   'data' event.\n  //\n  // In addition to the above conditions to keep reading data, the following\n  // conditions prevent the data from being read:\n  // - The stream has ended (state.ended).\n  // - There is already a pending 'read' operation (state.reading). This is a\n  //   case where the the stream has called the implementation defined _read()\n  //   method, but they are processing the call asynchronously and have _not_\n  //   called push() with new data. In this case we skip performing more\n  //   read()s. The execution ends in this method again after the _read() ends\n  //   up calling push() with more data.\n  while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {\n    var len = state.length;\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length) // didn't get any data, stop spinning.\n      break;\n  }\n\n  state.readingMore = false;\n} // abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\n\n\nReadable.prototype._read = function (n) {\n  errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);\n  dest.on('unpipe', onunpipe);\n\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  } // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n\n\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n  var cleanedUp = false;\n\n  function cleanup() {\n    debug('cleanup'); // cleanup event handlers once the pipe is broken\n\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n    cleanedUp = true; // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  src.on('data', ondata);\n\n  function ondata(chunk) {\n    debug('ondata');\n    var ret = dest.write(chunk);\n    debug('dest.write', ret);\n\n    if (ret === false) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', state.awaitDrain);\n        state.awaitDrain++;\n      }\n\n      src.pause();\n    }\n  } // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n\n\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);\n  } // Make sure our error handler is attached before userland ones.\n\n\n  prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.\n\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n\n  dest.once('close', onclose);\n\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  } // tell the dest that it's being piped to\n\n\n  dest.emit('pipe', src); // start the flow if it hasn't been started already.\n\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function pipeOnDrainFunctionResult() {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = {\n    hasUnpiped: false\n  }; // if we're not piping anywhere, then do nothing.\n\n  if (state.pipesCount === 0) return this; // just one destination.  most common case.\n\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n    if (!dest) dest = state.pipes; // got a match.\n\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  } // slow case. multiple pipe destinations.\n\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, {\n        hasUnpiped: false\n      });\n    }\n\n    return this;\n  } // try to find the right one.\n\n\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n  dest.emit('unpipe', this, unpipeInfo);\n  return this;\n}; // set up data events if they are asked for\n// Ensure readable listeners eventually get something\n\n\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n  var state = this._readableState;\n\n  if (ev === 'data') {\n    // update readableListening so that resume() may be a no-op\n    // a few lines down. This is needed to support once('readable').\n    state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused\n\n    if (state.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.flowing = false;\n      state.emittedReadable = false;\n      debug('on readable', state.length, state.reading);\n\n      if (state.length) {\n        emitReadable(this);\n      } else if (!state.reading) {\n        process.nextTick(nReadingNextTick, this);\n      }\n    }\n  }\n\n  return res;\n};\n\nReadable.prototype.addListener = Readable.prototype.on;\n\nReadable.prototype.removeListener = function (ev, fn) {\n  var res = Stream.prototype.removeListener.call(this, ev, fn);\n\n  if (ev === 'readable') {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this);\n  }\n\n  return res;\n};\n\nReadable.prototype.removeAllListeners = function (ev) {\n  var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n\n  if (ev === 'readable' || ev === undefined) {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this);\n  }\n\n  return res;\n};\n\nfunction updateReadableListening(self) {\n  var state = self._readableState;\n  state.readableListening = self.listenerCount('readable') > 0;\n\n  if (state.resumeScheduled && !state.paused) {\n    // flowing needs to be set to true now, otherwise\n    // the upcoming resume will not flow.\n    state.flowing = true; // crude way to check if we should resume\n  } else if (self.listenerCount('data') > 0) {\n    self.resume();\n  }\n}\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n} // pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\n\n\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n\n  if (!state.flowing) {\n    debug('resume'); // we flow only if there is no one listening\n    // for readable, but we still have to call\n    // resume()\n\n    state.flowing = !state.readableListening;\n    resume(this, state);\n  }\n\n  state.paused = false;\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    process.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  debug('resume', state.reading);\n\n  if (!state.reading) {\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n\n  if (this._readableState.flowing !== false) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n\n  this._readableState.paused = true;\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n\n  while (state.flowing && stream.read() !== null) {\n    ;\n  }\n} // wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\n\n\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n  stream.on('end', function () {\n    debug('wrapped end');\n\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n\n    _this.push(null);\n  });\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode\n\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  }); // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function methodWrap(method) {\n        return function methodWrapReturnFunction() {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  } // proxy certain important events.\n\n\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  } // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n\n\n  this._read = function (n) {\n    debug('wrapped _read', n);\n\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nif (typeof Symbol === 'function') {\n  Readable.prototype[Symbol.asyncIterator] = function () {\n    if (createReadableStreamAsyncIterator === undefined) {\n      createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n    }\n\n    return createReadableStreamAsyncIterator(this);\n  };\n}\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.highWaterMark;\n  }\n});\nObject.defineProperty(Readable.prototype, 'readableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState && this._readableState.buffer;\n  }\n});\nObject.defineProperty(Readable.prototype, 'readableFlowing', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.flowing;\n  },\n  set: function set(state) {\n    if (this._readableState) {\n      this._readableState.flowing = state;\n    }\n  }\n}); // exposed for testing purposes only.\n\nReadable._fromList = fromList;\nObject.defineProperty(Readable.prototype, 'readableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.length;\n  }\n}); // Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = state.buffer.consume(n, state.decoder);\n  }\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n  debug('endReadable', state.endEmitted);\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    process.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.\n\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n\n    if (state.autoDestroy) {\n      // In case of duplex streams we need a way to detect\n      // if the writable side is ready for autoDestroy as well\n      var wState = stream._writableState;\n\n      if (!wState || wState.autoDestroy && wState.finished) {\n        stream.destroy();\n      }\n    }\n  }\n}\n\nif (typeof Symbol === 'function') {\n  Readable.from = function (iterable, opts) {\n    if (from === undefined) {\n      from = require('./internal/streams/from');\n    }\n\n    return from(Readable, iterable, opts);\n  };\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n\n  return -1;\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// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n'use strict';\n\nmodule.exports = Transform;\n\nvar _require$codes = require('../errors').codes,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n    ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,\n    ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;\n\nvar Duplex = require('./_stream_duplex');\n\nrequire('inherits')(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n  var cb = ts.writecb;\n\n  if (cb === null) {\n    return this.emit('error', new ERR_MULTIPLE_CALLBACK());\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n  cb(er);\n  var rs = this._readableState;\n  rs.reading = false;\n\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n  Duplex.call(this, options);\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  }; // start out asking for a readable event once data is transformed.\n\n  this._readableState.needReadable = true; // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  } // When the writable side finishes, then flush out anything remaining.\n\n\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function' && !this._readableState.destroyed) {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n}; // This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\n\n\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n}; // Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\n\n\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && !ts.transforming) {\n    ts.transforming = true;\n\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data); // TODO(BridgeAR): Write a test for these two error cases\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n\n  if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();\n  if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();\n  return stream.push(null);\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// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n'use strict';\n\nmodule.exports = Writable;\n/* <replacement> */\n\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n} // It seems a linked list but it is not\n// there will be only 2 of these for each stream\n\n\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\n\n\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n/*<replacement>*/\n\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n    getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n    ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n    ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n    ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n    ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\n\nrequire('inherits')(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {}; // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream,\n  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n\n  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called\n\n  this.finalCalled = false; // drain event flag.\n\n  this.needDrain = false; // at the start of calling end()\n\n  this.ending = false; // when end() has been called, and returned\n\n  this.ended = false; // when 'finish' is emitted\n\n  this.finished = false; // has it been destroyed\n\n  this.destroyed = false; // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode; // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n\n  this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n\n  this.length = 0; // a flag to see when we're in the middle of a write.\n\n  this.writing = false; // when true all writes will be buffered until .uncork() call\n\n  this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n\n  this.sync = true; // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n\n  this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)\n\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  }; // the callback that the user supplies to write(chunk,encoding,cb)\n\n\n  this.writecb = null; // the amount that is being written when _write is called.\n\n  this.writelen = 0;\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null; // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n\n  this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n\n  this.prefinished = false; // True if the error was already emitted and should not be thrown again\n\n  this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.\n\n  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')\n\n  this.autoDestroy = !!options.autoDestroy; // count buffered requests\n\n  this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function writableStateBufferGetter() {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})(); // Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\n\n\nvar realHasInstance;\n\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function value(object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function realHasInstance(object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the WritableState constructor, at least with V8 6.5\n\n  var isDuplex = this instanceof Duplex;\n  if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n  this._writableState = new WritableState(options, this, isDuplex); // legacy.\n\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n    if (typeof options.writev === 'function') this._writev = options.writev;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n} // Otherwise people can pipe Writable streams, which is just wrong.\n\n\nWritable.prototype.pipe = function () {\n  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb\n\n  errorOrDestroy(stream, er);\n  process.nextTick(cb, er);\n} // Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\n\n\nfunction validChunk(stream, state, chunk, cb) {\n  var er;\n\n  if (chunk === null) {\n    er = new ERR_STREAM_NULL_VALUES();\n  } else if (typeof chunk !== 'string' && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n  }\n\n  if (er) {\n    errorOrDestroy(stream, er);\n    process.nextTick(cb, er);\n    return false;\n  }\n\n  return true;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n  if (typeof cb !== 'function') cb = nop;\n  if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  this._writableState.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n    if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.highWaterMark;\n  }\n}); // if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\n\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n\n  var len = state.objectMode ? 1 : chunk.length;\n  state.length += len;\n  var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.\n\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    process.nextTick(cb, er); // this can emit finish, and it will always happen\n    // after error\n\n    process.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er); // this can emit finish, but finish must\n    // always follow error\n\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n  if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n  onwriteStateUpdate(state);\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state) || stream.destroyed;\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      process.nextTick(afterWrite, stream, state, finished, cb);\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n} // Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\n\n\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n} // if there's something in the buffer waiting, then process it\n\n\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n    var count = 0;\n    var allBuffers = true;\n\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n\n    buffer.allBuffers = allBuffers;\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks\n\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  } // ignore unnecessary end() calls.\n\n\n  if (!state.ending) endWritable(this, state, cb);\n  return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.length;\n  }\n});\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\n\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n\n    if (err) {\n      errorOrDestroy(stream, err);\n    }\n\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\n\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function' && !state.destroyed) {\n      state.pendingcb++;\n      state.finalCalled = true;\n      process.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n\n  if (need) {\n    prefinish(stream, state);\n\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n\n      if (state.autoDestroy) {\n        // In case of duplex streams we need a way to detect\n        // if the readable side is ready for autoDestroy as well\n        var rState = stream._readableState;\n\n        if (!rState || rState.autoDestroy && rState.endEmitted) {\n          stream.destroy();\n        }\n      }\n    }\n  }\n\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n\n  if (cb) {\n    if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n  }\n\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  } // reuse the free corkReq.\n\n\n  state.corkedRequestsFree.next = corkReq;\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._writableState === undefined) {\n      return false;\n    }\n\n    return this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._writableState.destroyed = value;\n  }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\n\nWritable.prototype._destroy = function (err, cb) {\n  cb(err);\n};","'use strict';\n\nvar _Object$setPrototypeO;\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\nvar finished = require('./end-of-stream');\n\nvar kLastResolve = Symbol('lastResolve');\nvar kLastReject = Symbol('lastReject');\nvar kError = Symbol('error');\nvar kEnded = Symbol('ended');\nvar kLastPromise = Symbol('lastPromise');\nvar kHandlePromise = Symbol('handlePromise');\nvar kStream = Symbol('stream');\n\nfunction createIterResult(value, done) {\n  return {\n    value: value,\n    done: done\n  };\n}\n\nfunction readAndResolve(iter) {\n  var resolve = iter[kLastResolve];\n\n  if (resolve !== null) {\n    var data = iter[kStream].read(); // we defer if data is null\n    // we can be expecting either 'end' or\n    // 'error'\n\n    if (data !== null) {\n      iter[kLastPromise] = null;\n      iter[kLastResolve] = null;\n      iter[kLastReject] = null;\n      resolve(createIterResult(data, false));\n    }\n  }\n}\n\nfunction onReadable(iter) {\n  // we wait for the next tick, because it might\n  // emit an error with process.nextTick\n  process.nextTick(readAndResolve, iter);\n}\n\nfunction wrapForNext(lastPromise, iter) {\n  return function (resolve, reject) {\n    lastPromise.then(function () {\n      if (iter[kEnded]) {\n        resolve(createIterResult(undefined, true));\n        return;\n      }\n\n      iter[kHandlePromise](resolve, reject);\n    }, reject);\n  };\n}\n\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n  get stream() {\n    return this[kStream];\n  },\n\n  next: function next() {\n    var _this = this;\n\n    // if we have detected an error in the meanwhile\n    // reject straight away\n    var error = this[kError];\n\n    if (error !== null) {\n      return Promise.reject(error);\n    }\n\n    if (this[kEnded]) {\n      return Promise.resolve(createIterResult(undefined, true));\n    }\n\n    if (this[kStream].destroyed) {\n      // We need to defer via nextTick because if .destroy(err) is\n      // called, the error will be emitted via nextTick, and\n      // we cannot guarantee that there is no error lingering around\n      // waiting to be emitted.\n      return new Promise(function (resolve, reject) {\n        process.nextTick(function () {\n          if (_this[kError]) {\n            reject(_this[kError]);\n          } else {\n            resolve(createIterResult(undefined, true));\n          }\n        });\n      });\n    } // if we have multiple next() calls\n    // we will wait for the previous Promise to finish\n    // this logic is optimized to support for await loops,\n    // where next() is only called once at a time\n\n\n    var lastPromise = this[kLastPromise];\n    var promise;\n\n    if (lastPromise) {\n      promise = new Promise(wrapForNext(lastPromise, this));\n    } else {\n      // fast path needed to support multiple this.push()\n      // without triggering the next() queue\n      var data = this[kStream].read();\n\n      if (data !== null) {\n        return Promise.resolve(createIterResult(data, false));\n      }\n\n      promise = new Promise(this[kHandlePromise]);\n    }\n\n    this[kLastPromise] = promise;\n    return promise;\n  }\n}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {\n  return this;\n}), _defineProperty(_Object$setPrototypeO, \"return\", function _return() {\n  var _this2 = this;\n\n  // destroy(err, cb) is a private API\n  // we can guarantee we have that here, because we control the\n  // Readable class this is attached to\n  return new Promise(function (resolve, reject) {\n    _this2[kStream].destroy(null, function (err) {\n      if (err) {\n        reject(err);\n        return;\n      }\n\n      resolve(createIterResult(undefined, true));\n    });\n  });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\n\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n  var _Object$create;\n\n  var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {\n    value: stream,\n    writable: true\n  }), _defineProperty(_Object$create, kLastResolve, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kLastReject, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kError, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kEnded, {\n    value: stream._readableState.endEmitted,\n    writable: true\n  }), _defineProperty(_Object$create, kHandlePromise, {\n    value: function value(resolve, reject) {\n      var data = iterator[kStream].read();\n\n      if (data) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        resolve(createIterResult(data, false));\n      } else {\n        iterator[kLastResolve] = resolve;\n        iterator[kLastReject] = reject;\n      }\n    },\n    writable: true\n  }), _Object$create));\n  iterator[kLastPromise] = null;\n  finished(stream, function (err) {\n    if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {\n      var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise\n      // returned by next() and store the error\n\n      if (reject !== null) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        reject(err);\n      }\n\n      iterator[kError] = err;\n      return;\n    }\n\n    var resolve = iterator[kLastResolve];\n\n    if (resolve !== null) {\n      iterator[kLastPromise] = null;\n      iterator[kLastResolve] = null;\n      iterator[kLastReject] = null;\n      resolve(createIterResult(undefined, true));\n    }\n\n    iterator[kEnded] = true;\n  });\n  stream.on('readable', onReadable.bind(null, iterator));\n  return iterator;\n};\n\nmodule.exports = createReadableStreamAsyncIterator;","'use strict';\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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\nvar _require = require('buffer'),\n    Buffer = _require.Buffer;\n\nvar _require2 = require('util'),\n    inspect = _require2.inspect;\n\nvar custom = inspect && inspect.custom || 'inspect';\n\nfunction copyBuffer(src, target, offset) {\n  Buffer.prototype.copy.call(src, target, offset);\n}\n\nmodule.exports =\n/*#__PURE__*/\nfunction () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  _createClass(BufferList, [{\n    key: \"push\",\n    value: function push(v) {\n      var entry = {\n        data: v,\n        next: null\n      };\n      if (this.length > 0) this.tail.next = entry;else this.head = entry;\n      this.tail = entry;\n      ++this.length;\n    }\n  }, {\n    key: \"unshift\",\n    value: function unshift(v) {\n      var entry = {\n        data: v,\n        next: this.head\n      };\n      if (this.length === 0) this.tail = entry;\n      this.head = entry;\n      ++this.length;\n    }\n  }, {\n    key: \"shift\",\n    value: function shift() {\n      if (this.length === 0) return;\n      var ret = this.head.data;\n      if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n      --this.length;\n      return ret;\n    }\n  }, {\n    key: \"clear\",\n    value: function clear() {\n      this.head = this.tail = null;\n      this.length = 0;\n    }\n  }, {\n    key: \"join\",\n    value: function join(s) {\n      if (this.length === 0) return '';\n      var p = this.head;\n      var ret = '' + p.data;\n\n      while (p = p.next) {\n        ret += s + p.data;\n      }\n\n      return ret;\n    }\n  }, {\n    key: \"concat\",\n    value: function concat(n) {\n      if (this.length === 0) return Buffer.alloc(0);\n      var ret = Buffer.allocUnsafe(n >>> 0);\n      var p = this.head;\n      var i = 0;\n\n      while (p) {\n        copyBuffer(p.data, ret, i);\n        i += p.data.length;\n        p = p.next;\n      }\n\n      return ret;\n    } // Consumes a specified amount of bytes or characters from the buffered data.\n\n  }, {\n    key: \"consume\",\n    value: function consume(n, hasStrings) {\n      var ret;\n\n      if (n < this.head.data.length) {\n        // `slice` is the same for buffers and strings.\n        ret = this.head.data.slice(0, n);\n        this.head.data = this.head.data.slice(n);\n      } else if (n === this.head.data.length) {\n        // First chunk is a perfect match.\n        ret = this.shift();\n      } else {\n        // Result spans more than one buffer.\n        ret = hasStrings ? this._getString(n) : this._getBuffer(n);\n      }\n\n      return ret;\n    }\n  }, {\n    key: \"first\",\n    value: function first() {\n      return this.head.data;\n    } // Consumes a specified amount of characters from the buffered data.\n\n  }, {\n    key: \"_getString\",\n    value: function _getString(n) {\n      var p = this.head;\n      var c = 1;\n      var ret = p.data;\n      n -= ret.length;\n\n      while (p = p.next) {\n        var str = p.data;\n        var nb = n > str.length ? str.length : n;\n        if (nb === str.length) ret += str;else ret += str.slice(0, n);\n        n -= nb;\n\n        if (n === 0) {\n          if (nb === str.length) {\n            ++c;\n            if (p.next) this.head = p.next;else this.head = this.tail = null;\n          } else {\n            this.head = p;\n            p.data = str.slice(nb);\n          }\n\n          break;\n        }\n\n        ++c;\n      }\n\n      this.length -= c;\n      return ret;\n    } // Consumes a specified amount of bytes from the buffered data.\n\n  }, {\n    key: \"_getBuffer\",\n    value: function _getBuffer(n) {\n      var ret = Buffer.allocUnsafe(n);\n      var p = this.head;\n      var c = 1;\n      p.data.copy(ret);\n      n -= p.data.length;\n\n      while (p = p.next) {\n        var buf = p.data;\n        var nb = n > buf.length ? buf.length : n;\n        buf.copy(ret, ret.length - n, 0, nb);\n        n -= nb;\n\n        if (n === 0) {\n          if (nb === buf.length) {\n            ++c;\n            if (p.next) this.head = p.next;else this.head = this.tail = null;\n          } else {\n            this.head = p;\n            p.data = buf.slice(nb);\n          }\n\n          break;\n        }\n\n        ++c;\n      }\n\n      this.length -= c;\n      return ret;\n    } // Make sure the linked list only shows the minimal necessary information.\n\n  }, {\n    key: custom,\n    value: function value(_, options) {\n      return inspect(this, _objectSpread({}, options, {\n        // Only inspect one level.\n        depth: 0,\n        // It should not recurse.\n        customInspect: false\n      }));\n    }\n  }]);\n\n  return BufferList;\n}();","'use strict'; // undocumented cb() API, needed for core, not for public API\n\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err) {\n      if (!this._writableState) {\n        process.nextTick(emitErrorNT, this, err);\n      } else if (!this._writableState.errorEmitted) {\n        this._writableState.errorEmitted = true;\n        process.nextTick(emitErrorNT, this, err);\n      }\n    }\n\n    return this;\n  } // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  } // if this is a duplex stream mark the writable part as destroyed as well\n\n\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      if (!_this._writableState) {\n        process.nextTick(emitErrorAndCloseNT, _this, err);\n      } else if (!_this._writableState.errorEmitted) {\n        _this._writableState.errorEmitted = true;\n        process.nextTick(emitErrorAndCloseNT, _this, err);\n      } else {\n        process.nextTick(emitCloseNT, _this);\n      }\n    } else if (cb) {\n      process.nextTick(emitCloseNT, _this);\n      cb(err);\n    } else {\n      process.nextTick(emitCloseNT, _this);\n    }\n  });\n\n  return this;\n}\n\nfunction emitErrorAndCloseNT(self, err) {\n  emitErrorNT(self, err);\n  emitCloseNT(self);\n}\n\nfunction emitCloseNT(self) {\n  if (self._writableState && !self._writableState.emitClose) return;\n  if (self._readableState && !self._readableState.emitClose) return;\n  self.emit('close');\n}\n\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finalCalled = false;\n    this._writableState.prefinished = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nfunction errorOrDestroy(stream, err) {\n  // We have tests that rely on errors being emitted\n  // in the same tick, so changing this is semver major.\n  // For now when you opt-in to autoDestroy we allow\n  // the error to be emitted nextTick. In a future\n  // semver major update we should change the default to this.\n  var rState = stream._readableState;\n  var wState = stream._writableState;\n  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy,\n  errorOrDestroy: errorOrDestroy\n};","// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\n\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    callback.apply(this, args);\n  };\n}\n\nfunction noop() {}\n\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\n\nfunction eos(stream, opts, callback) {\n  if (typeof opts === 'function') return eos(stream, null, opts);\n  if (!opts) opts = {};\n  callback = once(callback || noop);\n  var readable = opts.readable || opts.readable !== false && stream.readable;\n  var writable = opts.writable || opts.writable !== false && stream.writable;\n\n  var onlegacyfinish = function onlegacyfinish() {\n    if (!stream.writable) onfinish();\n  };\n\n  var writableEnded = stream._writableState && stream._writableState.finished;\n\n  var onfinish = function onfinish() {\n    writable = false;\n    writableEnded = true;\n    if (!readable) callback.call(stream);\n  };\n\n  var readableEnded = stream._readableState && stream._readableState.endEmitted;\n\n  var onend = function onend() {\n    readable = false;\n    readableEnded = true;\n    if (!writable) callback.call(stream);\n  };\n\n  var onerror = function onerror(err) {\n    callback.call(stream, err);\n  };\n\n  var onclose = function onclose() {\n    var err;\n\n    if (readable && !readableEnded) {\n      if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n      return callback.call(stream, err);\n    }\n\n    if (writable && !writableEnded) {\n      if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n      return callback.call(stream, err);\n    }\n  };\n\n  var onrequest = function onrequest() {\n    stream.req.on('finish', onfinish);\n  };\n\n  if (isRequest(stream)) {\n    stream.on('complete', onfinish);\n    stream.on('abort', onclose);\n    if (stream.req) onrequest();else stream.on('request', onrequest);\n  } else if (writable && !stream._writableState) {\n    // legacy streams\n    stream.on('end', onlegacyfinish);\n    stream.on('close', onlegacyfinish);\n  }\n\n  stream.on('end', onend);\n  stream.on('finish', onfinish);\n  if (opts.error !== false) stream.on('error', onerror);\n  stream.on('close', onclose);\n  return function () {\n    stream.removeListener('complete', onfinish);\n    stream.removeListener('abort', onclose);\n    stream.removeListener('request', onrequest);\n    if (stream.req) stream.req.removeListener('finish', onfinish);\n    stream.removeListener('end', onlegacyfinish);\n    stream.removeListener('close', onlegacyfinish);\n    stream.removeListener('finish', onfinish);\n    stream.removeListener('end', onend);\n    stream.removeListener('error', onerror);\n    stream.removeListener('close', onclose);\n  };\n}\n\nmodule.exports = eos;","module.exports = function () {\n  throw new Error('Readable.from is not available in the browser')\n};\n","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar eos;\n\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n    callback.apply(void 0, arguments);\n  };\n}\n\nvar _require$codes = require('../../../errors').codes,\n    ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,\n    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;\n\nfunction noop(err) {\n  // Rethrow the error if it exists to avoid swallowing it\n  if (err) throw err;\n}\n\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\n\nfunction destroyer(stream, reading, writing, callback) {\n  callback = once(callback);\n  var closed = false;\n  stream.on('close', function () {\n    closed = true;\n  });\n  if (eos === undefined) eos = require('./end-of-stream');\n  eos(stream, {\n    readable: reading,\n    writable: writing\n  }, function (err) {\n    if (err) return callback(err);\n    closed = true;\n    callback();\n  });\n  var destroyed = false;\n  return function (err) {\n    if (closed) return;\n    if (destroyed) return;\n    destroyed = true; // request.destroy just do .end - .abort is what we want\n\n    if (isRequest(stream)) return stream.abort();\n    if (typeof stream.destroy === 'function') return stream.destroy();\n    callback(err || new ERR_STREAM_DESTROYED('pipe'));\n  };\n}\n\nfunction call(fn) {\n  fn();\n}\n\nfunction pipe(from, to) {\n  return from.pipe(to);\n}\n\nfunction popCallback(streams) {\n  if (!streams.length) return noop;\n  if (typeof streams[streams.length - 1] !== 'function') return noop;\n  return streams.pop();\n}\n\nfunction pipeline() {\n  for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {\n    streams[_key] = arguments[_key];\n  }\n\n  var callback = popCallback(streams);\n  if (Array.isArray(streams[0])) streams = streams[0];\n\n  if (streams.length < 2) {\n    throw new ERR_MISSING_ARGS('streams');\n  }\n\n  var error;\n  var destroys = streams.map(function (stream, i) {\n    var reading = i < streams.length - 1;\n    var writing = i > 0;\n    return destroyer(stream, reading, writing, function (err) {\n      if (!error) error = err;\n      if (err) destroys.forEach(call);\n      if (reading) return;\n      destroys.forEach(call);\n      callback(error);\n    });\n  });\n  return streams.reduce(pipe);\n}\n\nmodule.exports = pipeline;","'use strict';\n\nvar ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;\n\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\n\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n\n  if (hwm != null) {\n    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {\n      var name = isDuplex ? duplexKey : 'highWaterMark';\n      throw new ERR_INVALID_OPT_VALUE(name, hwm);\n    }\n\n    return Math.floor(hwm);\n  } // Default value\n\n\n  return state.objectMode ? 16 : 16 * 1024;\n}\n\nmodule.exports = {\n  getHighWaterMark: getHighWaterMark\n};","module.exports = require('events').EventEmitter;\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\nexports.finished = require('./lib/internal/streams/end-of-stream.js');\nexports.pipeline = require('./lib/internal/streams/pipeline.js');\n","/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.prototype = Object.create(Buffer.prototype)\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\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\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\n","module.exports = __WEBPACK_EXTERNAL_MODULE__0__;","// 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\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\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__.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__.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};","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","// **N3Util** provides N3 utility functions.\n\nimport N3DataFactory from './N3DataFactory';\n\n// Tests whether the given term represents an IRI\nexport function isNamedNode(term) {\n  return !!term && term.termType === 'NamedNode';\n}\n\n// Tests whether the given term represents a blank node\nexport function isBlankNode(term) {\n  return !!term && term.termType === 'BlankNode';\n}\n\n// Tests whether the given term represents a literal\nexport function isLiteral(term) {\n  return !!term && term.termType === 'Literal';\n}\n\n// Tests whether the given term represents a variable\nexport function isVariable(term) {\n  return !!term && term.termType === 'Variable';\n}\n\n// Tests whether the given term represents the default graph\nexport function isDefaultGraph(term) {\n  return !!term && term.termType === 'DefaultGraph';\n}\n\n// Tests whether the given quad is in the default graph\nexport function inDefaultGraph(quad) {\n  return isDefaultGraph(quad.graph);\n}\n\n// Creates a function that prepends the given IRI to a local name\nexport function prefix(iri, factory) {\n  return prefixes({ '': iri.value || iri }, factory)('');\n}\n\n// Creates a function that allows registering and expanding prefixes\nexport function prefixes(defaultPrefixes, factory) {\n  // Add all of the default prefixes\n  const prefixes = Object.create(null);\n  for (const prefix in defaultPrefixes)\n    processPrefix(prefix, defaultPrefixes[prefix]);\n  // Set the default factory if none was specified\n  factory = factory || N3DataFactory;\n\n  // Registers a new prefix (if an IRI was specified)\n  // or retrieves a function that expands an existing prefix (if no IRI was specified)\n  function processPrefix(prefix, iri) {\n    // Create a new prefix if an IRI is specified or the prefix doesn't exist\n    if (typeof iri === 'string') {\n      // Create a function that expands the prefix\n      const cache = Object.create(null);\n      prefixes[prefix] = local => {\n        return cache[local] || (cache[local] = factory.namedNode(iri + local));\n      };\n    }\n    else if (!(prefix in prefixes)) {\n      throw new Error(`Unknown prefix: ${prefix}`);\n    }\n    return prefixes[prefix];\n  }\n  return processPrefix;\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';\nimport { isDefaultGraph } from './N3Util';\nconst { rdf, xsd } = namespaces;\n\n// eslint-disable-next-line prefer-const\nlet DEFAULTGRAPH;\nlet _blankNodeCounter = 0;\n\nconst escapedLiteral = /^\"(.*\".*)(?=\"[^\"]*$)/;\nconst quadId = /^<<(\"(?:\"\"|[^\"])*\"[^ ]*|[^ ]+) (\"(?:\"\"|[^\"])*\"[^ ]*|[^ ]+) (\"(?:\"\"|[^\"])*\"[^ ]*|[^ ]+) ?(\"(?:\"\"|[^\"])*\"[^ ]*|[^ ]+)?>>$/;\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\n// ### Constructs a term from the given internal string ID\nexport function termFromId(id, factory) {\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    const components = quadId.exec(id);\n    return factory.quad(\n      termFromId(unescapeQuotes(components[1]), factory),\n      termFromId(unescapeQuotes(components[2]), factory),\n      termFromId(unescapeQuotes(components[3]), factory),\n      components[4] && termFromId(unescapeQuotes(components[4]), factory)\n    );\n  default:\n    return factory.namedNode(id);\n  }\n}\n\n// ### Constructs an internal string ID from the given term or ID string\nexport function termToId(term) {\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    // To identify RDF* quad components, we escape quotes by doubling them.\n    // This avoids the overhead of backslash parsing of Turtle-like syntaxes.\n    return `<<${\n        escapeQuotes(termToId(term.subject))\n      } ${\n        escapeQuotes(termToId(term.predicate))\n      } ${\n        escapeQuotes(termToId(term.object))\n      }${\n        (isDefaultGraph(term.graph)) ? '' : ` ${termToId(term.graph)}`\n      }>>`;\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","export const xsd = {\n    boolean: 'http://www.w3.org/2001/XMLSchema#boolean',\n    dateTime: 'http://www.w3.org/2001/XMLSchema#dateTime',\n    date: 'http://www.w3.org/2001/XMLSchema#date',\n    time: 'http://www.w3.org/2001/XMLSchema#time',\n    decimal: 'http://www.w3.org/2001/XMLSchema#decimal',\n    anyURI: 'http://www.w3.org/2001/XMLSchema#anyURI',\n    integer: 'http://www.w3.org/2001/XMLSchema#integer',\n    string: 'http://www.w3.org/2001/XMLSchema#string',\n    double: 'http://www.w3.org/2001/XMLSchema#double',\n    langString: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#langString',\n};\n//# sourceMappingURL=index.js.map","export function mergeDeep(target, source) {\n    const output = Object.assign({}, target);\n    if (isObject(target) && isObject(source)) {\n        Object.keys(source).forEach((key) => {\n            if (Array.isArray(source[key])) {\n                output[key] = source[key];\n                output[key].push(...(target[key] || []));\n            }\n            else if (isObject(source[key])) {\n                if (!(key in target))\n                    Object.assign(output, { [key]: source[key] });\n                else\n                    output[key] = mergeDeep(target[key], source[key]);\n            }\n            else {\n                Object.assign(output, { [key]: source[key] });\n            }\n        });\n    }\n    return output;\n}\nfunction isObject(item) {\n    return item && typeof item === 'object' && !Array.isArray(item);\n}\n//# sourceMappingURL=utils.js.map","import { DataSerializer, Serializer, } from '@openhps/core';\nimport * as N3 from 'n3';\nimport { xsd } from '../decorators/';\nimport { mergeDeep } from './utils';\nexport class InternalRDFSerializer extends Serializer {\n    constructor() {\n        super(...arguments);\n        this.serializationStrategy = new Map([\n            [Number, this.serializeLiteral.bind(this)],\n            [String, this.serializeLiteral.bind(this)],\n            [Boolean, this.serializeLiteral.bind(this)],\n            [Date, this.serializeDate.bind(this)],\n            [Array, this.serializeArray.bind(this)],\n            [Map, this.serializeMap.bind(this)],\n            [Set, this.serializeSet.bind(this)],\n        ]);\n    }\n    convertSingleValue(sourceObject, typeDescriptor, memberName, memberOptions, serializerOptions) {\n        if (this.retrievePreserveNull(memberOptions) && sourceObject === null) {\n            return null;\n        }\n        if (sourceObject === undefined || sourceObject === null) {\n            return;\n        }\n        if (memberOptions &&\n            memberOptions.options &&\n            memberOptions.options.rdf &&\n            memberOptions.options.rdf.serializer) {\n            return memberOptions.options.rdf.serializer(sourceObject);\n        }\n        const serializer = this.serializationStrategy.get(typeDescriptor.ctor);\n        if (serializer !== undefined) {\n            return serializer(sourceObject, typeDescriptor, memberName, this, memberOptions, serializerOptions);\n        }\n        if (typeof sourceObject === 'object') {\n            return this.serializeObject(sourceObject, typeDescriptor, memberName, this, memberOptions, serializerOptions);\n        }\n        let error = `Could not serialize '${memberName}'; don't know how to serialize type`;\n        if (typeDescriptor.hasFriendlyName()) {\n            error += ` '${typeDescriptor.ctor.name}'`;\n        }\n        this.errorHandler(new TypeError(`${error}.`));\n    }\n    serializeObject(sourceObject, typeDescriptor, memberName, serializer, memberOptions, serializerOptions) {\n        let metadata;\n        const rootMetadata = DataSerializer.getRootMetadata(sourceObject.constructor);\n        if (sourceObject.constructor !== typeDescriptor.ctor && sourceObject instanceof typeDescriptor.ctor) {\n            metadata = DataSerializer.getMetadata(sourceObject.constructor);\n        }\n        else {\n            metadata = DataSerializer.getMetadata(typeDescriptor.ctor);\n        }\n        const options = metadata.options && metadata.options.rdf\n            ? metadata.options.rdf\n            : rootMetadata.options && rootMetadata.options.rdf\n                ? rootMetadata.options.rdf\n                : undefined;\n        if (!options) {\n            return undefined;\n        }\n        const identifierMember = Array.from(metadata.dataMembers.values()).filter((member) => {\n            return (member &&\n                member.options &&\n                member.options.rdf &&\n                member.options.rdf.identifier);\n        })[0];\n        let uri = undefined;\n        if (identifierMember) {\n            const rdfOptions = identifierMember.options.rdf;\n            uri = rdfOptions.serializer\n                ? rdfOptions.serializer(sourceObject[identifierMember.key], sourceObject.constructor)\n                : sourceObject[identifierMember.key];\n        }\n        uri =\n            uri && !uri.startsWith('http') && serializerOptions.rdf.baseUri\n                ? serializerOptions.rdf.baseUri + uri\n                : N3.DataFactory.blankNode(uri).value;\n        let thing = {\n            value: uri,\n            predicates: options.predicates\n                ? Object.entries(options.predicates)\n                    .map(([k, v]) => {\n                    return { [k]: v.map(N3.DataFactory.namedNode) };\n                })\n                    .reduce((a, b) => {\n                    return Object.assign(Object.assign({}, a), b);\n                })\n                : {},\n        };\n        if (options.serializer) {\n            thing = mergeDeep(thing, options.serializer(sourceObject, serializerOptions.rdf.baseUri));\n        }\n        thing.termType = thing.value.startsWith('http') ? 'NamedNode' : 'BlankNode';\n        metadata.dataMembers.forEach((member) => {\n            const rootMember = rootMetadata.dataMembers.get(member.key);\n            const memberOptions = member.options && member.options.rdf\n                ? member\n                : rootMember && rootMember.options && rootMember.options.rdf\n                    ? rootMember\n                    : undefined;\n            if (!memberOptions || !memberOptions.options.rdf.predicate) {\n                return;\n            }\n            const object = serializer.convertSingleValue(sourceObject[memberOptions.key], memberOptions.type(), `${memberOptions.name}`, memberOptions, serializerOptions);\n            if (object) {\n                const predicates = memberOptions.options.rdf.predicate;\n                [...(Array.isArray(predicates) ? predicates : [predicates])].forEach((predicateIri) => {\n                    const predicate = thing.predicates[predicateIri] || [];\n                    predicate.push(...(Array.isArray(object) ? object : [object]).filter((s) => s));\n                    thing.predicates[predicateIri] = predicate;\n                });\n            }\n        });\n        return thing;\n    }\n    serializeArray(sourceObject, typeDescriptor, memberName, _, memberOptions, serializerOptions) {\n        return sourceObject.map((obj) => {\n            return this.convertSingleValue(obj, typeDescriptor.elementType, memberName, memberOptions, serializerOptions);\n        });\n    }\n    serializeMap(sourceObject, typeDescriptor, memberName, _, memberOptions, serializerOptions) {\n        return Array.from(sourceObject.values()).map((obj) => {\n            return this.convertSingleValue(obj, typeDescriptor.valueType, memberName, memberOptions, serializerOptions);\n        });\n    }\n    serializeSet(sourceObject, typeDescriptor, memberName, _, memberOptions, serializerOptions) {\n        return Array.from(sourceObject.values()).map((obj) => {\n            return this.convertSingleValue(obj, typeDescriptor.valueType, memberName, memberOptions, serializerOptions);\n        });\n    }\n    serializeLiteral(sourceObject, typeDescriptor, memberName, serializer, memberOptions) {\n        var _a;\n        let xsdDatatype = undefined;\n        const rdfOptions = memberOptions.options.rdf;\n        if (rdfOptions && rdfOptions.datatype) {\n            xsdDatatype = rdfOptions.datatype;\n            switch (rdfOptions.datatype) {\n                case xsd.date:\n                case xsd.dateTime:\n                    return this.serializeDate(sourceObject, typeDescriptor, memberName, serializer, memberOptions);\n            }\n        }\n        else {\n            switch (typeof sourceObject) {\n                case 'bigint':\n                case 'number':\n                    xsdDatatype = xsd.decimal;\n                    break;\n                case 'boolean':\n                    xsdDatatype = xsd.boolean;\n                    break;\n                default:\n                    xsdDatatype = xsd.string;\n                    break;\n            }\n        }\n        const dataTypeNode = this.iriToNode(xsdDatatype);\n        return N3.DataFactory.literal(sourceObject, rdfOptions ? (_a = rdfOptions.language) !== null && _a !== void 0 ? _a : dataTypeNode : dataTypeNode);\n    }\n    serializeDate(sourceObject, typeDescriptor, memberName, serializer, memberOptions) {\n        var _a;\n        const rdfOptions = memberOptions.options.rdf;\n        const xsdDatatype = xsd.dateTime;\n        const dateString = new Date(sourceObject).toISOString();\n        const dataTypeNode = this.iriToNode(xsdDatatype);\n        return N3.DataFactory.literal(dateString, rdfOptions ? (_a = rdfOptions.language) !== null && _a !== void 0 ? _a : dataTypeNode : dataTypeNode);\n    }\n    iriToNode(iri) {\n        return N3.DataFactory.namedNode(iri);\n    }\n}\n//# sourceMappingURL=InternalRDFSerializer.js.map","export const type = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';\nexport const subject = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#subject';\nexport const predicate = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate';\nexport const object = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#object';\nexport const value = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#value';\nexport const first = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#first';\nexport const rest = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#rest';\nexport const language = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#language';\nexport const direction = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#direction';\nexport const Property = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#Property';\nexport const Statement = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement';\nexport const Bag = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag';\nexport const Seq = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq';\nexport const Alt = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#Alt';\nexport const List = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#List';\nexport const CompoundLiteral = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#CompoundLiteral';\nexport const HTML = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#HTML';\nexport const langString = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#langString';\nexport const PlainLiteral = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#PlainLiteral';\nexport const XMLLiteral = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral';\nexport const JSON__workaround = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#JSON';\nexport const nil = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil';\n//# sourceMappingURL=rdf.js.map","import * as geoImport from './geo';\nexport const geo = geoImport;\nimport * as schemaImport from './schema';\nexport const schema = schemaImport;\nimport * as rdfImport from './rdf';\nexport const rdf = rdfImport;\nimport * as rdfsImport from './rdfs';\nexport const rdfs = rdfsImport;\nimport * as vcardImport from './vcard';\nexport const vcard = vcardImport;\nimport * as owlImport from './owl';\nexport const owl = owlImport;\nimport * as timeImport from './time';\nexport const time = timeImport;\nimport * as dctermsImport from './dcterms';\nexport const dcterms = dctermsImport;\nimport * as dcmiImport from './dcmi';\nexport const dcmi = dcmiImport;\nimport * as dqmImport from './dqm';\nexport const dqm = dqmImport;\nimport * as foafImport from './foaf';\nexport const foaf = foafImport;\nimport * as qudtImport from './qudt';\nexport const qudt = qudtImport;\nimport * as qudt_unitImport from './qudt_unit';\nexport const qudt_unit = qudt_unitImport;\nimport * as quantitykindImport from './quantitykind';\nexport const quantitykind = quantitykindImport;\nimport * as sosaImport from './sosa';\nexport const sosa = sosaImport;\nimport * as ssnImport from './ssn';\nexport const ssn = ssnImport;\nimport * as ssnsImport from './ssns';\nexport const ssns = ssnsImport;\nimport * as openhpsImport from './openhps';\nexport const openhps = openhpsImport;\nimport * as ogcImport from './ogc';\nexport const ogc = ogcImport;\n//# sourceMappingURL=index.js.map","import { DataSerializer, Deserializer, } from '@openhps/core';\nimport { xsd } from '../decorators';\nimport { rdf } from '../vocab';\nexport class InternalRDFDeserializer extends Deserializer {\n    constructor() {\n        super(...arguments);\n        this.deserializationStrategy = new Map([\n            [Number, this.deserializeLiteral.bind(this)],\n            [String, this.deserializeLiteral.bind(this)],\n            [Boolean, this.deserializeLiteral.bind(this)],\n            [Date, this.deserializeLiteral.bind(this)],\n            [Array, this.deserializeArray.bind(this)],\n            [Map, this.deserializeMap.bind(this)],\n            [Set, this.deserializeSet.bind(this)],\n        ]);\n    }\n    rdfTypeResolver(sourceObject, knownTypes, knownRDFTypes) {\n        if (sourceObject['predicates'] !== undefined) {\n            const rdfTypes = Object.entries(sourceObject['predicates'])\n                .filter(([k, _]) => k === rdf.type)\n                .map(([_, v]) => v)\n                .flat()\n                .map((v) => v.value);\n            const mappedTypes = rdfTypes\n                .map((type) => knownRDFTypes.get(type))\n                .flat()\n                .map((type) => knownTypes.get(type));\n            return mappedTypes[0];\n        }\n        return Object;\n    }\n    convertSingleValue(sourceObject, typeDescriptor, knownTypes, memberName = 'object', memberOptions, serializerOptions) {\n        if (this.retrievePreserveNull(memberOptions) && sourceObject === null) {\n            return null;\n        }\n        else if (sourceObject === null || sourceObject === undefined) {\n            return;\n        }\n        const deserializer = this.deserializationStrategy.get(typeDescriptor.ctor);\n        if (deserializer !== undefined) {\n            return deserializer(sourceObject, typeDescriptor, knownTypes, memberName, this, memberOptions, serializerOptions);\n        }\n        if (typeof sourceObject === 'object') {\n            return this.deserializeObject(sourceObject, typeDescriptor, knownTypes, memberName, this, serializerOptions);\n        }\n        let error = `Could not deserialize '${memberName}'; don't know how to deserialize type`;\n        if (typeDescriptor.hasFriendlyName()) {\n            error += ` '${typeDescriptor.ctor.name}'`;\n        }\n        this.errorHandler(new TypeError(`${error}.`));\n    }\n    deserializeObject(sourceObject, typeDescriptor, knownTypes, _, deserializer, serializerOptions) {\n        const expectedSelfType = typeDescriptor.ctor;\n        const typeFromRDF = this.rdfTypeResolver(sourceObject, knownTypes, serializerOptions.rdf.knownTypes);\n        const finalType = typeFromRDF || expectedSelfType;\n        const metadata = DataSerializer.getMetadata(finalType);\n        const rootMetadata = DataSerializer.getRootMetadata(finalType);\n        if (!metadata && !rootMetadata) {\n            return undefined;\n        }\n        const options = metadata.options && metadata.options.rdf\n            ? metadata.options.rdf\n            : rootMetadata.options && rootMetadata.options.rdf\n                ? rootMetadata.options.rdf\n                : undefined;\n        if (!options) {\n            return undefined;\n        }\n        const targetObject = options.deserializer\n            ? options.deserializer(sourceObject)\n            : this.instantiateType(finalType);\n        const identifierMember = Array.from(metadata.dataMembers.values()).filter((member) => {\n            return (member &&\n                member.options &&\n                member.options.rdf &&\n                member.options.rdf.identifier);\n        })[0];\n        if (identifierMember) {\n            const rdfOptions = identifierMember.options.rdf;\n            targetObject[identifierMember.key] = rdfOptions.deserializer\n                ? rdfOptions.deserializer(sourceObject, finalType)\n                : sourceObject.value;\n        }\n        metadata.dataMembers.forEach((member) => {\n            const rootMember = rootMetadata.dataMembers.get(member.key);\n            const memberOptions = member.options && member.options.rdf\n                ? member\n                : rootMember && rootMember.options && rootMember.options.rdf\n                    ? rootMember\n                    : undefined;\n            if (!memberOptions || !memberOptions.options.rdf.predicate) {\n                return undefined;\n            }\n            const predicates = memberOptions.options.rdf.predicate;\n            [...(Array.isArray(predicates) ? predicates : [predicates])].forEach((predicateIri) => {\n                if (!sourceObject.predicates[predicateIri]) {\n                    return;\n                }\n                if (memberOptions.type().ctor === Array) {\n                    targetObject[memberOptions.key] = deserializer.convertSingleValue(sourceObject.predicates[predicateIri], memberOptions.type(), knownTypes, memberOptions.name, memberOptions, serializerOptions);\n                }\n                else {\n                    targetObject[memberOptions.key] = sourceObject.predicates[predicateIri]\n                        .map((object) => {\n                        return deserializer.convertSingleValue(object, memberOptions.type(), knownTypes, memberOptions.name, memberOptions, serializerOptions);\n                    })\n                        .filter((item) => this.isInstanceOf(item, memberOptions.type().ctor))[0];\n                }\n            });\n        });\n        return targetObject;\n    }\n    deserializeLiteral(sourceObject, typeDescriptor, knownTypes, memberName, deserializer, memberOptions, serializerOptions) {\n        switch (sourceObject.datatype.value) {\n            case xsd.dateTime:\n                return new Date(sourceObject.value).getTime();\n            default:\n                return sourceObject.value;\n        }\n    }\n    deserializeDate(sourceObject, typeDescriptor, knownTypes, memberName, deserializer, memberOptions, serializerOptions) {\n        return new Date(sourceObject.value);\n    }\n    deserializeArray(sourceObject, typeDescriptor, knownTypes, memberName, deserializer, memberOptions, serializerOptions) {\n        if (!sourceObject) {\n            return [];\n        }\n        return sourceObject\n            .map((object) => {\n            return deserializer.convertSingleValue(object, typeDescriptor.elementType, knownTypes, memberName, memberOptions, serializerOptions);\n        })\n            .filter((val) => this.isInstanceOf(val, typeDescriptor.elementType.ctor));\n    }\n    isInstanceOf(value, constructor) {\n        if (typeof value === 'number') {\n            return constructor === Number;\n        }\n        else if (typeof value === 'string') {\n            return constructor === String;\n        }\n        else if (typeof value === 'boolean') {\n            return constructor === Boolean;\n        }\n        else if (typeof value === 'object') {\n            return value instanceof constructor;\n        }\n        return false;\n    }\n    deserializeMap(sourceObject, typeDescriptor, knownTypes, memberName, deserializer, memberOptions, serializerOptions) {\n        return undefined;\n    }\n    deserializeSet(sourceObject, typeDescriptor, knownTypes, memberName, deserializer, memberOptions, serializerOptions) {\n        return undefined;\n    }\n}\n//# sourceMappingURL=InternalRDFDeserializer.js.map","// **N3Store** objects store N3 quads by graph in memory.\nimport { default as N3DataFactory, termToId, termFromId } from './N3DataFactory';\nimport { Readable } from 'readable-stream';\nimport namespaces from './IRIs';\n\n// ## Constructor\nexport default class N3Store {\n  constructor(quads, options) {\n    // The number of quads is initially zero\n    this._size = 0;\n    // `_graphs` contains subject, predicate, and object indexes per graph\n    this._graphs = Object.create(null);\n    // `_ids` maps entities such as `http://xmlns.com/foaf/0.1/name` to numbers,\n    // saving memory by using only numbers as keys in `_graphs`\n    this._id = 0;\n    this._ids = Object.create(null);\n    this._ids['><'] = 0; // dummy entry, so the first actual key is non-zero\n    this._entities = Object.create(null); // inverse of `_ids`\n    // `_blankNodeIndex` is the index of the last automatically named blank node\n    this._blankNodeIndex = 0;\n\n    // Shift parameters if `quads` is not given\n    if (!options && quads && !quads[0])\n      options = quads, quads = null;\n    options = options || {};\n    this._factory = options.factory || N3DataFactory;\n\n    // Add quads if passed\n    if (quads)\n      this.addQuads(quads);\n  }\n\n  // ## Public properties\n\n  // ### `size` returns the number of quads in the store\n  get size() {\n    // Return the quad count if if was cached\n    let size = this._size;\n    if (size !== null)\n      return size;\n\n    // Calculate the number of quads by counting to the deepest level\n    size = 0;\n    const graphs = this._graphs;\n    let subjects, subject;\n    for (const graphKey in graphs)\n      for (const subjectKey in (subjects = graphs[graphKey].subjects))\n        for (const predicateKey in (subject = subjects[subjectKey]))\n          size += Object.keys(subject[predicateKey]).length;\n    return this._size = size;\n  }\n\n  // ## Private methods\n\n  // ### `_addToIndex` adds a quad to a three-layered index.\n  // Returns if the index has changed, if the entry did not already exist.\n  _addToIndex(index0, key0, key1, key2) {\n    // Create layers as necessary\n    const index1 = index0[key0] || (index0[key0] = {});\n    const index2 = index1[key1] || (index1[key1] = {});\n    // Setting the key to _any_ value signals the presence of the quad\n    const existed = key2 in index2;\n    if (!existed)\n      index2[key2] = null;\n    return !existed;\n  }\n\n  // ### `_removeFromIndex` removes a quad from a three-layered index\n  _removeFromIndex(index0, key0, key1, key2) {\n    // Remove the quad from the index\n    const index1 = index0[key0], index2 = index1[key1];\n    delete index2[key2];\n\n    // Remove intermediary index layers if they are empty\n    for (const key in index2) return;\n    delete index1[key1];\n    for (const key in index1) return;\n    delete index0[key0];\n  }\n\n  // ### `_findInIndex` finds a set of quads in a three-layered index.\n  // The index base is `index0` and the keys at each level are `key0`, `key1`, and `key2`.\n  // Any of these keys can be undefined, which is interpreted as a wildcard.\n  // `name0`, `name1`, and `name2` are the names of the keys at each level,\n  // used when reconstructing the resulting quad\n  // (for instance: _subject_, _predicate_, and _object_).\n  // Finally, `graphId` will be the graph of the created quads.\n  *_findInIndex(index0, key0, key1, key2, name0, name1, name2, graphId) {\n    let tmp, index1, index2;\n    // Depending on the number of variables, keys or reverse index are faster\n    const varCount = !key0 + !key1 + !key2,\n        entityKeys = varCount > 1 ? Object.keys(this._ids) : this._entities;\n    const graph = termFromId(graphId, this._factory);\n\n    // If a key is specified, use only that part of index 0.\n    if (key0) (tmp = index0, index0 = {})[key0] = tmp[key0];\n    for (const value0 in index0) {\n      const entity0 = entityKeys[value0];\n\n      if (index1 = index0[value0]) {\n        // If a key is specified, use only that part of index 1.\n        if (key1) (tmp = index1, index1 = {})[key1] = tmp[key1];\n        for (const value1 in index1) {\n          const entity1 = entityKeys[value1];\n\n          if (index2 = index1[value1]) {\n            // If a key is specified, use only that part of index 2, if it exists.\n            const values = key2 ? (key2 in index2 ? [key2] : []) : Object.keys(index2);\n            // Create quads for all items found in index 2.\n            for (let l = 0; l < values.length; l++) {\n              const parts = { subject: null, predicate: null, object: null };\n              parts[name0] = termFromId(entity0, this._factory);\n              parts[name1] = termFromId(entity1, this._factory);\n              parts[name2] = termFromId(entityKeys[values[l]], this._factory);\n              yield this._factory.quad(parts.subject, parts.predicate, parts.object, graph);\n            }\n          }\n        }\n      }\n    }\n  }\n\n  // ### `_loop` executes the callback on all keys of index 0\n  _loop(index0, callback) {\n    for (const key0 in index0)\n      callback(key0);\n  }\n\n  // ### `_loopByKey0` executes the callback on all keys of a certain entry in index 0\n  _loopByKey0(index0, key0, callback) {\n    let index1, key1;\n    if (index1 = index0[key0]) {\n      for (key1 in index1)\n        callback(key1);\n    }\n  }\n\n  // ### `_loopByKey1` executes the callback on given keys of all entries in index 0\n  _loopByKey1(index0, key1, callback) {\n    let key0, index1;\n    for (key0 in index0) {\n      index1 = index0[key0];\n      if (index1[key1])\n        callback(key0);\n    }\n  }\n\n  // ### `_loopBy2Keys` executes the callback on given keys of certain entries in index 2\n  _loopBy2Keys(index0, key0, key1, callback) {\n    let index1, index2, key2;\n    if ((index1 = index0[key0]) && (index2 = index1[key1])) {\n      for (key2 in index2)\n        callback(key2);\n    }\n  }\n\n  // ### `_countInIndex` counts matching quads in a three-layered index.\n  // The index base is `index0` and the keys at each level are `key0`, `key1`, and `key2`.\n  // Any of these keys can be undefined, which is interpreted as a wildcard.\n  _countInIndex(index0, key0, key1, key2) {\n    let count = 0, tmp, index1, index2;\n\n    // If a key is specified, count only that part of index 0\n    if (key0) (tmp = index0, index0 = {})[key0] = tmp[key0];\n    for (const value0 in index0) {\n      if (index1 = index0[value0]) {\n        // If a key is specified, count only that part of index 1\n        if (key1) (tmp = index1, index1 = {})[key1] = tmp[key1];\n        for (const value1 in index1) {\n          if (index2 = index1[value1]) {\n            // If a key is specified, count the quad if it exists\n            if (key2) (key2 in index2) && count++;\n            // Otherwise, count all quads\n            else count += Object.keys(index2).length;\n          }\n        }\n      }\n    }\n    return count;\n  }\n\n  // ### `_getGraphs` returns an array with the given graph,\n  // or all graphs if the argument is null or undefined.\n  _getGraphs(graph) {\n    if (!isString(graph))\n      return this._graphs;\n    const graphs = {};\n    graphs[graph] = this._graphs[graph];\n    return graphs;\n  }\n\n  // ### `_uniqueEntities` returns a function that accepts an entity ID\n  // and passes the corresponding entity to callback if it hasn't occurred before.\n  _uniqueEntities(callback) {\n    const uniqueIds = Object.create(null);\n    return id => {\n      if (!(id in uniqueIds)) {\n        uniqueIds[id] = true;\n        callback(termFromId(this._entities[id], this._factory));\n      }\n    };\n  }\n\n  // ## Public methods\n\n  // ### `add` adds the specified quad to the dataset.\n  // Returns the dataset instance it was called on.\n  // Existing quads, as defined in Quad.equals, will be ignored.\n  add(quad) {\n    this.addQuad(quad);\n    return this;\n  }\n\n  // ### `addQuad` adds a new quad to the store.\n  // Returns if the quad index has changed, if the quad did not already exist.\n  addQuad(subject, predicate, object, graph) {\n    // Shift arguments if a quad object is given instead of components\n    if (!predicate)\n      graph = subject.graph, object = subject.object,\n        predicate = subject.predicate, subject = subject.subject;\n\n    // Convert terms to internal string representation\n    subject = termToId(subject);\n    predicate = termToId(predicate);\n    object = termToId(object);\n    graph = termToId(graph);\n\n    // Find the graph that will contain the triple\n    let graphItem = this._graphs[graph];\n    // Create the graph if it doesn't exist yet\n    if (!graphItem) {\n      graphItem = this._graphs[graph] = { subjects: {}, predicates: {}, objects: {} };\n      // Freezing a graph helps subsequent `add` performance,\n      // and properties will never be modified anyway\n      Object.freeze(graphItem);\n    }\n\n    // Since entities can often be long IRIs, we avoid storing them in every index.\n    // Instead, we have a separate index that maps entities to numbers,\n    // which are then used as keys in the other indexes.\n    const ids = this._ids;\n    const entities = this._entities;\n    subject   = ids[subject]   || (ids[entities[++this._id] = subject]   = this._id);\n    predicate = ids[predicate] || (ids[entities[++this._id] = predicate] = this._id);\n    object    = ids[object]    || (ids[entities[++this._id] = object]    = this._id);\n\n    const changed = this._addToIndex(graphItem.subjects,   subject,   predicate, object);\n    this._addToIndex(graphItem.predicates, predicate, object,    subject);\n    this._addToIndex(graphItem.objects,    object,    subject,   predicate);\n\n    // The cached quad count is now invalid\n    this._size = null;\n    return changed;\n  }\n\n  // ### `addQuads` adds multiple quads to the store\n  addQuads(quads) {\n    for (let i = 0; i < quads.length; i++)\n      this.addQuad(quads[i]);\n  }\n\n  // ### `delete` removes the specified quad from the dataset.\n  // Returns the dataset instance it was called on.\n  delete(quad) {\n    this.removeQuad(quad);\n    return this;\n  }\n\n  // ### `has` determines whether a dataset includes a certain quad or quad pattern.\n  has(subjectOrQuad, predicate, object, graph) {\n    if (subjectOrQuad && subjectOrQuad.subject)\n      ({ subject: subjectOrQuad, predicate, object, graph } = subjectOrQuad);\n    return !this.readQuads(subjectOrQuad, predicate, object, graph).next().done;\n  }\n\n  // ### `import` adds a stream of quads to the store\n  import(stream) {\n    stream.on('data', quad => { this.addQuad(quad); });\n    return stream;\n  }\n\n  // ### `removeQuad` removes a quad from the store if it exists\n  removeQuad(subject, predicate, object, graph) {\n    // Shift arguments if a quad object is given instead of components\n    if (!predicate)\n      graph = subject.graph, object = subject.object,\n        predicate = subject.predicate, subject = subject.subject;\n\n    // Convert terms to internal string representation\n    subject = termToId(subject);\n    predicate = termToId(predicate);\n    object = termToId(object);\n    graph = termToId(graph);\n\n    // Find internal identifiers for all components\n    // and verify the quad exists.\n    const ids = this._ids, graphs = this._graphs;\n    let graphItem, subjects, predicates;\n    if (!(subject    = ids[subject]) || !(predicate = ids[predicate]) ||\n        !(object     = ids[object])  || !(graphItem = graphs[graph])  ||\n        !(subjects   = graphItem.subjects[subject]) ||\n        !(predicates = subjects[predicate]) ||\n        !(object in predicates))\n      return false;\n\n    // Remove it from all indexes\n    this._removeFromIndex(graphItem.subjects,   subject,   predicate, object);\n    this._removeFromIndex(graphItem.predicates, predicate, object,    subject);\n    this._removeFromIndex(graphItem.objects,    object,    subject,   predicate);\n    if (this._size !== null) this._size--;\n\n    // Remove the graph if it is empty\n    for (subject in graphItem.subjects) return true;\n    delete graphs[graph];\n    return true;\n  }\n\n  // ### `removeQuads` removes multiple quads from the store\n  removeQuads(quads) {\n    for (let i = 0; i < quads.length; i++)\n      this.removeQuad(quads[i]);\n  }\n\n  // ### `remove` removes a stream of quads from the store\n  remove(stream) {\n    stream.on('data', quad => { this.removeQuad(quad); });\n    return stream;\n  }\n\n  // ### `removeMatches` removes all matching quads from the store\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  removeMatches(subject, predicate, object, graph) {\n    const stream = new Readable({ objectMode: true });\n\n    stream._read = () => {\n      for (const quad of this.readQuads(subject, predicate, object, graph))\n        stream.push(quad);\n      stream.push(null);\n    };\n\n    return this.remove(stream);\n  }\n\n  // ### `deleteGraph` removes all triples with the given graph from the store\n  deleteGraph(graph) {\n    return this.removeMatches(null, null, null, graph);\n  }\n\n  // ### `getQuads` returns an array of quads matching a pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  getQuads(subject, predicate, object, graph) {\n    return [...this.readQuads(subject, predicate, object, graph)];\n  }\n\n  // ### `readQuads` returns an generator of quads matching a pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  *readQuads(subject, predicate, object, graph) {\n    // Convert terms to internal string representation\n    subject = subject && termToId(subject);\n    predicate = predicate && termToId(predicate);\n    object = object && termToId(object);\n    graph = graph && termToId(graph);\n\n    const graphs = this._getGraphs(graph), ids = this._ids;\n    let content, subjectId, predicateId, objectId;\n\n    // Translate IRIs to internal index keys.\n    if (isString(subject)   && !(subjectId   = ids[subject])   ||\n        isString(predicate) && !(predicateId = ids[predicate]) ||\n        isString(object)    && !(objectId    = ids[object]))\n      return;\n\n    for (const graphId in graphs) {\n      // Only if the specified graph contains triples, there can be results\n      if (content = graphs[graphId]) {\n        // Choose the optimal index, based on what fields are present\n        if (subjectId) {\n          if (objectId)\n            // If subject and object are given, the object index will be the fastest\n            yield* this._findInIndex(content.objects, objectId, subjectId, predicateId,\n                              'object', 'subject', 'predicate', graphId, null, true);\n          else\n            // If only subject and possibly predicate are given, the subject index will be the fastest\n            yield* this._findInIndex(content.subjects, subjectId, predicateId, null,\n                              'subject', 'predicate', 'object', graphId, null, true);\n        }\n        else if (predicateId)\n          // If only predicate and possibly object are given, the predicate index will be the fastest\n          yield* this._findInIndex(content.predicates, predicateId, objectId, null,\n                            'predicate', 'object', 'subject', graphId, null, true);\n        else if (objectId)\n          // If only object is given, the object index will be the fastest\n          yield* this._findInIndex(content.objects, objectId, null, null,\n                            'object', 'subject', 'predicate', graphId, null, true);\n        else\n          // If nothing is given, iterate subjects and predicates first\n          yield* this._findInIndex(content.subjects, null, null, null,\n                            'subject', 'predicate', 'object', graphId, null, true);\n      }\n    }\n  }\n\n  // ### `match` returns a new dataset that is comprised of all quads in the current instance matching the given arguments.\n  // The logic described in Quad Matching is applied for each quad in this dataset to check if it should be included in the output dataset.\n  // Note: This method always returns a new DatasetCore, even if that dataset contains no quads.\n  // Note: Since a DatasetCore is an unordered set, the order of the quads within the returned sequence is arbitrary.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  // For backwards compatibility, the object return also implements the Readable stream interface.\n  match(subject, predicate, object, graph) {\n    return new DatasetCoreAndReadableStream(this, subject, predicate, object, graph);\n  }\n\n  // ### `countQuads` returns the number of quads matching a pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  countQuads(subject, predicate, object, graph) {\n    // Convert terms to internal string representation\n    subject = subject && termToId(subject);\n    predicate = predicate && termToId(predicate);\n    object = object && termToId(object);\n    graph = graph && termToId(graph);\n\n    const graphs = this._getGraphs(graph), ids = this._ids;\n    let count = 0, content, subjectId, predicateId, objectId;\n\n    // Translate IRIs to internal index keys.\n    if (isString(subject)   && !(subjectId   = ids[subject])   ||\n        isString(predicate) && !(predicateId = ids[predicate]) ||\n        isString(object)    && !(objectId    = ids[object]))\n      return 0;\n\n    for (const graphId in graphs) {\n      // Only if the specified graph contains triples, there can be results\n      if (content = graphs[graphId]) {\n        // Choose the optimal index, based on what fields are present\n        if (subject) {\n          if (object)\n            // If subject and object are given, the object index will be the fastest\n            count += this._countInIndex(content.objects, objectId, subjectId, predicateId);\n          else\n            // If only subject and possibly predicate are given, the subject index will be the fastest\n            count += this._countInIndex(content.subjects, subjectId, predicateId, objectId);\n        }\n        else if (predicate) {\n          // If only predicate and possibly object are given, the predicate index will be the fastest\n          count += this._countInIndex(content.predicates, predicateId, objectId, subjectId);\n        }\n        else {\n          // If only object is possibly given, the object index will be the fastest\n          count += this._countInIndex(content.objects, objectId, subjectId, predicateId);\n        }\n      }\n    }\n    return count;\n  }\n\n  // ### `forEach` executes the callback on all quads.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  forEach(callback, subject, predicate, object, graph) {\n    this.some(quad => {\n      callback(quad);\n      return false;\n    }, subject, predicate, object, graph);\n  }\n\n  // ### `every` executes the callback on all quads,\n  // and returns `true` if it returns truthy for all them.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  every(callback, subject, predicate, object, graph) {\n    let some = false;\n    const every = !this.some(quad => {\n      some = true;\n      return !callback(quad);\n    }, subject, predicate, object, graph);\n    return some && every;\n  }\n\n  // ### `some` executes the callback on all quads,\n  // and returns `true` if it returns truthy for any of them.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  some(callback, subject, predicate, object, graph) {\n    for (const quad of this.readQuads(subject, predicate, object, graph))\n      if (callback(quad))\n        return true;\n    return false;\n  }\n\n  // ### `getSubjects` returns all subjects that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  getSubjects(predicate, object, graph) {\n    const results = [];\n    this.forSubjects(s => { results.push(s); }, predicate, object, graph);\n    return results;\n  }\n\n  // ### `forSubjects` executes the callback on all subjects that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  forSubjects(callback, predicate, object, graph) {\n    // Convert terms to internal string representation\n    predicate = predicate && termToId(predicate);\n    object = object && termToId(object);\n    graph = graph && termToId(graph);\n\n    const ids = this._ids, graphs = this._getGraphs(graph);\n    let content, predicateId, objectId;\n    callback = this._uniqueEntities(callback);\n\n    // Translate IRIs to internal index keys.\n    if (isString(predicate) && !(predicateId = ids[predicate]) ||\n        isString(object)    && !(objectId    = ids[object]))\n      return;\n\n    for (graph in graphs) {\n      // Only if the specified graph contains triples, there can be results\n      if (content = graphs[graph]) {\n        // Choose optimal index based on which fields are wildcards\n        if (predicateId) {\n          if (objectId)\n            // If predicate and object are given, the POS index is best.\n            this._loopBy2Keys(content.predicates, predicateId, objectId, callback);\n          else\n            // If only predicate is given, the SPO index is best.\n            this._loopByKey1(content.subjects, predicateId, callback);\n        }\n        else if (objectId)\n          // If only object is given, the OSP index is best.\n          this._loopByKey0(content.objects, objectId, callback);\n        else\n          // If no params given, iterate all the subjects\n          this._loop(content.subjects, callback);\n      }\n    }\n  }\n\n  // ### `getPredicates` returns all predicates that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  getPredicates(subject, object, graph) {\n    const results = [];\n    this.forPredicates(p => { results.push(p); }, subject, object, graph);\n    return results;\n  }\n\n  // ### `forPredicates` executes the callback on all predicates that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  forPredicates(callback, subject, object, graph) {\n    // Convert terms to internal string representation\n    subject = subject && termToId(subject);\n    object = object && termToId(object);\n    graph = graph && termToId(graph);\n\n    const ids = this._ids, graphs = this._getGraphs(graph);\n    let content, subjectId, objectId;\n    callback = this._uniqueEntities(callback);\n\n    // Translate IRIs to internal index keys.\n    if (isString(subject) && !(subjectId = ids[subject]) ||\n        isString(object)  && !(objectId  = ids[object]))\n      return;\n\n    for (graph in graphs) {\n      // Only if the specified graph contains triples, there can be results\n      if (content = graphs[graph]) {\n        // Choose optimal index based on which fields are wildcards\n        if (subjectId) {\n          if (objectId)\n            // If subject and object are given, the OSP index is best.\n            this._loopBy2Keys(content.objects, objectId, subjectId, callback);\n          else\n            // If only subject is given, the SPO index is best.\n            this._loopByKey0(content.subjects, subjectId, callback);\n        }\n        else if (objectId)\n          // If only object is given, the POS index is best.\n          this._loopByKey1(content.predicates, objectId, callback);\n        else\n          // If no params given, iterate all the predicates.\n          this._loop(content.predicates, callback);\n      }\n    }\n  }\n\n  // ### `getObjects` returns all objects that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  getObjects(subject, predicate, graph) {\n    const results = [];\n    this.forObjects(o => { results.push(o); }, subject, predicate, graph);\n    return results;\n  }\n\n  // ### `forObjects` executes the callback on all objects that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  forObjects(callback, subject, predicate, graph) {\n    // Convert terms to internal string representation\n    subject = subject && termToId(subject);\n    predicate = predicate && termToId(predicate);\n    graph = graph && termToId(graph);\n\n    const ids = this._ids, graphs = this._getGraphs(graph);\n    let content, subjectId, predicateId;\n    callback = this._uniqueEntities(callback);\n\n    // Translate IRIs to internal index keys.\n    if (isString(subject)   && !(subjectId   = ids[subject]) ||\n        isString(predicate) && !(predicateId = ids[predicate]))\n      return;\n\n    for (graph in graphs) {\n      // Only if the specified graph contains triples, there can be results\n      if (content = graphs[graph]) {\n        // Choose optimal index based on which fields are wildcards\n        if (subjectId) {\n          if (predicateId)\n            // If subject and predicate are given, the SPO index is best.\n            this._loopBy2Keys(content.subjects, subjectId, predicateId, callback);\n          else\n            // If only subject is given, the OSP index is best.\n            this._loopByKey1(content.objects, subjectId, callback);\n        }\n        else if (predicateId)\n          // If only predicate is given, the POS index is best.\n          this._loopByKey0(content.predicates, predicateId, callback);\n        else\n          // If no params given, iterate all the objects.\n          this._loop(content.objects, callback);\n      }\n    }\n  }\n\n  // ### `getGraphs` returns all graphs that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  getGraphs(subject, predicate, object) {\n    const results = [];\n    this.forGraphs(g => { results.push(g); }, subject, predicate, object);\n    return results;\n  }\n\n  // ### `forGraphs` executes the callback on all graphs that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  forGraphs(callback, subject, predicate, object) {\n    for (const graph in this._graphs) {\n      this.some(quad => {\n        callback(quad.graph);\n        return true; // Halt iteration of some()\n      }, subject, predicate, object, graph);\n    }\n  }\n\n  // ### `createBlankNode` creates a new blank node, returning its name\n  createBlankNode(suggestedName) {\n    let name, index;\n    // Generate a name based on the suggested name\n    if (suggestedName) {\n      name = suggestedName = `_:${suggestedName}`, index = 1;\n      while (this._ids[name])\n        name = suggestedName + index++;\n    }\n    // Generate a generic blank node name\n    else {\n      do { name = `_:b${this._blankNodeIndex++}`; }\n      while (this._ids[name]);\n    }\n    // Add the blank node to the entities, avoiding the generation of duplicates\n    this._ids[name] = ++this._id;\n    this._entities[this._id] = name;\n    return this._factory.blankNode(name.substr(2));\n  }\n\n  // ### `extractLists` finds and removes all list triples\n  // and returns the items per list.\n  extractLists({ remove = false, ignoreErrors = false } = {}) {\n    const lists = {}; // has scalar keys so could be a simple Object\n    const onError = ignoreErrors ? (() => true) :\n                  ((node, message) => { throw new Error(`${node.value} ${message}`); });\n\n    // Traverse each list from its tail\n    const tails = this.getQuads(null, namespaces.rdf.rest, namespaces.rdf.nil, null);\n    const toRemove = remove ? [...tails] : [];\n    tails.forEach(tailQuad => {\n      const items = [];             // the members found as objects of rdf:first quads\n      let malformed = false;      // signals whether the current list is malformed\n      let head;                   // the head of the list (_:b1 in above example)\n      let headPos;                // set to subject or object when head is set\n      const graph = tailQuad.graph; // make sure list is in exactly one graph\n\n      // Traverse the list from tail to end\n      let current = tailQuad.subject;\n      while (current && !malformed) {\n        const objectQuads = this.getQuads(null, null, current, null);\n        const subjectQuads = this.getQuads(current, null, null, null);\n        let quad, first = null, rest = null, parent = null;\n\n        // Find the first and rest of this list node\n        for (let i = 0; i < subjectQuads.length && !malformed; i++) {\n          quad = subjectQuads[i];\n          if (!quad.graph.equals(graph))\n            malformed = onError(current, 'not confined to single graph');\n          else if (head)\n            malformed = onError(current, 'has non-list arcs out');\n\n          // one rdf:first\n          else if (quad.predicate.value === namespaces.rdf.first) {\n            if (first)\n              malformed = onError(current, 'has multiple rdf:first arcs');\n            else\n              toRemove.push(first = quad);\n          }\n\n          // one rdf:rest\n          else if (quad.predicate.value === namespaces.rdf.rest) {\n            if (rest)\n              malformed = onError(current, 'has multiple rdf:rest arcs');\n            else\n              toRemove.push(rest = quad);\n          }\n\n          // alien triple\n          else if (objectQuads.length)\n            malformed = onError(current, 'can\\'t be subject and object');\n          else {\n            head = quad; // e.g. { (1 2 3) :p :o }\n            headPos = 'subject';\n          }\n        }\n\n        // { :s :p (1 2) } arrives here with no head\n        // { (1 2) :p :o } arrives here with head set to the list.\n        for (let i = 0; i < objectQuads.length && !malformed; ++i) {\n          quad = objectQuads[i];\n          if (head)\n            malformed = onError(current, 'can\\'t have coreferences');\n          // one rdf:rest\n          else if (quad.predicate.value === namespaces.rdf.rest) {\n            if (parent)\n              malformed = onError(current, 'has incoming rdf:rest arcs');\n            else\n              parent = quad;\n          }\n          else {\n            head = quad; // e.g. { :s :p (1 2) }\n            headPos = 'object';\n          }\n        }\n\n        // Store the list item and continue with parent\n        if (!first)\n          malformed = onError(current, 'has no list head');\n        else\n          items.unshift(first.object);\n        current = parent && parent.subject;\n      }\n\n      // Don't remove any quads if the list is malformed\n      if (malformed)\n        remove = false;\n      // Store the list under the value of its head\n      else if (head)\n        lists[head[headPos].value] = items;\n    });\n\n    // Remove list quads if requested\n    if (remove)\n      this.removeQuads(toRemove);\n    return lists;\n  }\n\n  // ### Store is an iterable.\n  // Can be used where iterables are expected: for...of loops, array spread operator,\n  // `yield*`, and destructuring assignment (order is not guaranteed).\n  *[Symbol.iterator]() {\n    yield* this.readQuads();\n  }\n}\n\n// Determines whether the argument is a string\nfunction isString(s) {\n  return typeof s === 'string' || s instanceof String;\n}\n\n/**\n * A class that implements both DatasetCore and Readable.\n */\nclass DatasetCoreAndReadableStream extends Readable {\n  constructor(n3Store, subject, predicate, object, graph) {\n    super({ objectMode: true });\n    Object.assign(this, { n3Store, subject, predicate, object, graph });\n  }\n\n  get filtered() {\n    if (!this._filtered) {\n      const { n3Store, graph, object, predicate, subject } = this;\n      const quads = n3Store.getQuads(subject, predicate, object, graph);\n      this._filtered = new N3Store(quads, { factory: n3Store._factory });\n    }\n    return this._filtered;\n  }\n  get size() {\n    return this.filtered.size;\n  }\n\n  _read() {\n    for (const quad of this)\n      this.push(quad);\n    this.push(null);\n  }\n\n  add(quad) {\n    return this.filtered.add(quad);\n  }\n\n  delete(quad) {\n    return this.filtered.delete(quad);\n  }\n\n  has(quad) {\n    return this.filtered.has(quad);\n  }\n\n  match(subject, predicate, object, graph) {\n    return new DatasetCoreAndReadableStream(this.filtered, subject, predicate, object, graph);\n  }\n\n  *[Symbol.iterator]() {\n    yield* this._filtered || this.n3Store.readQuads(this.subject, this.predicate, this.object, this.graph);\n  }\n}\n","// **N3Writer** writes N3 documents.\nimport namespaces from './IRIs';\nimport { default as N3DataFactory, Term } from './N3DataFactory';\nimport { isDefaultGraph } from './N3Util';\n\nconst DEFAULTGRAPH = N3DataFactory.defaultGraph();\n\nconst { rdf, xsd } = namespaces;\n\n// Characters in literals that require escaping\nconst escape    = /[\"\\\\\\t\\n\\r\\b\\f\\u0000-\\u0019\\ud800-\\udbff]/,\n    escapeAll = /[\"\\\\\\t\\n\\r\\b\\f\\u0000-\\u0019]|[\\ud800-\\udbff][\\udc00-\\udfff]/g,\n    escapedCharacters = {\n      '\\\\': '\\\\\\\\', '\"': '\\\\\"', '\\t': '\\\\t',\n      '\\n': '\\\\n', '\\r': '\\\\r', '\\b': '\\\\b', '\\f': '\\\\f',\n    };\n\n// ## Placeholder class to represent already pretty-printed terms\nclass SerializedTerm extends Term {\n  // Pretty-printed nodes are not equal to any other node\n  // (e.g., [] does not equal [])\n  equals() {\n    return false;\n  }\n}\n\n// ## Constructor\nexport default class N3Writer {\n  constructor(outputStream, options) {\n    // ### `_prefixRegex` matches a prefixed name or IRI that begins with one of the added prefixes\n    this._prefixRegex = /$0^/;\n\n    // Shift arguments if the first argument is not a stream\n    if (outputStream && typeof outputStream.write !== 'function')\n      options = outputStream, outputStream = null;\n    options = options || {};\n    this._lists = options.lists;\n\n    // If no output stream given, send the output as string through the end callback\n    if (!outputStream) {\n      let output = '';\n      this._outputStream = {\n        write(chunk, encoding, done) { output += chunk; done && done(); },\n        end: done => { done && done(null, output); },\n      };\n      this._endStream = true;\n    }\n    else {\n      this._outputStream = outputStream;\n      this._endStream = options.end === undefined ? true : !!options.end;\n    }\n\n    // Initialize writer, depending on the format\n    this._subject = null;\n    if (!(/triple|quad/i).test(options.format)) {\n      this._lineMode = false;\n      this._graph = DEFAULTGRAPH;\n      this._prefixIRIs = Object.create(null);\n      options.prefixes && this.addPrefixes(options.prefixes);\n      if (options.baseIRI) {\n        this._baseMatcher = new RegExp(`^${escapeRegex(options.baseIRI)\n            }${options.baseIRI.endsWith('/') ? '' : '[#?]'}`);\n        this._baseLength = options.baseIRI.length;\n      }\n    }\n    else {\n      this._lineMode = true;\n      this._writeQuad = this._writeQuadLine;\n    }\n  }\n\n  // ## Private methods\n\n  // ### Whether the current graph is the default graph\n  get _inDefaultGraph() {\n    return DEFAULTGRAPH.equals(this._graph);\n  }\n\n  // ### `_write` writes the argument to the output stream\n  _write(string, callback) {\n    this._outputStream.write(string, 'utf8', callback);\n  }\n\n  // ### `_writeQuad` writes the quad to the output stream\n  _writeQuad(subject, predicate, object, graph, done) {\n    try {\n      // Write the graph's label if it has changed\n      if (!graph.equals(this._graph)) {\n        // Close the previous graph and start the new one\n        this._write((this._subject === null ? '' : (this._inDefaultGraph ? '.\\n' : '\\n}\\n')) +\n                    (DEFAULTGRAPH.equals(graph) ? '' : `${this._encodeIriOrBlank(graph)} {\\n`));\n        this._graph = graph;\n        this._subject = null;\n      }\n      // Don't repeat the subject if it's the same\n      if (subject.equals(this._subject)) {\n        // Don't repeat the predicate if it's the same\n        if (predicate.equals(this._predicate))\n          this._write(`, ${this._encodeObject(object)}`, done);\n        // Same subject, different predicate\n        else\n          this._write(`;\\n    ${\n                      this._encodePredicate(this._predicate = predicate)} ${\n                      this._encodeObject(object)}`, done);\n      }\n      // Different subject; write the whole quad\n      else\n        this._write(`${(this._subject === null ? '' : '.\\n') +\n                    this._encodeSubject(this._subject = subject)} ${\n                    this._encodePredicate(this._predicate = predicate)} ${\n                    this._encodeObject(object)}`, done);\n    }\n    catch (error) { done && done(error); }\n  }\n\n  // ### `_writeQuadLine` writes the quad to the output stream as a single line\n  _writeQuadLine(subject, predicate, object, graph, done) {\n    // Write the quad without prefixes\n    delete this._prefixMatch;\n    this._write(this.quadToString(subject, predicate, object, graph), done);\n  }\n\n  // ### `quadToString` serializes a quad as a string\n  quadToString(subject, predicate, object, graph) {\n    return  `${this._encodeSubject(subject)} ${\n            this._encodeIriOrBlank(predicate)} ${\n            this._encodeObject(object)\n            }${graph && graph.value ? ` ${this._encodeIriOrBlank(graph)} .\\n` : ' .\\n'}`;\n  }\n\n  // ### `quadsToString` serializes an array of quads as a string\n  quadsToString(quads) {\n    return quads.map(t => {\n      return this.quadToString(t.subject, t.predicate, t.object, t.graph);\n    }).join('');\n  }\n\n  // ### `_encodeSubject` represents a subject\n  _encodeSubject(entity) {\n    return entity.termType === 'Quad' ?\n      this._encodeQuad(entity) : this._encodeIriOrBlank(entity);\n  }\n\n  // ### `_encodeIriOrBlank` represents an IRI or blank node\n  _encodeIriOrBlank(entity) {\n    // A blank node or list is represented as-is\n    if (entity.termType !== 'NamedNode') {\n      // If it is a list head, pretty-print it\n      if (this._lists && (entity.value in this._lists))\n        entity = this.list(this._lists[entity.value]);\n      return 'id' in entity ? entity.id : `_:${entity.value}`;\n    }\n    let iri = entity.value;\n    // Use relative IRIs if requested and possible\n    if (this._baseMatcher && this._baseMatcher.test(iri))\n      iri = iri.substr(this._baseLength);\n    // Escape special characters\n    if (escape.test(iri))\n      iri = iri.replace(escapeAll, characterReplacer);\n    // Try to represent the IRI as prefixed name\n    const prefixMatch = this._prefixRegex.exec(iri);\n    return !prefixMatch ? `<${iri}>` :\n           (!prefixMatch[1] ? iri : this._prefixIRIs[prefixMatch[1]] + prefixMatch[2]);\n  }\n\n  // ### `_encodeLiteral` represents a literal\n  _encodeLiteral(literal) {\n    // Escape special characters\n    let value = literal.value;\n    if (escape.test(value))\n      value = value.replace(escapeAll, characterReplacer);\n\n    // Write a language-tagged literal\n    if (literal.language)\n      return `\"${value}\"@${literal.language}`;\n\n    // Write dedicated literals per data type\n    if (this._lineMode) {\n      // Only abbreviate strings in N-Triples or N-Quads\n      if (literal.datatype.value === xsd.string)\n        return `\"${value}\"`;\n    }\n    else {\n      // Use common datatype abbreviations in Turtle or TriG\n      switch (literal.datatype.value) {\n      case xsd.string:\n        return `\"${value}\"`;\n      case xsd.boolean:\n        if (value === 'true' || value === 'false')\n          return value;\n        break;\n      case xsd.integer:\n        if (/^[+-]?\\d+$/.test(value))\n          return value;\n        break;\n      case xsd.decimal:\n        if (/^[+-]?\\d*\\.\\d+$/.test(value))\n          return value;\n        break;\n      case xsd.double:\n        if (/^[+-]?(?:\\d+\\.\\d*|\\.?\\d+)[eE][+-]?\\d+$/.test(value))\n          return value;\n        break;\n      }\n    }\n\n    // Write a regular datatyped literal\n    return `\"${value}\"^^${this._encodeIriOrBlank(literal.datatype)}`;\n  }\n\n  // ### `_encodePredicate` represents a predicate\n  _encodePredicate(predicate) {\n    return predicate.value === rdf.type ? 'a' : this._encodeIriOrBlank(predicate);\n  }\n\n  // ### `_encodeObject` represents an object\n  _encodeObject(object) {\n    switch (object.termType) {\n    case 'Quad':\n      return this._encodeQuad(object);\n    case 'Literal':\n      return this._encodeLiteral(object);\n    default:\n      return this._encodeIriOrBlank(object);\n    }\n  }\n\n  // ### `_encodeQuad` encodes an RDF* quad\n  _encodeQuad({ subject, predicate, object, graph }) {\n    return `<<${\n      this._encodeSubject(subject)} ${\n      this._encodePredicate(predicate)} ${\n      this._encodeObject(object)}${\n      isDefaultGraph(graph) ? '' : ` ${this._encodeIriOrBlank(graph)}`}>>`;\n  }\n\n  // ### `_blockedWrite` replaces `_write` after the writer has been closed\n  _blockedWrite() {\n    throw new Error('Cannot write because the writer has been closed.');\n  }\n\n  // ### `addQuad` adds the quad to the output stream\n  addQuad(subject, predicate, object, graph, done) {\n    // The quad was given as an object, so shift parameters\n    if (object === undefined)\n      this._writeQuad(subject.subject, subject.predicate, subject.object, subject.graph, predicate);\n    // The optional `graph` parameter was not provided\n    else if (typeof graph === 'function')\n      this._writeQuad(subject, predicate, object, DEFAULTGRAPH, graph);\n    // The `graph` parameter was provided\n    else\n      this._writeQuad(subject, predicate, object, graph || DEFAULTGRAPH, done);\n  }\n\n  // ### `addQuads` adds the quads to the output stream\n  addQuads(quads) {\n    for (let i = 0; i < quads.length; i++)\n      this.addQuad(quads[i]);\n  }\n\n  // ### `addPrefix` adds the prefix to the output stream\n  addPrefix(prefix, iri, done) {\n    const prefixes = {};\n    prefixes[prefix] = iri;\n    this.addPrefixes(prefixes, done);\n  }\n\n  // ### `addPrefixes` adds the prefixes to the output stream\n  addPrefixes(prefixes, done) {\n    // Ignore prefixes if not supported by the serialization\n    if (!this._prefixIRIs)\n      return done && done();\n\n    // Write all new prefixes\n    let hasPrefixes = false;\n    for (let prefix in prefixes) {\n      let iri = prefixes[prefix];\n      if (typeof iri !== 'string')\n        iri = iri.value;\n      hasPrefixes = true;\n      // Finish a possible pending quad\n      if (this._subject !== null) {\n        this._write(this._inDefaultGraph ? '.\\n' : '\\n}\\n');\n        this._subject = null, this._graph = '';\n      }\n      // Store and write the prefix\n      this._prefixIRIs[iri] = (prefix += ':');\n      this._write(`@prefix ${prefix} <${iri}>.\\n`);\n    }\n    // Recreate the prefix matcher\n    if (hasPrefixes) {\n      let IRIlist = '', prefixList = '';\n      for (const prefixIRI in this._prefixIRIs) {\n        IRIlist += IRIlist ? `|${prefixIRI}` : prefixIRI;\n        prefixList += (prefixList ? '|' : '') + this._prefixIRIs[prefixIRI];\n      }\n      IRIlist = escapeRegex(IRIlist, /[\\]\\/\\(\\)\\*\\+\\?\\.\\\\\\$]/g, '\\\\$&');\n      this._prefixRegex = new RegExp(`^(?:${prefixList})[^\\/]*$|` +\n                                     `^(${IRIlist})([a-zA-Z][\\\\-_a-zA-Z0-9]*)$`);\n    }\n    // End a prefix block with a newline\n    this._write(hasPrefixes ? '\\n' : '', done);\n  }\n\n  // ### `blank` creates a blank node with the given content\n  blank(predicate, object) {\n    let children = predicate, child, length;\n    // Empty blank node\n    if (predicate === undefined)\n      children = [];\n    // Blank node passed as blank(Term(\"predicate\"), Term(\"object\"))\n    else if (predicate.termType)\n      children = [{ predicate: predicate, object: object }];\n    // Blank node passed as blank({ predicate: predicate, object: object })\n    else if (!('length' in predicate))\n      children = [predicate];\n\n    switch (length = children.length) {\n    // Generate an empty blank node\n    case 0:\n      return new SerializedTerm('[]');\n    // Generate a non-nested one-triple blank node\n    case 1:\n      child = children[0];\n      if (!(child.object instanceof SerializedTerm))\n        return new SerializedTerm(`[ ${this._encodePredicate(child.predicate)} ${\n                                  this._encodeObject(child.object)} ]`);\n    // Generate a multi-triple or nested blank node\n    default:\n      let contents = '[';\n      // Write all triples in order\n      for (let i = 0; i < length; i++) {\n        child = children[i];\n        // Write only the object is the predicate is the same as the previous\n        if (child.predicate.equals(predicate))\n          contents += `, ${this._encodeObject(child.object)}`;\n        // Otherwise, write the predicate and the object\n        else {\n          contents += `${(i ? ';\\n  ' : '\\n  ') +\n                      this._encodePredicate(child.predicate)} ${\n                      this._encodeObject(child.object)}`;\n          predicate = child.predicate;\n        }\n      }\n      return new SerializedTerm(`${contents}\\n]`);\n    }\n  }\n\n  // ### `list` creates a list node with the given content\n  list(elements) {\n    const length = elements && elements.length || 0, contents = new Array(length);\n    for (let i = 0; i < length; i++)\n      contents[i] = this._encodeObject(elements[i]);\n    return new SerializedTerm(`(${contents.join(' ')})`);\n  }\n\n  // ### `end` signals the end of the output stream\n  end(done) {\n    // Finish a possible pending quad\n    if (this._subject !== null) {\n      this._write(this._inDefaultGraph ? '.\\n' : '\\n}\\n');\n      this._subject = null;\n    }\n    // Disallow further writing\n    this._write = this._blockedWrite;\n\n    // Try to end the underlying stream, ensuring done is called exactly one time\n    let singleDone = done && ((error, result) => { singleDone = null, done(error, result); });\n    if (this._endStream) {\n      try { return this._outputStream.end(singleDone); }\n      catch (error) { /* error closing stream */ }\n    }\n    singleDone && singleDone();\n  }\n}\n\n// Replaces a character by its escaped version\nfunction characterReplacer(character) {\n  // Replace a single character by its escaped version\n  let result = escapedCharacters[character];\n  if (result === undefined) {\n    // Replace a single character with its 4-bit unicode escape sequence\n    if (character.length === 1) {\n      result = character.charCodeAt(0).toString(16);\n      result = '\\\\u0000'.substr(0, 6 - result.length) + result;\n    }\n    // Replace a surrogate pair with its 8-bit unicode escape sequence\n    else {\n      result = ((character.charCodeAt(0) - 0xD800) * 0x400 +\n                 character.charCodeAt(1) + 0x2400).toString(16);\n      result = '\\\\U00000000'.substr(0, 10 - result.length) + result;\n    }\n  }\n  return result;\n}\n\nfunction escapeRegex(regex) {\n  return regex.replace(/[\\]\\/\\(\\)\\*\\+\\?\\.\\\\\\$]/g, '\\\\$&');\n}\n","const namespaces = {\n    geo: 'http://www.w3.org/2003/01/geo/wgs84_pos#',\n    schema: 'http://schema.org/',\n    rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',\n    rdfs: 'http://www.w3.org/2000/01/rdf-schema#',\n    vcard: 'http://www.w3.org/2006/vcard/ns#',\n    owl: 'http://www.w3.org/2002/07/owl#',\n    time: 'http://www.w3.org/2006/time#',\n    dcterms: 'http://purl.org/dc/terms/',\n    dcmi: 'http://purl.org/dc/terms/',\n    dqm: 'http://purl.org/dqm-vocabulary/v1/dqm#',\n    foaf: 'http://xmlns.com/foaf/0.1/',\n    qudt: 'http://qudt.org/schema/qudt/',\n    qudt_unit: 'http://qudt.org/vocab/unit/',\n    quantitykind: 'http://qudt.org/vocab/quantitykind/',\n    sosa: 'http://www.w3.org/ns/sosa/',\n    ssn: 'http://www.w3.org/ns/ssn/',\n    ssns: 'http://www.w3.org/ns/ssn/systems/',\n    openhps: 'http://openhps.org/terms#',\n    ogc: 'http://www.opengis.net/ont/geosparql#',\n};\nconst mirrors = {\n    'http://www.opengis.net/ont/geosparql#': 'https://cdn.jsdelivr.net/gh/opengeospatial/ogc-geosparql@master/1.1/geo.ttl',\n    'http://schema.org/': 'https://schema.org/version/latest/schemaorg-all-http.ttl',\n    'http://purl.org/dc/terms/': 'https://www.dublincore.org/specifications/dublin-core/dcmi-terms/dublin_core_terms.nt',\n    'http://purl.org/dqm-vocabulary/v1/dqm#': 'http://semwebquality.org/dqm-vocabulary/v1/dqm.owl',\n    'http://openhps.org/terms#': 'https://cdn.jsdelivr.net/gh/OpenHPS/openhps-rdf@master/ontology/v1/openhps.ttl',\n};\nexport { namespaces, mirrors };\n//# sourceMappingURL=namespaces.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar _a;\nimport { DataSerializer, } from '@openhps/core';\nimport { InternalRDFSerializer } from './InternalRDFSerializer';\nimport { InternalRDFDeserializer } from './InternalRDFDeserializer';\nimport * as N3 from 'n3';\nimport { namespaces } from '../namespaces';\nimport { rdf } from '../vocab';\nexport class RDFSerializer extends DataSerializer {\n    static get options() {\n        return {\n            serializer: new InternalRDFSerializer(),\n            deserializer: new InternalRDFDeserializer(),\n        };\n    }\n    static registerRDFType(type) {\n        const meta = this.getMetadata(type);\n        if (!meta.options || !meta.options.rdf) {\n            return;\n        }\n        const rdfOptions = meta.options.rdf;\n        if (rdfOptions.predicates) {\n            Object.entries(rdfOptions.predicates)\n                .filter(([k, _]) => k === rdf.type)\n                .map(([_, v]) => v.flat())\n                .flat()\n                .forEach((typeIri) => {\n                var _b;\n                const results = (_b = this.knownRDFTypes.get(typeIri)) !== null && _b !== void 0 ? _b : [];\n                results.push(type.name);\n                this.knownRDFTypes.set(typeIri, results);\n            });\n        }\n    }\n    static serialize(data, baseUri) {\n        return super.serialize(data, Object.assign({ rdf: {\n                baseUri,\n            } }, this.options));\n    }\n    static deserializeFromStore(subject, store) {\n        function quadsToThing(subject, store) {\n            return {\n                termType: subject.termType,\n                value: subject.value,\n                predicates: Object.assign({}, store\n                    .getPredicates(subject, null, null)\n                    .map((predicate) => {\n                    return {\n                        [predicate.value]: store.getObjects(subject, predicate, null).map((object) => {\n                            if (object.constructor.name === 'BlankNode' ||\n                                object.constructor.name === 'NamedNode') {\n                                return quadsToThing(object, store);\n                            }\n                            else {\n                                return object;\n                            }\n                        }),\n                    };\n                })\n                    .reduce((a, b) => (Object.assign(Object.assign({}, a), b)), {})),\n            };\n        }\n        const thing = quadsToThing(subject, store);\n        return this.deserialize(thing);\n    }\n    static serializeToSubjects(data, baseUri) {\n        const quads = RDFSerializer.serializeToQuads(data, baseUri);\n        const store = new N3.Store(quads);\n        const quadSubjects = store.getSubjects(null, null, null);\n        function serializePredicates(quadSubject) {\n            const quadPredicates = store.getPredicates(quadSubject, null, null);\n            return quadPredicates\n                .map((quadPredicate) => {\n                const quadObjects = store.getObjects(quadSubject, quadPredicate, null);\n                const literals = quadObjects\n                    .filter((obj) => obj instanceof N3.Literal)\n                    .filter((obj) => obj.language === '')\n                    .map((obj) => ({ [obj.datatype.value]: [obj.value] }))\n                    .reduce((a, b) => (Object.assign(Object.assign({}, a), b)), {});\n                const langStrings = quadObjects\n                    .filter((obj) => obj instanceof N3.Literal)\n                    .filter((obj) => obj.language !== '')\n                    .map((obj) => ({ [obj.language]: [obj.value] }))\n                    .reduce((a, b) => (Object.assign(Object.assign({}, a), b)), {});\n                const namedNodes = quadObjects\n                    .filter((obj) => obj instanceof N3.NamedNode)\n                    .map((obj) => obj.value);\n                const blankNodes = quadObjects\n                    .filter((obj) => obj instanceof N3.BlankNode)\n                    .map((obj) => serializePredicates(N3.DataFactory.blankNode(obj.value)));\n                return {\n                    [quadPredicate.value]: {\n                        namedNodes,\n                        blankNodes,\n                        literals,\n                        langStrings,\n                    },\n                };\n            })\n                .reduce((a, b) => (Object.assign(Object.assign({}, a), b)), {});\n        }\n        const subjects = quadSubjects\n            .filter((quadSubject) => quadSubject instanceof N3.NamedNode)\n            .map((quadSubject) => {\n            return {\n                type: 'Subject',\n                url: quadSubject.value,\n                predicates: serializePredicates(quadSubject),\n            };\n        });\n        return subjects;\n    }\n    static serializeToQuads(data, baseUri) {\n        const thing = data['predicates'] !== undefined ? data : this.serialize(data, baseUri);\n        const subject = thing.termType === 'BlankNode'\n            ? N3.DataFactory.blankNode(thing.value)\n            : N3.DataFactory.namedNode(thing.value);\n        return Object.keys(thing.predicates)\n            .map((predicateIri) => {\n            const predicate = N3.DataFactory.namedNode(predicateIri);\n            return thing.predicates[predicateIri].map((object) => {\n                if (object['predicates'] !== undefined) {\n                    return [\n                        N3.DataFactory.quad(subject, predicate, object),\n                        ...this.serializeToQuads(object),\n                    ];\n                }\n                else {\n                    return [N3.DataFactory.quad(subject, predicate, object)];\n                }\n            });\n        })\n            .flat()\n            .flat();\n    }\n    static stringify(thing, options = {}) {\n        return __awaiter(this, void 0, void 0, function* () {\n            return new Promise((resolve, reject) => {\n                const quads = this.serializeToQuads(thing, options.baseUri);\n                const store = new N3.Store(quads);\n                const prefixes = Object.assign({ xsd: 'http://www.w3.org/2001/XMLSchema#' }, namespaces);\n                const ns = Object.keys(prefixes)\n                    .map((k) => {\n                    return { [prefixes[k]]: k };\n                })\n                    .reduce((a, b) => {\n                    return Object.assign(Object.assign({}, a), b);\n                });\n                const filteredPrefixes = {};\n                quads.map((quad) => {\n                    const usedNamespacesInQuad = [\n                        quad.subject.value,\n                        quad.predicate.value,\n                        quad.object.termType === 'NamedNode'\n                            ? quad.object.termType\n                            : quad.object.termType === 'Literal'\n                                ? quad.object.datatype.value\n                                : quad.object.value,\n                    ];\n                    usedNamespacesInQuad.map((namespace) => {\n                        Object.keys(ns).forEach((n) => {\n                            if (namespace.includes(n)) {\n                                filteredPrefixes[ns[n]] = n;\n                            }\n                        });\n                    });\n                });\n                options.prefixes = Object.assign(Object.assign({}, filteredPrefixes), options.prefixes);\n                const writer = new N3.Writer(options);\n                if (options.prettyPrint) {\n                    store.getSubjects(null, null, null).forEach((subject) => {\n                        if (subject.termType === 'BlankNode') {\n                            return;\n                        }\n                        else {\n                            store.getPredicates(subject, null, null).forEach((predicate) => {\n                                store.getObjects(subject, predicate, null).forEach((object) => {\n                                    if (object.termType === 'BlankNode') {\n                                        writer.addQuad(subject, predicate, this.writeBlankNode(writer, object, store));\n                                    }\n                                    else {\n                                        writer.addQuad(subject, predicate, object);\n                                    }\n                                });\n                            });\n                        }\n                    });\n                }\n                else {\n                    writer.addQuads(quads);\n                }\n                writer.end((err, result) => {\n                    if (err) {\n                        return reject(err);\n                    }\n                    resolve(result);\n                });\n            });\n        });\n    }\n    static writeBlankNode(writer, object, store) {\n        const blankNodePredicates = store.getPredicates(object, null, null);\n        return writer.blank(blankNodePredicates\n            .map((predicate) => {\n            const blankNodeObjects = store.getObjects(object, predicate, null);\n            return blankNodeObjects.map((object) => {\n                if (object.termType === 'BlankNode') {\n                    return {\n                        predicate,\n                        object: this.writeBlankNode(writer, object, store),\n                    };\n                }\n                else {\n                    return {\n                        predicate,\n                        object,\n                    };\n                }\n            });\n        })\n            .flat());\n    }\n    static deserialize(serializedData, dataType) {\n        if (serializedData['predicates'] === undefined) {\n            return super.deserialize(serializedData, dataType);\n        }\n        const deserializer = new InternalRDFDeserializer();\n        const finalType = dataType !== null && dataType !== void 0 ? dataType : deserializer.rdfTypeResolver(serializedData, this.knownTypes, this.knownRDFTypes);\n        if (finalType === Object) {\n            return serializedData;\n        }\n        return deserializer.convertSingleValue(serializedData, this.ensureTypeDescriptor(finalType), this.knownTypes, undefined, undefined, {\n            rdf: {\n                knownTypes: this.knownRDFTypes,\n            },\n        });\n    }\n    static getUriMetadata(dataType) {\n        const metadata = DataSerializer.getMetadata(dataType);\n        const rootMetadata = DataSerializer.getRootMetadata(dataType);\n        const options = metadata.options && metadata.options.rdf\n            ? metadata.options.rdf\n            : rootMetadata.options && rootMetadata.options.rdf\n                ? rootMetadata.options.rdf\n                : undefined;\n        if (!options) {\n            return undefined;\n        }\n        const identifierMember = Array.from(metadata.dataMembers.values()).filter((member) => {\n            return (member &&\n                member.options &&\n                member.options.rdf &&\n                member.options.rdf.identifier);\n        })[0];\n        return identifierMember;\n    }\n    static normalizeUri(dataType, identifier, baseUri) {\n        const identifierMember = this.getUriMetadata(dataType);\n        let uri = undefined;\n        if (identifierMember) {\n            const rdfOptions = identifierMember.options.rdf;\n            uri = rdfOptions.serializer ? rdfOptions.serializer(identifier, dataType) : identifier;\n            uri = uri && !uri.startsWith('http') && baseUri ? baseUri + uri : N3.DataFactory.blankNode(uri).value;\n        }\n        else {\n            return baseUri;\n        }\n    }\n}\n_a = RDFSerializer;\nRDFSerializer.knownRDFTypes = new Map();\n(() => {\n    _a.eventEmitter.on('updateSerializableObject', (_, options) => {\n        if (options && options.rdf && options.rdf.type) {\n            options.rdf.predicates = options.rdf.predicates || {};\n            const types = options.rdf.predicates[rdf.type] || [];\n            types.push(options.rdf.type);\n            options.rdf.predicates[rdf.type] = types;\n        }\n    });\n    _a.eventEmitter.on('registerType', (type) => {\n        RDFSerializer.registerRDFType(type);\n    });\n})();\n//# sourceMappingURL=RDFSerializer.js.map","var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar SerializableNamedNode_1;\nimport { SerializableObject } from '@openhps/core';\nimport * as N3 from 'n3';\nlet SerializableNamedNode = SerializableNamedNode_1 = class SerializableNamedNode extends N3.NamedNode {\n};\nSerializableNamedNode = SerializableNamedNode_1 = __decorate([\n    SerializableObject({\n        rdf: {\n            serializer: (object) => {\n                return {\n                    value: object.value,\n                };\n            },\n            deserializer: (thing) => {\n                return new SerializableNamedNode_1(thing.value);\n            },\n        },\n    })\n], SerializableNamedNode);\nexport { SerializableNamedNode };\n//# sourceMappingURL=SerializableNamedNode.js.map"],"names":["root","factory","exports","module","require","define","amd","self","this","__WEBPACK_EXTERNAL_MODULE__0__","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","i","arr","Arr","_byteLength","curByte","len","revLookup","charCodeAt","fromByteArray","uint8","length","extraBytes","parts","maxChunkLength","len2","push","encodeChunk","lookup","join","Uint8Array","Array","code","Error","indexOf","start","end","num","output","base64","ieee754","customInspectSymbol","Symbol","Buffer","SlowBuffer","alloc","INSPECT_MAX_BYTES","K_MAX_LENGTH","createBuffer","RangeError","buf","Object","setPrototypeOf","prototype","arg","encodingOrOffset","TypeError","allocUnsafe","from","value","string","encoding","isEncoding","actual","write","slice","fromString","ArrayBuffer","isView","arrayView","isInstance","copy","fromArrayBuffer","buffer","byteOffset","fromArrayLike","fromArrayView","SharedArrayBuffer","valueOf","b","obj","isBuffer","checked","undefined","numberIsNaN","type","isArray","data","fromObject","toPrimitive","assertSize","size","array","toString","mustMatch","arguments","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","n","m","bidirectionalIndexOf","val","dir","arrayIndexOf","call","lastIndexOf","indexSize","arrLength","valLength","String","read","readUInt16BE","foundIndex","found","j","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","str","byteArray","asciiToBytes","base64Write","ucs2Write","units","c","hi","lo","utf16leToBytes","Math","min","res","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","apply","decodeCodePointsArray","kMaxLength","TYPED_ARRAY_SUPPORT","proto","foo","e","typedArraySupport","console","error","defineProperty","enumerable","get","poolSize","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","concat","list","pos","set","swap16","swap32","swap64","toLocaleString","equals","inspect","max","replace","trim","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_arr","ret","out","hexSliceLookupTable","bytes","checkOffset","ext","checkInt","wrtBigUInt64LE","checkIntBI","BigInt","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","last","boundsError","readBigUInt64BE","readIntLE","pow","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","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeBigInt64LE","writeBigInt64BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","errors","E","sym","getMessage","Base","NodeError","constructor","super","writable","configurable","name","stack","message","addNumericalSeparator","range","ERR_OUT_OF_RANGE","checkBounds","ERR_INVALID_ARG_TYPE","floor","ERR_BUFFER_OUT_OF_BOUNDS","input","msg","received","isInteger","abs","INVALID_BASE64_RE","Infinity","leadSurrogate","split","base64clean","src","dst","alphabet","table","i16","fn","BufferBigIntNotDefined","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","args","Function","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","NumberIsNaN","isNaN","EventEmitter","init","once","emitter","Promise","resolve","reject","errorListener","err","removeListener","resolver","eventTargetAgnosticAddListener","handler","flags","on","addErrorHandlerIfEventEmitter","_events","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","that","_addListener","prepend","events","existing","warning","create","newListener","emit","unshift","warned","w","count","warn","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","bind","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","addEventListener","wrapListener","removeEventListener","getPrototypeOf","setMaxListeners","getMaxListeners","doError","er","context","listeners","addListener","prependListener","prependOnceListener","position","originalListener","shift","index","pop","spliceOne","off","removeAllListeners","key","keys","rawListeners","eventNames","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","d","s","NaN","rt","log","LN2","ctor","superCtor","super_","TempCtor","codes","createErrorType","_Base","subClass","superClass","arg1","arg2","arg3","__proto__","oneOf","expected","thing","map","determiner","search","this_len","substring","endsWith","objectKeys","Duplex","Readable","Writable","v","method","options","allowHalfOpen","readable","onend","_writableState","ended","process","nextTick","onEndNT","highWaterMark","getBuffer","_readableState","destroyed","PassThrough","Transform","_transform","chunk","cb","ReadableState","EElistenerCount","Stream","OurUint8Array","g","debug","debugUtil","debuglog","StringDecoder","createReadableStreamAsyncIterator","BufferList","destroyImpl","getHighWaterMark","_require$codes","ERR_STREAM_PUSH_AFTER_EOF","ERR_METHOD_NOT_IMPLEMENTED","ERR_STREAM_UNSHIFT_AFTER_END_EVENT","errorOrDestroy","kProxyEvents","stream","isDuplex","objectMode","readableObjectMode","pipes","pipesCount","flowing","endEmitted","reading","sync","needReadable","emittedReadable","readableListening","resumeScheduled","paused","emitClose","autoDestroy","defaultEncoding","awaitDrain","readingMore","decoder","_read","destroy","_destroy","readableAddChunk","addToFront","skipChunkCheck","emitReadable","emitReadable_","onEofChunk","chunkInvalid","_uint8ArrayToBuffer","addChunk","maybeReadMore","_undestroy","undestroy","isPaused","setEncoding","enc","p","head","content","next","clear","MAX_HWM","howMuchToRead","computeNewHighWaterMark","flow","maybeReadMore_","updateReadableListening","resume","nReadingNextTick","resume_","fromList","consume","endReadable","endReadableNT","wState","finished","xs","l","nOrig","doRead","pipe","dest","pipeOpts","endFn","stdout","stderr","unpipe","onunpipe","unpipeInfo","hasUnpiped","onclose","onfinish","ondrain","onerror","ondata","cleanedUp","needDrain","pipeOnDrain","pause","event","dests","splice","ev","wrap","_this","asyncIterator","_fromList","iterable","opts","ERR_MULTIPLE_CALLBACK","ERR_TRANSFORM_ALREADY_TRANSFORMING","ERR_TRANSFORM_WITH_LENGTH_0","afterTransform","ts","_transformState","transforming","writecb","writechunk","rs","needTransform","writeencoding","transform","flush","_flush","prefinish","done","_write","err2","CorkedRequest","entry","finish","corkReq","callback","pendingcb","corkedRequestsFree","onCorkedFinish","WritableState","internalUtil","deprecate","realHasInstance","ERR_STREAM_CANNOT_PIPE","ERR_STREAM_DESTROYED","ERR_STREAM_NULL_VALUES","ERR_STREAM_WRITE_AFTER_END","ERR_UNKNOWN_ENCODING","nop","writableObjectMode","finalCalled","ending","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writelen","onwriteStateUpdate","finishMaybe","errorEmitted","onwriteError","needFinish","bufferedRequest","clearBuffer","afterWrite","lastBufferedRequest","prefinished","bufferedRequestCount","writev","_writev","final","_final","doWrite","onwriteDrain","holder","allBuffers","isBuf","callFinal","need","rState","current","_","hasInstance","object","writeAfterEnd","validChunk","newChunk","decodeChunk","writeOrBuffer","cork","uncork","setDefaultEncoding","endWritable","_Object$setPrototypeO","_defineProperty","kLastResolve","kLastReject","kError","kEnded","kLastPromise","kHandlePromise","kStream","createIterResult","readAndResolve","iter","onReadable","AsyncIteratorPrototype","ReadableStreamAsyncIteratorPrototype","promise","lastPromise","then","wrapForNext","_this2","_Object$create","iterator","enumerableOnly","symbols","filter","getOwnPropertyDescriptor","_defineProperties","props","descriptor","custom","instance","Constructor","_classCallCheck","tail","protoProps","staticProps","hasStrings","_getString","_getBuffer","nb","source","forEach","getOwnPropertyDescriptors","defineProperties","_objectSpread","depth","customInspect","emitErrorAndCloseNT","emitErrorNT","emitCloseNT","readableDestroyed","writableDestroyed","ERR_STREAM_PREMATURE_CLOSE","noop","eos","called","_len","_key","onlegacyfinish","writableEnded","readableEnded","onrequest","req","setHeader","abort","isRequest","ERR_MISSING_ARGS","destroyer","closed","to","popCallback","streams","destroys","reduce","ERR_INVALID_OPT_VALUE","duplexKey","hwm","highWaterMarkFrom","pipeline","copyProps","SafeBuffer","nenc","retried","_normalizeEncoding","normalizeEncoding","text","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","r","utf8CheckExtraBytes","total","utf8CheckIncomplete","config","localStorage","trace","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","definition","o","globalThis","window","prop","hasOwnProperty","toStringTag","RDF","XSD","SWAP","xsd","decimal","boolean","double","integer","rdf","nil","rest","langString","owl","sameAs","forSome","forAll","implies","isDefaultGraph","term","termType","DEFAULTGRAPH","_blankNodeCounter","escapedLiteral","quadId","DataFactory","namedNode","iri","NamedNode","blankNode","BlankNode","variable","Variable","literal","languageOrDataType","Literal","datatype","defaultGraph","quad","triple","Term","id","other","hashCode","language","atPos","datatypeString","dtPos","char","termFromId","endPos","components","exec","unescapeQuotes","termToId","escapeQuotes","subject","predicate","graph","DefaultGraph","Quad","_subject","_predicate","_object","_graph","quoted","dateTime","date","time","anyURI","mergeDeep","assign","isObject","item","InternalRDFSerializer","Serializer","serializationStrategy","Map","serializeLiteral","Boolean","Date","serializeDate","serializeArray","serializeMap","Set","serializeSet","convertSingleValue","sourceObject","typeDescriptor","memberName","memberOptions","serializerOptions","retrievePreserveNull","serializer","serializeObject","hasFriendlyName","errorHandler","metadata","rootMetadata","DataSerializer","identifierMember","dataMembers","values","member","identifier","uri","rdfOptions","startsWith","baseUri","predicates","entries","k","rootMember","predicateIri","elementType","valueType","_a","xsdDatatype","dataTypeNode","iriToNode","dateString","toISOString","direction","Property","Statement","Bag","Seq","Alt","List","CompoundLiteral","HTML","PlainLiteral","XMLLiteral","JSON__workaround","InternalRDFDeserializer","Deserializer","deserializationStrategy","deserializeLiteral","deserializeArray","deserializeMap","deserializeSet","rdfTypeResolver","knownTypes","knownRDFTypes","mappedTypes","flat","deserializer","deserializeObject","expectedSelfType","finalType","targetObject","instantiateType","isInstanceOf","getTime","deserializeDate","N3Store","quads","_size","_graphs","_id","_ids","_entities","_blankNodeIndex","_factory","addQuads","graphs","subjects","graphKey","subjectKey","predicateKey","_addToIndex","index0","key0","key1","key2","index1","index2","existed","_removeFromIndex","name0","name1","name2","graphId","entityKeys","value0","entity0","value1","entity1","_loop","_loopByKey0","_loopByKey1","_loopBy2Keys","_countInIndex","_getGraphs","isString","_uniqueEntities","uniqueIds","add","addQuad","graphItem","objects","freeze","ids","entities","changed","delete","removeQuad","has","subjectOrQuad","readQuads","import","removeQuads","remove","removeMatches","deleteGraph","getQuads","subjectId","predicateId","objectId","_findInIndex","match","DatasetCoreAndReadableStream","countQuads","some","every","getSubjects","results","forSubjects","getPredicates","forPredicates","getObjects","forObjects","getGraphs","forGraphs","createBlankNode","suggestedName","extractLists","ignoreErrors","lists","onError","node","tails","toRemove","tailQuad","items","headPos","malformed","objectQuads","subjectQuads","parent","n3Store","filtered","_filtered","escapeAll","escapedCharacters","SerializedTerm","N3Writer","outputStream","_prefixRegex","_lists","_outputStream","_endStream","test","format","_lineMode","_writeQuad","_writeQuadLine","_prefixIRIs","prefixes","addPrefixes","baseIRI","_baseMatcher","RegExp","escapeRegex","_baseLength","_inDefaultGraph","_encodeIriOrBlank","_encodeObject","_encodePredicate","_encodeSubject","_prefixMatch","quadToString","quadsToString","t","entity","_encodeQuad","characterReplacer","prefixMatch","_encodeLiteral","_blockedWrite","addPrefix","prefix","hasPrefixes","IRIlist","prefixList","prefixIRI","blank","child","children","contents","elements","singleDone","result","character","regex","namespaces","geo","schema","rdfs","vcard","dcterms","dcmi","dqm","foaf","qudt","qudt_unit","quantitykind","sosa","ssn","ssns","openhps","ogc","__awaiter","thisArg","_arguments","P","generator","fulfilled","step","rejected","adopt","RDFSerializer","static","meta","getMetadata","typeIri","_b","serialize","store","quadsToThing","deserialize","serializeToQuads","serializePredicates","quadSubject","quadPredicate","quadObjects","literals","langStrings","namedNodes","blankNodes","url","ns","filteredPrefixes","namespace","writer","prettyPrint","writeBlankNode","blankNodePredicates","serializedData","dataType","ensureTypeDescriptor","getUriMetadata","eventEmitter","types","registerRDFType","SerializableNamedNode_1","__decorate","decorators","desc","decorate","SerializableNamedNode","SerializableObject"],"sourceRoot":""}
+{"version":3,"file":"web/openhps-rdf.serialization.min.js","mappings":"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","sources":["webpack://OpenHPS.rdf/webpack/universalModuleDefinition","webpack://OpenHPS.rdf/./node_modules/base64-js/index.js","webpack://OpenHPS.rdf/./node_modules/buffer/index.js","webpack://OpenHPS.rdf/./node_modules/events/events.js","webpack://OpenHPS.rdf/./node_modules/ieee754/index.js","webpack://OpenHPS.rdf/./node_modules/inherits/inherits_browser.js","webpack://OpenHPS.rdf/./node_modules/queue-microtask/index.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/errors-browser.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/_stream_duplex.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/_stream_passthrough.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/_stream_readable.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/_stream_transform.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/_stream_writable.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/async_iterator.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/buffer_list.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/destroy.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/end-of-stream.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/from-browser.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/pipeline.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/state.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack://OpenHPS.rdf/./node_modules/readable-stream/readable-browser.js","webpack://OpenHPS.rdf/./node_modules/safe-buffer/index.js","webpack://OpenHPS.rdf/./node_modules/string_decoder/lib/string_decoder.js","webpack://OpenHPS.rdf/./node_modules/util-deprecate/browser.js","webpack://OpenHPS.rdf/external umd {\"commonjs\":\"@openhps/core\",\"commonjs2\":\"@openhps/core\",\"amd\":\"core\",\"root\":[\"OpenHPS\",\"core\"]}","webpack://OpenHPS.rdf/webpack/bootstrap","webpack://OpenHPS.rdf/webpack/runtime/compat get default export","webpack://OpenHPS.rdf/webpack/runtime/define property getters","webpack://OpenHPS.rdf/webpack/runtime/global","webpack://OpenHPS.rdf/webpack/runtime/hasOwnProperty shorthand","webpack://OpenHPS.rdf/webpack/runtime/make namespace object","webpack://OpenHPS.rdf/./node_modules/n3/src/IRIs.js","webpack://OpenHPS.rdf/./node_modules/n3/src/N3Util.js","webpack://OpenHPS.rdf/./node_modules/n3/src/N3DataFactory.js","webpack://OpenHPS.rdf/./dist/esm/decorators/index.js","webpack://OpenHPS.rdf/./dist/esm/rdf/utils.js","webpack://OpenHPS.rdf/./dist/esm/rdf/InternalRDFSerializer.js","webpack://OpenHPS.rdf/./dist/esm/vocab/rdf.js","webpack://OpenHPS.rdf/./dist/esm/vocab/index.js","webpack://OpenHPS.rdf/./dist/esm/rdf/InternalRDFDeserializer.js","webpack://OpenHPS.rdf/./node_modules/n3/src/N3Store.js","webpack://OpenHPS.rdf/./node_modules/n3/src/N3Writer.js","webpack://OpenHPS.rdf/./dist/esm/namespaces.js","webpack://OpenHPS.rdf/./dist/esm/rdf/RDFSerializer.js","webpack://OpenHPS.rdf/./dist/esm/rdf/SerializableNamedNode.js","webpack://OpenHPS.rdf/./node_modules/n3/src/N3Lexer.js","webpack://OpenHPS.rdf/./node_modules/n3/src/N3Parser.js","webpack://OpenHPS.rdf/./node_modules/n3/src/N3StreamParser.js","webpack://OpenHPS.rdf/./node_modules/n3/src/N3StreamWriter.js","webpack://OpenHPS.rdf/./node_modules/n3/src/index.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"@openhps/core\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"OpenHPS\", [\"core\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"OpenHPS\"] = factory(require(\"@openhps/core\"));\n\telse\n\t\troot[\"OpenHPS\"] = root[\"OpenHPS\"] || {}, root[\"OpenHPS\"][\"rdf\"] = factory(root[\"OpenHPS\"][\"core\"]);\n})((typeof self !== 'undefined' ? self : this), function(__WEBPACK_EXTERNAL_MODULE__0__) {\nreturn ","'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","// 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 R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\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","/*! 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","'use strict';\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nvar codes = {};\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    _inheritsLoose(NodeError, _Base);\n\n    function NodeError(arg1, arg2, arg3) {\n      return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;\n    }\n\n    return NodeError;\n  }(Base);\n\n  NodeError.prototype.name = Base.name;\n  NodeError.prototype.code = code;\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_INVALID_OPT_VALUE', function (name, value) {\n  return 'The value \"' + value + '\" is invalid for option \"' + name + '\"';\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n  // determiner: 'must be' or 'must not be'\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  }\n\n  msg += \". Received type \".concat(typeof actual);\n  return msg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');\ncreateErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {\n  return 'The ' + name + ' method is not implemented';\n});\ncreateErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');\ncreateErrorType('ERR_STREAM_DESTROYED', function (name) {\n  return 'Cannot call ' + name + ' after a stream was destroyed';\n});\ncreateErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');\ncreateErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');\ncreateErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');\ncreateErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);\ncreateErrorType('ERR_UNKNOWN_ENCODING', function (arg) {\n  return 'Unknown encoding: ' + arg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');\nmodule.exports.codes = codes;\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// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n'use strict';\n/*<replacement>*/\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n\n  for (var key in obj) {\n    keys.push(key);\n  }\n\n  return keys;\n};\n/*</replacement>*/\n\n\nmodule.exports = Duplex;\n\nvar Readable = require('./_stream_readable');\n\nvar Writable = require('./_stream_writable');\n\nrequire('inherits')(Duplex, Readable);\n\n{\n  // Allow the keys array to be GC'ed.\n  var keys = objectKeys(Writable.prototype);\n\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n  Readable.call(this, options);\n  Writable.call(this, options);\n  this.allowHalfOpen = true;\n\n  if (options) {\n    if (options.readable === false) this.readable = false;\n    if (options.writable === false) this.writable = false;\n\n    if (options.allowHalfOpen === false) {\n      this.allowHalfOpen = false;\n      this.once('end', onend);\n    }\n  }\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.highWaterMark;\n  }\n});\nObject.defineProperty(Duplex.prototype, 'writableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\nObject.defineProperty(Duplex.prototype, 'writableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.length;\n  }\n}); // the no-half-open enforcer\n\nfunction onend() {\n  // If the writable side ended, then we're ok.\n  if (this._writableState.ended) return; // no more data can be written.\n  // But allow more writes to happen in this tick.\n\n  process.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\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// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\nrequire('inherits')(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\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'use strict';\n\nmodule.exports = Readable;\n/*<replacement>*/\n\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n/*<replacement>*/\n\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*<replacement>*/\n\n\nvar debugUtil = require('util');\n\nvar debug;\n\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function debug() {};\n}\n/*</replacement>*/\n\n\nvar BufferList = require('./internal/streams/buffer_list');\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n    getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n    ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; // Lazy loaded to improve the startup performance.\n\n\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\nvar from;\n\nrequire('inherits')(Readable, Stream);\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n\n  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\n\nfunction ReadableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {}; // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n\n  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n\n  this.sync = true; // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n  this.paused = true; // Should close be emitted on destroy. Defaults to true.\n\n  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish')\n\n  this.autoDestroy = !!options.autoDestroy; // has it been destroyed\n\n  this.destroyed = false; // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n\n  this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s\n\n  this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled\n\n  this.readingMore = false;\n  this.decoder = null;\n  this.encoding = null;\n\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n  if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the ReadableState constructor, at least with V8 6.5\n\n  var isDuplex = this instanceof Duplex;\n  this._readableState = new ReadableState(options, this, isDuplex); // legacy\n\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._readableState === undefined) {\n      return false;\n    }\n\n    return this._readableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._readableState.destroyed = value;\n  }\n});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\n\nReadable.prototype._destroy = function (err, cb) {\n  cb(err);\n}; // Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\n\n\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n}; // Unshift should *always* be something directly out of read()\n\n\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  debug('readableAddChunk', chunk);\n  var state = stream._readableState;\n\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n\n    if (er) {\n      errorOrDestroy(stream, er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());\n      } else if (state.destroyed) {\n        return false;\n      } else {\n        state.reading = false;\n\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n      maybeReadMore(stream, state);\n    }\n  } // We can push more data if we are below the highWaterMark.\n  // Also, if we have no data yet, we can stand some more bytes.\n  // This is to work around cases where hwm=0, such as the repl.\n\n\n  return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    state.awaitDrain = 0;\n    stream.emit('data', chunk);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n    if (state.needReadable) emitReadable(stream);\n  }\n\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);\n  }\n\n  return er;\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n}; // backwards compatibility.\n\n\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  var decoder = new StringDecoder(enc);\n  this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8\n\n  this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers:\n\n  var p = this._readableState.buffer.head;\n  var content = '';\n\n  while (p !== null) {\n    content += decoder.write(p.data);\n    p = p.next;\n  }\n\n  this._readableState.buffer.clear();\n\n  if (content !== '') this._readableState.buffer.push(content);\n  this._readableState.length = content.length;\n  return this;\n}; // Don't raise the hwm > 1GB\n\n\nvar MAX_HWM = 0x40000000;\n\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n\n  return n;\n} // This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\n\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  } // If we're asking for more than the current hwm, then raise the hwm.\n\n\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n; // Don't have enough\n\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n\n  return state.length;\n} // you can override either this method, or the async _read(n) below.\n\n\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n  if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n\n  if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.\n\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  } // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n  // if we need a readable event, then we need to do some reading.\n\n\n  var doRead = state.needReadable;\n  debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some\n\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  } // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n\n\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true; // if the length is currently zero, then we *need* a readable event.\n\n    if (state.length === 0) state.needReadable = true; // call internal read method\n\n    this._read(state.highWaterMark);\n\n    state.sync = false; // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = state.length <= state.highWaterMark;\n    n = 0;\n  } else {\n    state.length -= n;\n    state.awaitDrain = 0;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick.\n\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  debug('onEofChunk');\n  if (state.ended) return;\n\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n\n  state.ended = true;\n\n  if (state.sync) {\n    // if we are sync, wait until next tick to emit the data.\n    // Otherwise we risk emitting data in the flow()\n    // the readable code triggers during a read() call\n    emitReadable(stream);\n  } else {\n    // emit 'readable' now to make sure it gets picked up.\n    state.needReadable = false;\n\n    if (!state.emittedReadable) {\n      state.emittedReadable = true;\n      emitReadable_(stream);\n    }\n  }\n} // Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\n\n\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  debug('emitReadable', state.needReadable, state.emittedReadable);\n  state.needReadable = false;\n\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    process.nextTick(emitReadable_, stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  var state = stream._readableState;\n  debug('emitReadable_', state.destroyed, state.length, state.ended);\n\n  if (!state.destroyed && (state.length || state.ended)) {\n    stream.emit('readable');\n    state.emittedReadable = false;\n  } // The stream needs another readable event if\n  // 1. It is not flowing, as the flow mechanism will take\n  //    care of it.\n  // 2. It is not ended.\n  // 3. It is below the highWaterMark, so we can schedule\n  //    another readable later.\n\n\n  state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n  flow(stream);\n} // at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\n\n\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    process.nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  // Attempt to read more data if we should.\n  //\n  // The conditions for reading more data are (one of):\n  // - Not enough data buffered (state.length < state.highWaterMark). The loop\n  //   is responsible for filling the buffer with enough data if such data\n  //   is available. If highWaterMark is 0 and we are not in the flowing mode\n  //   we should _not_ attempt to buffer any extra data. We'll get more data\n  //   when the stream consumer calls read() instead.\n  // - No data in the buffer, and the stream is in flowing mode. In this mode\n  //   the loop below is responsible for ensuring read() is called. Failing to\n  //   call read here would abort the flow and there's no other mechanism for\n  //   continuing the flow if the stream consumer has just subscribed to the\n  //   'data' event.\n  //\n  // In addition to the above conditions to keep reading data, the following\n  // conditions prevent the data from being read:\n  // - The stream has ended (state.ended).\n  // - There is already a pending 'read' operation (state.reading). This is a\n  //   case where the the stream has called the implementation defined _read()\n  //   method, but they are processing the call asynchronously and have _not_\n  //   called push() with new data. In this case we skip performing more\n  //   read()s. The execution ends in this method again after the _read() ends\n  //   up calling push() with more data.\n  while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {\n    var len = state.length;\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length) // didn't get any data, stop spinning.\n      break;\n  }\n\n  state.readingMore = false;\n} // abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\n\n\nReadable.prototype._read = function (n) {\n  errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);\n  dest.on('unpipe', onunpipe);\n\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  } // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n\n\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n  var cleanedUp = false;\n\n  function cleanup() {\n    debug('cleanup'); // cleanup event handlers once the pipe is broken\n\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n    cleanedUp = true; // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  src.on('data', ondata);\n\n  function ondata(chunk) {\n    debug('ondata');\n    var ret = dest.write(chunk);\n    debug('dest.write', ret);\n\n    if (ret === false) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', state.awaitDrain);\n        state.awaitDrain++;\n      }\n\n      src.pause();\n    }\n  } // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n\n\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);\n  } // Make sure our error handler is attached before userland ones.\n\n\n  prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.\n\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n\n  dest.once('close', onclose);\n\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  } // tell the dest that it's being piped to\n\n\n  dest.emit('pipe', src); // start the flow if it hasn't been started already.\n\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function pipeOnDrainFunctionResult() {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = {\n    hasUnpiped: false\n  }; // if we're not piping anywhere, then do nothing.\n\n  if (state.pipesCount === 0) return this; // just one destination.  most common case.\n\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n    if (!dest) dest = state.pipes; // got a match.\n\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  } // slow case. multiple pipe destinations.\n\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, {\n        hasUnpiped: false\n      });\n    }\n\n    return this;\n  } // try to find the right one.\n\n\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n  dest.emit('unpipe', this, unpipeInfo);\n  return this;\n}; // set up data events if they are asked for\n// Ensure readable listeners eventually get something\n\n\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n  var state = this._readableState;\n\n  if (ev === 'data') {\n    // update readableListening so that resume() may be a no-op\n    // a few lines down. This is needed to support once('readable').\n    state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused\n\n    if (state.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.flowing = false;\n      state.emittedReadable = false;\n      debug('on readable', state.length, state.reading);\n\n      if (state.length) {\n        emitReadable(this);\n      } else if (!state.reading) {\n        process.nextTick(nReadingNextTick, this);\n      }\n    }\n  }\n\n  return res;\n};\n\nReadable.prototype.addListener = Readable.prototype.on;\n\nReadable.prototype.removeListener = function (ev, fn) {\n  var res = Stream.prototype.removeListener.call(this, ev, fn);\n\n  if (ev === 'readable') {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this);\n  }\n\n  return res;\n};\n\nReadable.prototype.removeAllListeners = function (ev) {\n  var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n\n  if (ev === 'readable' || ev === undefined) {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this);\n  }\n\n  return res;\n};\n\nfunction updateReadableListening(self) {\n  var state = self._readableState;\n  state.readableListening = self.listenerCount('readable') > 0;\n\n  if (state.resumeScheduled && !state.paused) {\n    // flowing needs to be set to true now, otherwise\n    // the upcoming resume will not flow.\n    state.flowing = true; // crude way to check if we should resume\n  } else if (self.listenerCount('data') > 0) {\n    self.resume();\n  }\n}\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n} // pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\n\n\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n\n  if (!state.flowing) {\n    debug('resume'); // we flow only if there is no one listening\n    // for readable, but we still have to call\n    // resume()\n\n    state.flowing = !state.readableListening;\n    resume(this, state);\n  }\n\n  state.paused = false;\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    process.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  debug('resume', state.reading);\n\n  if (!state.reading) {\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n\n  if (this._readableState.flowing !== false) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n\n  this._readableState.paused = true;\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n\n  while (state.flowing && stream.read() !== null) {\n    ;\n  }\n} // wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\n\n\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n  stream.on('end', function () {\n    debug('wrapped end');\n\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n\n    _this.push(null);\n  });\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode\n\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  }); // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function methodWrap(method) {\n        return function methodWrapReturnFunction() {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  } // proxy certain important events.\n\n\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  } // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n\n\n  this._read = function (n) {\n    debug('wrapped _read', n);\n\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nif (typeof Symbol === 'function') {\n  Readable.prototype[Symbol.asyncIterator] = function () {\n    if (createReadableStreamAsyncIterator === undefined) {\n      createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n    }\n\n    return createReadableStreamAsyncIterator(this);\n  };\n}\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.highWaterMark;\n  }\n});\nObject.defineProperty(Readable.prototype, 'readableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState && this._readableState.buffer;\n  }\n});\nObject.defineProperty(Readable.prototype, 'readableFlowing', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.flowing;\n  },\n  set: function set(state) {\n    if (this._readableState) {\n      this._readableState.flowing = state;\n    }\n  }\n}); // exposed for testing purposes only.\n\nReadable._fromList = fromList;\nObject.defineProperty(Readable.prototype, 'readableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.length;\n  }\n}); // Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = state.buffer.consume(n, state.decoder);\n  }\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n  debug('endReadable', state.endEmitted);\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    process.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.\n\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n\n    if (state.autoDestroy) {\n      // In case of duplex streams we need a way to detect\n      // if the writable side is ready for autoDestroy as well\n      var wState = stream._writableState;\n\n      if (!wState || wState.autoDestroy && wState.finished) {\n        stream.destroy();\n      }\n    }\n  }\n}\n\nif (typeof Symbol === 'function') {\n  Readable.from = function (iterable, opts) {\n    if (from === undefined) {\n      from = require('./internal/streams/from');\n    }\n\n    return from(Readable, iterable, opts);\n  };\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n\n  return -1;\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// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n'use strict';\n\nmodule.exports = Transform;\n\nvar _require$codes = require('../errors').codes,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n    ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,\n    ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;\n\nvar Duplex = require('./_stream_duplex');\n\nrequire('inherits')(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n  var cb = ts.writecb;\n\n  if (cb === null) {\n    return this.emit('error', new ERR_MULTIPLE_CALLBACK());\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n  cb(er);\n  var rs = this._readableState;\n  rs.reading = false;\n\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n  Duplex.call(this, options);\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  }; // start out asking for a readable event once data is transformed.\n\n  this._readableState.needReadable = true; // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  } // When the writable side finishes, then flush out anything remaining.\n\n\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function' && !this._readableState.destroyed) {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n}; // This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\n\n\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n}; // Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\n\n\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && !ts.transforming) {\n    ts.transforming = true;\n\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data); // TODO(BridgeAR): Write a test for these two error cases\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n\n  if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();\n  if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();\n  return stream.push(null);\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// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n'use strict';\n\nmodule.exports = Writable;\n/* <replacement> */\n\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n} // It seems a linked list but it is not\n// there will be only 2 of these for each stream\n\n\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\n\n\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n/*<replacement>*/\n\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n    getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n    ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n    ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n    ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n    ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\n\nrequire('inherits')(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {}; // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream,\n  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n\n  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called\n\n  this.finalCalled = false; // drain event flag.\n\n  this.needDrain = false; // at the start of calling end()\n\n  this.ending = false; // when end() has been called, and returned\n\n  this.ended = false; // when 'finish' is emitted\n\n  this.finished = false; // has it been destroyed\n\n  this.destroyed = false; // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode; // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n\n  this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n\n  this.length = 0; // a flag to see when we're in the middle of a write.\n\n  this.writing = false; // when true all writes will be buffered until .uncork() call\n\n  this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n\n  this.sync = true; // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n\n  this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)\n\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  }; // the callback that the user supplies to write(chunk,encoding,cb)\n\n\n  this.writecb = null; // the amount that is being written when _write is called.\n\n  this.writelen = 0;\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null; // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n\n  this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n\n  this.prefinished = false; // True if the error was already emitted and should not be thrown again\n\n  this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.\n\n  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')\n\n  this.autoDestroy = !!options.autoDestroy; // count buffered requests\n\n  this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function writableStateBufferGetter() {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})(); // Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\n\n\nvar realHasInstance;\n\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function value(object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function realHasInstance(object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the WritableState constructor, at least with V8 6.5\n\n  var isDuplex = this instanceof Duplex;\n  if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n  this._writableState = new WritableState(options, this, isDuplex); // legacy.\n\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n    if (typeof options.writev === 'function') this._writev = options.writev;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n} // Otherwise people can pipe Writable streams, which is just wrong.\n\n\nWritable.prototype.pipe = function () {\n  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb\n\n  errorOrDestroy(stream, er);\n  process.nextTick(cb, er);\n} // Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\n\n\nfunction validChunk(stream, state, chunk, cb) {\n  var er;\n\n  if (chunk === null) {\n    er = new ERR_STREAM_NULL_VALUES();\n  } else if (typeof chunk !== 'string' && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n  }\n\n  if (er) {\n    errorOrDestroy(stream, er);\n    process.nextTick(cb, er);\n    return false;\n  }\n\n  return true;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n  if (typeof cb !== 'function') cb = nop;\n  if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  this._writableState.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n    if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.highWaterMark;\n  }\n}); // if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\n\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n\n  var len = state.objectMode ? 1 : chunk.length;\n  state.length += len;\n  var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.\n\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    process.nextTick(cb, er); // this can emit finish, and it will always happen\n    // after error\n\n    process.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er); // this can emit finish, but finish must\n    // always follow error\n\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n  if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n  onwriteStateUpdate(state);\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state) || stream.destroyed;\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      process.nextTick(afterWrite, stream, state, finished, cb);\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n} // Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\n\n\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n} // if there's something in the buffer waiting, then process it\n\n\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n    var count = 0;\n    var allBuffers = true;\n\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n\n    buffer.allBuffers = allBuffers;\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks\n\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  } // ignore unnecessary end() calls.\n\n\n  if (!state.ending) endWritable(this, state, cb);\n  return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.length;\n  }\n});\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\n\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n\n    if (err) {\n      errorOrDestroy(stream, err);\n    }\n\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\n\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function' && !state.destroyed) {\n      state.pendingcb++;\n      state.finalCalled = true;\n      process.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n\n  if (need) {\n    prefinish(stream, state);\n\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n\n      if (state.autoDestroy) {\n        // In case of duplex streams we need a way to detect\n        // if the readable side is ready for autoDestroy as well\n        var rState = stream._readableState;\n\n        if (!rState || rState.autoDestroy && rState.endEmitted) {\n          stream.destroy();\n        }\n      }\n    }\n  }\n\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n\n  if (cb) {\n    if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n  }\n\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  } // reuse the free corkReq.\n\n\n  state.corkedRequestsFree.next = corkReq;\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._writableState === undefined) {\n      return false;\n    }\n\n    return this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._writableState.destroyed = value;\n  }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\n\nWritable.prototype._destroy = function (err, cb) {\n  cb(err);\n};","'use strict';\n\nvar _Object$setPrototypeO;\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\nvar finished = require('./end-of-stream');\n\nvar kLastResolve = Symbol('lastResolve');\nvar kLastReject = Symbol('lastReject');\nvar kError = Symbol('error');\nvar kEnded = Symbol('ended');\nvar kLastPromise = Symbol('lastPromise');\nvar kHandlePromise = Symbol('handlePromise');\nvar kStream = Symbol('stream');\n\nfunction createIterResult(value, done) {\n  return {\n    value: value,\n    done: done\n  };\n}\n\nfunction readAndResolve(iter) {\n  var resolve = iter[kLastResolve];\n\n  if (resolve !== null) {\n    var data = iter[kStream].read(); // we defer if data is null\n    // we can be expecting either 'end' or\n    // 'error'\n\n    if (data !== null) {\n      iter[kLastPromise] = null;\n      iter[kLastResolve] = null;\n      iter[kLastReject] = null;\n      resolve(createIterResult(data, false));\n    }\n  }\n}\n\nfunction onReadable(iter) {\n  // we wait for the next tick, because it might\n  // emit an error with process.nextTick\n  process.nextTick(readAndResolve, iter);\n}\n\nfunction wrapForNext(lastPromise, iter) {\n  return function (resolve, reject) {\n    lastPromise.then(function () {\n      if (iter[kEnded]) {\n        resolve(createIterResult(undefined, true));\n        return;\n      }\n\n      iter[kHandlePromise](resolve, reject);\n    }, reject);\n  };\n}\n\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n  get stream() {\n    return this[kStream];\n  },\n\n  next: function next() {\n    var _this = this;\n\n    // if we have detected an error in the meanwhile\n    // reject straight away\n    var error = this[kError];\n\n    if (error !== null) {\n      return Promise.reject(error);\n    }\n\n    if (this[kEnded]) {\n      return Promise.resolve(createIterResult(undefined, true));\n    }\n\n    if (this[kStream].destroyed) {\n      // We need to defer via nextTick because if .destroy(err) is\n      // called, the error will be emitted via nextTick, and\n      // we cannot guarantee that there is no error lingering around\n      // waiting to be emitted.\n      return new Promise(function (resolve, reject) {\n        process.nextTick(function () {\n          if (_this[kError]) {\n            reject(_this[kError]);\n          } else {\n            resolve(createIterResult(undefined, true));\n          }\n        });\n      });\n    } // if we have multiple next() calls\n    // we will wait for the previous Promise to finish\n    // this logic is optimized to support for await loops,\n    // where next() is only called once at a time\n\n\n    var lastPromise = this[kLastPromise];\n    var promise;\n\n    if (lastPromise) {\n      promise = new Promise(wrapForNext(lastPromise, this));\n    } else {\n      // fast path needed to support multiple this.push()\n      // without triggering the next() queue\n      var data = this[kStream].read();\n\n      if (data !== null) {\n        return Promise.resolve(createIterResult(data, false));\n      }\n\n      promise = new Promise(this[kHandlePromise]);\n    }\n\n    this[kLastPromise] = promise;\n    return promise;\n  }\n}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {\n  return this;\n}), _defineProperty(_Object$setPrototypeO, \"return\", function _return() {\n  var _this2 = this;\n\n  // destroy(err, cb) is a private API\n  // we can guarantee we have that here, because we control the\n  // Readable class this is attached to\n  return new Promise(function (resolve, reject) {\n    _this2[kStream].destroy(null, function (err) {\n      if (err) {\n        reject(err);\n        return;\n      }\n\n      resolve(createIterResult(undefined, true));\n    });\n  });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\n\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n  var _Object$create;\n\n  var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {\n    value: stream,\n    writable: true\n  }), _defineProperty(_Object$create, kLastResolve, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kLastReject, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kError, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kEnded, {\n    value: stream._readableState.endEmitted,\n    writable: true\n  }), _defineProperty(_Object$create, kHandlePromise, {\n    value: function value(resolve, reject) {\n      var data = iterator[kStream].read();\n\n      if (data) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        resolve(createIterResult(data, false));\n      } else {\n        iterator[kLastResolve] = resolve;\n        iterator[kLastReject] = reject;\n      }\n    },\n    writable: true\n  }), _Object$create));\n  iterator[kLastPromise] = null;\n  finished(stream, function (err) {\n    if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {\n      var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise\n      // returned by next() and store the error\n\n      if (reject !== null) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        reject(err);\n      }\n\n      iterator[kError] = err;\n      return;\n    }\n\n    var resolve = iterator[kLastResolve];\n\n    if (resolve !== null) {\n      iterator[kLastPromise] = null;\n      iterator[kLastResolve] = null;\n      iterator[kLastReject] = null;\n      resolve(createIterResult(undefined, true));\n    }\n\n    iterator[kEnded] = true;\n  });\n  stream.on('readable', onReadable.bind(null, iterator));\n  return iterator;\n};\n\nmodule.exports = createReadableStreamAsyncIterator;","'use strict';\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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\nvar _require = require('buffer'),\n    Buffer = _require.Buffer;\n\nvar _require2 = require('util'),\n    inspect = _require2.inspect;\n\nvar custom = inspect && inspect.custom || 'inspect';\n\nfunction copyBuffer(src, target, offset) {\n  Buffer.prototype.copy.call(src, target, offset);\n}\n\nmodule.exports =\n/*#__PURE__*/\nfunction () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  _createClass(BufferList, [{\n    key: \"push\",\n    value: function push(v) {\n      var entry = {\n        data: v,\n        next: null\n      };\n      if (this.length > 0) this.tail.next = entry;else this.head = entry;\n      this.tail = entry;\n      ++this.length;\n    }\n  }, {\n    key: \"unshift\",\n    value: function unshift(v) {\n      var entry = {\n        data: v,\n        next: this.head\n      };\n      if (this.length === 0) this.tail = entry;\n      this.head = entry;\n      ++this.length;\n    }\n  }, {\n    key: \"shift\",\n    value: function shift() {\n      if (this.length === 0) return;\n      var ret = this.head.data;\n      if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n      --this.length;\n      return ret;\n    }\n  }, {\n    key: \"clear\",\n    value: function clear() {\n      this.head = this.tail = null;\n      this.length = 0;\n    }\n  }, {\n    key: \"join\",\n    value: function join(s) {\n      if (this.length === 0) return '';\n      var p = this.head;\n      var ret = '' + p.data;\n\n      while (p = p.next) {\n        ret += s + p.data;\n      }\n\n      return ret;\n    }\n  }, {\n    key: \"concat\",\n    value: function concat(n) {\n      if (this.length === 0) return Buffer.alloc(0);\n      var ret = Buffer.allocUnsafe(n >>> 0);\n      var p = this.head;\n      var i = 0;\n\n      while (p) {\n        copyBuffer(p.data, ret, i);\n        i += p.data.length;\n        p = p.next;\n      }\n\n      return ret;\n    } // Consumes a specified amount of bytes or characters from the buffered data.\n\n  }, {\n    key: \"consume\",\n    value: function consume(n, hasStrings) {\n      var ret;\n\n      if (n < this.head.data.length) {\n        // `slice` is the same for buffers and strings.\n        ret = this.head.data.slice(0, n);\n        this.head.data = this.head.data.slice(n);\n      } else if (n === this.head.data.length) {\n        // First chunk is a perfect match.\n        ret = this.shift();\n      } else {\n        // Result spans more than one buffer.\n        ret = hasStrings ? this._getString(n) : this._getBuffer(n);\n      }\n\n      return ret;\n    }\n  }, {\n    key: \"first\",\n    value: function first() {\n      return this.head.data;\n    } // Consumes a specified amount of characters from the buffered data.\n\n  }, {\n    key: \"_getString\",\n    value: function _getString(n) {\n      var p = this.head;\n      var c = 1;\n      var ret = p.data;\n      n -= ret.length;\n\n      while (p = p.next) {\n        var str = p.data;\n        var nb = n > str.length ? str.length : n;\n        if (nb === str.length) ret += str;else ret += str.slice(0, n);\n        n -= nb;\n\n        if (n === 0) {\n          if (nb === str.length) {\n            ++c;\n            if (p.next) this.head = p.next;else this.head = this.tail = null;\n          } else {\n            this.head = p;\n            p.data = str.slice(nb);\n          }\n\n          break;\n        }\n\n        ++c;\n      }\n\n      this.length -= c;\n      return ret;\n    } // Consumes a specified amount of bytes from the buffered data.\n\n  }, {\n    key: \"_getBuffer\",\n    value: function _getBuffer(n) {\n      var ret = Buffer.allocUnsafe(n);\n      var p = this.head;\n      var c = 1;\n      p.data.copy(ret);\n      n -= p.data.length;\n\n      while (p = p.next) {\n        var buf = p.data;\n        var nb = n > buf.length ? buf.length : n;\n        buf.copy(ret, ret.length - n, 0, nb);\n        n -= nb;\n\n        if (n === 0) {\n          if (nb === buf.length) {\n            ++c;\n            if (p.next) this.head = p.next;else this.head = this.tail = null;\n          } else {\n            this.head = p;\n            p.data = buf.slice(nb);\n          }\n\n          break;\n        }\n\n        ++c;\n      }\n\n      this.length -= c;\n      return ret;\n    } // Make sure the linked list only shows the minimal necessary information.\n\n  }, {\n    key: custom,\n    value: function value(_, options) {\n      return inspect(this, _objectSpread({}, options, {\n        // Only inspect one level.\n        depth: 0,\n        // It should not recurse.\n        customInspect: false\n      }));\n    }\n  }]);\n\n  return BufferList;\n}();","'use strict'; // undocumented cb() API, needed for core, not for public API\n\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err) {\n      if (!this._writableState) {\n        process.nextTick(emitErrorNT, this, err);\n      } else if (!this._writableState.errorEmitted) {\n        this._writableState.errorEmitted = true;\n        process.nextTick(emitErrorNT, this, err);\n      }\n    }\n\n    return this;\n  } // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  } // if this is a duplex stream mark the writable part as destroyed as well\n\n\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      if (!_this._writableState) {\n        process.nextTick(emitErrorAndCloseNT, _this, err);\n      } else if (!_this._writableState.errorEmitted) {\n        _this._writableState.errorEmitted = true;\n        process.nextTick(emitErrorAndCloseNT, _this, err);\n      } else {\n        process.nextTick(emitCloseNT, _this);\n      }\n    } else if (cb) {\n      process.nextTick(emitCloseNT, _this);\n      cb(err);\n    } else {\n      process.nextTick(emitCloseNT, _this);\n    }\n  });\n\n  return this;\n}\n\nfunction emitErrorAndCloseNT(self, err) {\n  emitErrorNT(self, err);\n  emitCloseNT(self);\n}\n\nfunction emitCloseNT(self) {\n  if (self._writableState && !self._writableState.emitClose) return;\n  if (self._readableState && !self._readableState.emitClose) return;\n  self.emit('close');\n}\n\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finalCalled = false;\n    this._writableState.prefinished = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nfunction errorOrDestroy(stream, err) {\n  // We have tests that rely on errors being emitted\n  // in the same tick, so changing this is semver major.\n  // For now when you opt-in to autoDestroy we allow\n  // the error to be emitted nextTick. In a future\n  // semver major update we should change the default to this.\n  var rState = stream._readableState;\n  var wState = stream._writableState;\n  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy,\n  errorOrDestroy: errorOrDestroy\n};","// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\n\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    callback.apply(this, args);\n  };\n}\n\nfunction noop() {}\n\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\n\nfunction eos(stream, opts, callback) {\n  if (typeof opts === 'function') return eos(stream, null, opts);\n  if (!opts) opts = {};\n  callback = once(callback || noop);\n  var readable = opts.readable || opts.readable !== false && stream.readable;\n  var writable = opts.writable || opts.writable !== false && stream.writable;\n\n  var onlegacyfinish = function onlegacyfinish() {\n    if (!stream.writable) onfinish();\n  };\n\n  var writableEnded = stream._writableState && stream._writableState.finished;\n\n  var onfinish = function onfinish() {\n    writable = false;\n    writableEnded = true;\n    if (!readable) callback.call(stream);\n  };\n\n  var readableEnded = stream._readableState && stream._readableState.endEmitted;\n\n  var onend = function onend() {\n    readable = false;\n    readableEnded = true;\n    if (!writable) callback.call(stream);\n  };\n\n  var onerror = function onerror(err) {\n    callback.call(stream, err);\n  };\n\n  var onclose = function onclose() {\n    var err;\n\n    if (readable && !readableEnded) {\n      if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n      return callback.call(stream, err);\n    }\n\n    if (writable && !writableEnded) {\n      if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n      return callback.call(stream, err);\n    }\n  };\n\n  var onrequest = function onrequest() {\n    stream.req.on('finish', onfinish);\n  };\n\n  if (isRequest(stream)) {\n    stream.on('complete', onfinish);\n    stream.on('abort', onclose);\n    if (stream.req) onrequest();else stream.on('request', onrequest);\n  } else if (writable && !stream._writableState) {\n    // legacy streams\n    stream.on('end', onlegacyfinish);\n    stream.on('close', onlegacyfinish);\n  }\n\n  stream.on('end', onend);\n  stream.on('finish', onfinish);\n  if (opts.error !== false) stream.on('error', onerror);\n  stream.on('close', onclose);\n  return function () {\n    stream.removeListener('complete', onfinish);\n    stream.removeListener('abort', onclose);\n    stream.removeListener('request', onrequest);\n    if (stream.req) stream.req.removeListener('finish', onfinish);\n    stream.removeListener('end', onlegacyfinish);\n    stream.removeListener('close', onlegacyfinish);\n    stream.removeListener('finish', onfinish);\n    stream.removeListener('end', onend);\n    stream.removeListener('error', onerror);\n    stream.removeListener('close', onclose);\n  };\n}\n\nmodule.exports = eos;","module.exports = function () {\n  throw new Error('Readable.from is not available in the browser')\n};\n","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar eos;\n\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n    callback.apply(void 0, arguments);\n  };\n}\n\nvar _require$codes = require('../../../errors').codes,\n    ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,\n    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;\n\nfunction noop(err) {\n  // Rethrow the error if it exists to avoid swallowing it\n  if (err) throw err;\n}\n\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\n\nfunction destroyer(stream, reading, writing, callback) {\n  callback = once(callback);\n  var closed = false;\n  stream.on('close', function () {\n    closed = true;\n  });\n  if (eos === undefined) eos = require('./end-of-stream');\n  eos(stream, {\n    readable: reading,\n    writable: writing\n  }, function (err) {\n    if (err) return callback(err);\n    closed = true;\n    callback();\n  });\n  var destroyed = false;\n  return function (err) {\n    if (closed) return;\n    if (destroyed) return;\n    destroyed = true; // request.destroy just do .end - .abort is what we want\n\n    if (isRequest(stream)) return stream.abort();\n    if (typeof stream.destroy === 'function') return stream.destroy();\n    callback(err || new ERR_STREAM_DESTROYED('pipe'));\n  };\n}\n\nfunction call(fn) {\n  fn();\n}\n\nfunction pipe(from, to) {\n  return from.pipe(to);\n}\n\nfunction popCallback(streams) {\n  if (!streams.length) return noop;\n  if (typeof streams[streams.length - 1] !== 'function') return noop;\n  return streams.pop();\n}\n\nfunction pipeline() {\n  for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {\n    streams[_key] = arguments[_key];\n  }\n\n  var callback = popCallback(streams);\n  if (Array.isArray(streams[0])) streams = streams[0];\n\n  if (streams.length < 2) {\n    throw new ERR_MISSING_ARGS('streams');\n  }\n\n  var error;\n  var destroys = streams.map(function (stream, i) {\n    var reading = i < streams.length - 1;\n    var writing = i > 0;\n    return destroyer(stream, reading, writing, function (err) {\n      if (!error) error = err;\n      if (err) destroys.forEach(call);\n      if (reading) return;\n      destroys.forEach(call);\n      callback(error);\n    });\n  });\n  return streams.reduce(pipe);\n}\n\nmodule.exports = pipeline;","'use strict';\n\nvar ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;\n\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\n\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n\n  if (hwm != null) {\n    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {\n      var name = isDuplex ? duplexKey : 'highWaterMark';\n      throw new ERR_INVALID_OPT_VALUE(name, hwm);\n    }\n\n    return Math.floor(hwm);\n  } // Default value\n\n\n  return state.objectMode ? 16 : 16 * 1024;\n}\n\nmodule.exports = {\n  getHighWaterMark: getHighWaterMark\n};","module.exports = require('events').EventEmitter;\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\nexports.finished = require('./lib/internal/streams/end-of-stream.js');\nexports.pipeline = require('./lib/internal/streams/pipeline.js');\n","/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.prototype = Object.create(Buffer.prototype)\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\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\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\n","module.exports = __WEBPACK_EXTERNAL_MODULE__0__;","// 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\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\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__.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__.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};","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","// **N3Util** provides N3 utility functions.\n\nimport N3DataFactory from './N3DataFactory';\n\n// Tests whether the given term represents an IRI\nexport function isNamedNode(term) {\n  return !!term && term.termType === 'NamedNode';\n}\n\n// Tests whether the given term represents a blank node\nexport function isBlankNode(term) {\n  return !!term && term.termType === 'BlankNode';\n}\n\n// Tests whether the given term represents a literal\nexport function isLiteral(term) {\n  return !!term && term.termType === 'Literal';\n}\n\n// Tests whether the given term represents a variable\nexport function isVariable(term) {\n  return !!term && term.termType === 'Variable';\n}\n\n// Tests whether the given term represents the default graph\nexport function isDefaultGraph(term) {\n  return !!term && term.termType === 'DefaultGraph';\n}\n\n// Tests whether the given quad is in the default graph\nexport function inDefaultGraph(quad) {\n  return isDefaultGraph(quad.graph);\n}\n\n// Creates a function that prepends the given IRI to a local name\nexport function prefix(iri, factory) {\n  return prefixes({ '': iri.value || iri }, factory)('');\n}\n\n// Creates a function that allows registering and expanding prefixes\nexport function prefixes(defaultPrefixes, factory) {\n  // Add all of the default prefixes\n  const prefixes = Object.create(null);\n  for (const prefix in defaultPrefixes)\n    processPrefix(prefix, defaultPrefixes[prefix]);\n  // Set the default factory if none was specified\n  factory = factory || N3DataFactory;\n\n  // Registers a new prefix (if an IRI was specified)\n  // or retrieves a function that expands an existing prefix (if no IRI was specified)\n  function processPrefix(prefix, iri) {\n    // Create a new prefix if an IRI is specified or the prefix doesn't exist\n    if (typeof iri === 'string') {\n      // Create a function that expands the prefix\n      const cache = Object.create(null);\n      prefixes[prefix] = local => {\n        return cache[local] || (cache[local] = factory.namedNode(iri + local));\n      };\n    }\n    else if (!(prefix in prefixes)) {\n      throw new Error(`Unknown prefix: ${prefix}`);\n    }\n    return prefixes[prefix];\n  }\n  return processPrefix;\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';\nimport { isDefaultGraph } from './N3Util';\nconst { rdf, xsd } = namespaces;\n\n// eslint-disable-next-line prefer-const\nlet DEFAULTGRAPH;\nlet _blankNodeCounter = 0;\n\nconst escapedLiteral = /^\"(.*\".*)(?=\"[^\"]*$)/;\nconst quadId = /^<<(\"(?:\"\"|[^\"])*\"[^ ]*|[^ ]+) (\"(?:\"\"|[^\"])*\"[^ ]*|[^ ]+) (\"(?:\"\"|[^\"])*\"[^ ]*|[^ ]+) ?(\"(?:\"\"|[^\"])*\"[^ ]*|[^ ]+)?>>$/;\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\n// ### Constructs a term from the given internal string ID\nexport function termFromId(id, factory) {\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    const components = quadId.exec(id);\n    return factory.quad(\n      termFromId(unescapeQuotes(components[1]), factory),\n      termFromId(unescapeQuotes(components[2]), factory),\n      termFromId(unescapeQuotes(components[3]), factory),\n      components[4] && termFromId(unescapeQuotes(components[4]), factory)\n    );\n  default:\n    return factory.namedNode(id);\n  }\n}\n\n// ### Constructs an internal string ID from the given term or ID string\nexport function termToId(term) {\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    // To identify RDF* quad components, we escape quotes by doubling them.\n    // This avoids the overhead of backslash parsing of Turtle-like syntaxes.\n    return `<<${\n        escapeQuotes(termToId(term.subject))\n      } ${\n        escapeQuotes(termToId(term.predicate))\n      } ${\n        escapeQuotes(termToId(term.object))\n      }${\n        (isDefaultGraph(term.graph)) ? '' : ` ${termToId(term.graph)}`\n      }>>`;\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","export const xsd = {\n    boolean: 'http://www.w3.org/2001/XMLSchema#boolean',\n    dateTime: 'http://www.w3.org/2001/XMLSchema#dateTime',\n    date: 'http://www.w3.org/2001/XMLSchema#date',\n    time: 'http://www.w3.org/2001/XMLSchema#time',\n    decimal: 'http://www.w3.org/2001/XMLSchema#decimal',\n    anyURI: 'http://www.w3.org/2001/XMLSchema#anyURI',\n    integer: 'http://www.w3.org/2001/XMLSchema#integer',\n    string: 'http://www.w3.org/2001/XMLSchema#string',\n    double: 'http://www.w3.org/2001/XMLSchema#double',\n    langString: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#langString',\n};\n//# sourceMappingURL=index.js.map","export function mergeDeep(target, source) {\n    const output = Object.assign({}, target);\n    if (isObject(target) && isObject(source)) {\n        Object.keys(source).forEach((key) => {\n            if (Array.isArray(source[key])) {\n                output[key] = source[key];\n                output[key].push(...(target[key] || []));\n            }\n            else if (isObject(source[key])) {\n                if (!(key in target))\n                    Object.assign(output, { [key]: source[key] });\n                else\n                    output[key] = mergeDeep(target[key], source[key]);\n            }\n            else {\n                Object.assign(output, { [key]: source[key] });\n            }\n        });\n    }\n    return output;\n}\nfunction isObject(item) {\n    return item && typeof item === 'object' && !Array.isArray(item);\n}\n//# sourceMappingURL=utils.js.map","import { DataSerializer, Serializer, } from '@openhps/core';\nimport * as N3 from 'n3';\nimport { xsd } from '../decorators/';\nimport { mergeDeep } from './utils';\nexport class InternalRDFSerializer extends Serializer {\n    constructor() {\n        super(...arguments);\n        this.serializationStrategy = new Map([\n            [Number, this.serializeLiteral.bind(this)],\n            [String, this.serializeLiteral.bind(this)],\n            [Boolean, this.serializeLiteral.bind(this)],\n            [Date, this.serializeDate.bind(this)],\n            [Array, this.serializeArray.bind(this)],\n            [Map, this.serializeMap.bind(this)],\n            [Set, this.serializeSet.bind(this)],\n        ]);\n    }\n    convertSingleValue(sourceObject, typeDescriptor, memberName, memberOptions, serializerOptions = {}) {\n        if (this.retrievePreserveNull(memberOptions) && sourceObject === null) {\n            return null;\n        }\n        if (sourceObject === undefined || sourceObject === null) {\n            return;\n        }\n        if (memberOptions &&\n            memberOptions.options &&\n            memberOptions.options.rdf &&\n            memberOptions.options.rdf.serializer) {\n            return memberOptions.options.rdf.serializer(sourceObject);\n        }\n        const serializer = this.serializationStrategy.get(typeDescriptor.ctor);\n        if (serializer !== undefined) {\n            return serializer(sourceObject, typeDescriptor, memberName, this, memberOptions, serializerOptions);\n        }\n        if (typeof sourceObject === 'object') {\n            return this.serializeObject(sourceObject, typeDescriptor, memberName, this, memberOptions, serializerOptions);\n        }\n        let error = `Could not serialize '${memberName}'; don't know how to serialize type`;\n        if (typeDescriptor.hasFriendlyName()) {\n            error += ` '${typeDescriptor.ctor.name}'`;\n        }\n        this.errorHandler(new TypeError(`${error}.`));\n    }\n    serializeObject(sourceObject, typeDescriptor, memberName, serializer, memberOptions, serializerOptions) {\n        let metadata;\n        const rootMetadata = DataSerializer.getRootMetadata(sourceObject.constructor);\n        if (sourceObject.constructor !== typeDescriptor.ctor && sourceObject instanceof typeDescriptor.ctor) {\n            metadata = DataSerializer.getMetadata(sourceObject.constructor);\n        }\n        else {\n            metadata = DataSerializer.getMetadata(typeDescriptor.ctor);\n        }\n        const options = metadata.options && metadata.options.rdf\n            ? metadata.options.rdf\n            : rootMetadata.options && rootMetadata.options.rdf\n                ? rootMetadata.options.rdf\n                : undefined;\n        if (!options) {\n            return undefined;\n        }\n        const identifierMember = Array.from(metadata.dataMembers.values()).filter((member) => {\n            return (member &&\n                member.options &&\n                member.options.rdf &&\n                member.options.rdf.identifier);\n        })[0];\n        let uri = undefined;\n        if (identifierMember) {\n            const rdfOptions = identifierMember.options.rdf;\n            uri = rdfOptions.serializer\n                ? rdfOptions.serializer(sourceObject[identifierMember.key], sourceObject.constructor)\n                : sourceObject[identifierMember.key];\n        }\n        uri =\n            uri && !uri.startsWith('http') && serializerOptions.rdf.baseUri\n                ? serializerOptions.rdf.baseUri + uri\n                : N3.DataFactory.blankNode(uri).value;\n        let thing = {\n            value: uri,\n            predicates: options.predicates\n                ? Object.entries(options.predicates)\n                    .map(([k, v]) => {\n                    return { [k]: v.map(N3.DataFactory.namedNode) };\n                })\n                    .reduce((a, b) => {\n                    return Object.assign(Object.assign({}, a), b);\n                })\n                : {},\n        };\n        if (options.serializer) {\n            thing = mergeDeep(thing, options.serializer(sourceObject, serializerOptions.rdf.baseUri));\n        }\n        thing.termType = thing.value.startsWith('http') ? 'NamedNode' : 'BlankNode';\n        if (serializerOptions.root === undefined) {\n            serializerOptions.root = thing;\n        }\n        else if (serializerOptions.root.value === thing.value) {\n            return undefined;\n        }\n        metadata.dataMembers.forEach((member) => {\n            const rootMember = rootMetadata.dataMembers.get(member.key);\n            const memberOptions = member.options && member.options.rdf\n                ? member\n                : rootMember && rootMember.options && rootMember.options.rdf\n                    ? rootMember\n                    : undefined;\n            if (!memberOptions || !memberOptions.options.rdf.predicate) {\n                return;\n            }\n            const object = serializer.convertSingleValue(sourceObject[memberOptions.key], memberOptions.type(), `${memberOptions.name}`, memberOptions, serializerOptions);\n            if (object) {\n                const predicates = memberOptions.options.rdf.predicate;\n                [...(Array.isArray(predicates) ? predicates : [predicates])].forEach((predicateIri) => {\n                    const predicate = thing.predicates[predicateIri] || [];\n                    predicate.push(...(Array.isArray(object) ? object : [object]).filter((s) => s));\n                    thing.predicates[predicateIri] = predicate;\n                });\n            }\n        });\n        return thing;\n    }\n    serializeArray(sourceObject, typeDescriptor, memberName, _, memberOptions, serializerOptions) {\n        return sourceObject.map((obj) => {\n            return this.convertSingleValue(obj, typeDescriptor.elementType, memberName, memberOptions, serializerOptions);\n        });\n    }\n    serializeMap(sourceObject, typeDescriptor, memberName, _, memberOptions, serializerOptions) {\n        return Array.from(sourceObject.values()).map((obj) => {\n            return this.convertSingleValue(obj, typeDescriptor.valueType, memberName, memberOptions, serializerOptions);\n        });\n    }\n    serializeSet(sourceObject, typeDescriptor, memberName, _, memberOptions, serializerOptions) {\n        return Array.from(sourceObject.values()).map((obj) => {\n            return this.convertSingleValue(obj, typeDescriptor.valueType, memberName, memberOptions, serializerOptions);\n        });\n    }\n    serializeLiteral(sourceObject, typeDescriptor, memberName, serializer, memberOptions) {\n        var _a;\n        let xsdDatatype = undefined;\n        const rdfOptions = memberOptions.options.rdf;\n        if (rdfOptions && rdfOptions.datatype) {\n            xsdDatatype = rdfOptions.datatype;\n            switch (rdfOptions.datatype) {\n                case xsd.date:\n                case xsd.dateTime:\n                    return this.serializeDate(sourceObject, typeDescriptor, memberName, serializer, memberOptions);\n            }\n        }\n        else {\n            switch (typeof sourceObject) {\n                case 'bigint':\n                case 'number':\n                    xsdDatatype = xsd.decimal;\n                    break;\n                case 'boolean':\n                    xsdDatatype = xsd.boolean;\n                    break;\n                default:\n                    xsdDatatype = xsd.string;\n                    break;\n            }\n        }\n        const dataTypeNode = this.iriToNode(xsdDatatype);\n        return N3.DataFactory.literal(sourceObject, rdfOptions ? (_a = rdfOptions.language) !== null && _a !== void 0 ? _a : dataTypeNode : dataTypeNode);\n    }\n    serializeDate(sourceObject, typeDescriptor, memberName, serializer, memberOptions) {\n        var _a;\n        const rdfOptions = memberOptions.options.rdf;\n        const xsdDatatype = xsd.dateTime;\n        const dateString = new Date(sourceObject).toISOString();\n        const dataTypeNode = this.iriToNode(xsdDatatype);\n        return N3.DataFactory.literal(dateString, rdfOptions ? (_a = rdfOptions.language) !== null && _a !== void 0 ? _a : dataTypeNode : dataTypeNode);\n    }\n    iriToNode(iri) {\n        return N3.DataFactory.namedNode(iri);\n    }\n}\n//# sourceMappingURL=InternalRDFSerializer.js.map","export const type = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';\nexport const subject = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#subject';\nexport const predicate = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate';\nexport const object = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#object';\nexport const value = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#value';\nexport const first = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#first';\nexport const rest = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#rest';\nexport const language = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#language';\nexport const direction = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#direction';\nexport const Property = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#Property';\nexport const Statement = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement';\nexport const Bag = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag';\nexport const Seq = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq';\nexport const Alt = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#Alt';\nexport const List = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#List';\nexport const CompoundLiteral = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#CompoundLiteral';\nexport const HTML = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#HTML';\nexport const langString = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#langString';\nexport const PlainLiteral = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#PlainLiteral';\nexport const XMLLiteral = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral';\nexport const JSON__workaround = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#JSON';\nexport const nil = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil';\n//# sourceMappingURL=rdf.js.map","import * as geoImport from './geo';\nexport const geo = geoImport;\nimport * as schemaImport from './schema';\nexport const schema = schemaImport;\nimport * as rdfImport from './rdf';\nexport const rdf = rdfImport;\nimport * as rdfsImport from './rdfs';\nexport const rdfs = rdfsImport;\nimport * as vcardImport from './vcard';\nexport const vcard = vcardImport;\nimport * as owlImport from './owl';\nexport const owl = owlImport;\nimport * as timeImport from './time';\nexport const time = timeImport;\nimport * as dctermsImport from './dcterms';\nexport const dcterms = dctermsImport;\nimport * as dcmiImport from './dcmi';\nexport const dcmi = dcmiImport;\nimport * as dqmImport from './dqm';\nexport const dqm = dqmImport;\nimport * as foafImport from './foaf';\nexport const foaf = foafImport;\nimport * as qudtImport from './qudt';\nexport const qudt = qudtImport;\nimport * as qudt_unitImport from './qudt_unit';\nexport const qudt_unit = qudt_unitImport;\nimport * as quantitykindImport from './quantitykind';\nexport const quantitykind = quantitykindImport;\nimport * as sosaImport from './sosa';\nexport const sosa = sosaImport;\nimport * as ssnImport from './ssn';\nexport const ssn = ssnImport;\nimport * as ssnsImport from './ssns';\nexport const ssns = ssnsImport;\nimport * as openhpsImport from './openhps';\nexport const openhps = openhpsImport;\nimport * as ogcImport from './ogc';\nexport const ogc = ogcImport;\n//# sourceMappingURL=index.js.map","import { DataSerializer, Deserializer, } from '@openhps/core';\nimport { xsd } from '../decorators';\nimport { rdf } from '../vocab';\nexport class InternalRDFDeserializer extends Deserializer {\n    constructor() {\n        super(...arguments);\n        this.deserializationStrategy = new Map([\n            [Number, this.deserializeLiteral.bind(this)],\n            [String, this.deserializeLiteral.bind(this)],\n            [Boolean, this.deserializeLiteral.bind(this)],\n            [Date, this.deserializeLiteral.bind(this)],\n            [Array, this.deserializeArray.bind(this)],\n            [Map, this.deserializeMap.bind(this)],\n            [Set, this.deserializeSet.bind(this)],\n        ]);\n    }\n    rdfTypeResolver(sourceObject, knownTypes, knownRDFTypes) {\n        if (sourceObject['predicates'] !== undefined) {\n            const rdfTypes = Object.entries(sourceObject['predicates'])\n                .filter(([k, _]) => k === rdf.type)\n                .map(([_, v]) => v)\n                .flat()\n                .map((v) => v.value);\n            const mappedTypes = rdfTypes\n                .map((type) => knownRDFTypes.get(type))\n                .flat()\n                .map((type) => knownTypes.get(type));\n            return mappedTypes[0];\n        }\n        return Object;\n    }\n    convertSingleValue(sourceObject, typeDescriptor, knownTypes, memberName = 'object', memberOptions, serializerOptions) {\n        if (this.retrievePreserveNull(memberOptions) && sourceObject === null) {\n            return null;\n        }\n        else if (sourceObject === null || sourceObject === undefined) {\n            return;\n        }\n        const deserializer = this.deserializationStrategy.get(typeDescriptor.ctor);\n        if (deserializer !== undefined) {\n            return deserializer(sourceObject, typeDescriptor, knownTypes, memberName, this, memberOptions, serializerOptions);\n        }\n        if (typeof sourceObject === 'object') {\n            return this.deserializeObject(sourceObject, typeDescriptor, knownTypes, memberName, this, serializerOptions);\n        }\n        let error = `Could not deserialize '${memberName}'; don't know how to deserialize type`;\n        if (typeDescriptor.hasFriendlyName()) {\n            error += ` '${typeDescriptor.ctor.name}'`;\n        }\n        this.errorHandler(new TypeError(`${error}.`));\n    }\n    deserializeObject(sourceObject, typeDescriptor, knownTypes, _, deserializer, serializerOptions) {\n        const expectedSelfType = typeDescriptor.ctor;\n        const typeFromRDF = this.rdfTypeResolver(sourceObject, knownTypes, serializerOptions.rdf.knownTypes);\n        const finalType = typeFromRDF || expectedSelfType;\n        const metadata = DataSerializer.getMetadata(finalType);\n        const rootMetadata = DataSerializer.getRootMetadata(finalType);\n        if (!metadata && !rootMetadata) {\n            return undefined;\n        }\n        const options = metadata.options && metadata.options.rdf\n            ? metadata.options.rdf\n            : rootMetadata.options && rootMetadata.options.rdf\n                ? rootMetadata.options.rdf\n                : undefined;\n        if (!options) {\n            return undefined;\n        }\n        const targetObject = options.deserializer\n            ? options.deserializer(sourceObject)\n            : this.instantiateType(finalType);\n        const identifierMember = Array.from(metadata.dataMembers.values()).filter((member) => {\n            return (member &&\n                member.options &&\n                member.options.rdf &&\n                member.options.rdf.identifier);\n        })[0];\n        if (identifierMember) {\n            const rdfOptions = identifierMember.options.rdf;\n            targetObject[identifierMember.key] = rdfOptions.deserializer\n                ? rdfOptions.deserializer(sourceObject, finalType)\n                : sourceObject.value;\n        }\n        metadata.dataMembers.forEach((member) => {\n            const rootMember = rootMetadata.dataMembers.get(member.key);\n            const memberOptions = member.options && member.options.rdf\n                ? member\n                : rootMember && rootMember.options && rootMember.options.rdf\n                    ? rootMember\n                    : undefined;\n            if (!memberOptions || !memberOptions.options.rdf.predicate) {\n                return undefined;\n            }\n            const predicates = memberOptions.options.rdf.predicate;\n            [...(Array.isArray(predicates) ? predicates : [predicates])].forEach((predicateIri) => {\n                if (!sourceObject.predicates[predicateIri]) {\n                    return;\n                }\n                if (memberOptions.type().ctor === Array) {\n                    targetObject[memberOptions.key] = deserializer.convertSingleValue(sourceObject.predicates[predicateIri], memberOptions.type(), knownTypes, memberOptions.name, memberOptions, serializerOptions);\n                }\n                else {\n                    targetObject[memberOptions.key] = sourceObject.predicates[predicateIri]\n                        .map((object) => {\n                        return deserializer.convertSingleValue(object, memberOptions.type(), knownTypes, memberOptions.name, memberOptions, serializerOptions);\n                    })\n                        .filter((item) => this.isInstanceOf(item, memberOptions.type().ctor))[0];\n                }\n            });\n        });\n        return targetObject;\n    }\n    deserializeLiteral(sourceObject, typeDescriptor, knownTypes, memberName, deserializer, memberOptions, serializerOptions) {\n        switch (sourceObject.datatype.value) {\n            case xsd.dateTime:\n                return new Date(sourceObject.value).getTime();\n            default:\n                return sourceObject.value;\n        }\n    }\n    deserializeDate(sourceObject, typeDescriptor, knownTypes, memberName, deserializer, memberOptions, serializerOptions) {\n        return new Date(sourceObject.value);\n    }\n    deserializeArray(sourceObject, typeDescriptor, knownTypes, memberName, deserializer, memberOptions, serializerOptions) {\n        if (!sourceObject) {\n            return [];\n        }\n        return sourceObject\n            .map((object) => {\n            return deserializer.convertSingleValue(object, typeDescriptor.elementType, knownTypes, memberName, memberOptions, serializerOptions);\n        })\n            .filter((val) => this.isInstanceOf(val, typeDescriptor.elementType.ctor));\n    }\n    isInstanceOf(value, constructor) {\n        if (typeof value === 'number') {\n            return constructor === Number;\n        }\n        else if (typeof value === 'string') {\n            return constructor === String;\n        }\n        else if (typeof value === 'boolean') {\n            return constructor === Boolean;\n        }\n        else if (typeof value === 'object') {\n            return value instanceof constructor;\n        }\n        return false;\n    }\n    deserializeMap(sourceObject, typeDescriptor, knownTypes, memberName, deserializer, memberOptions, serializerOptions) {\n        return undefined;\n    }\n    deserializeSet(sourceObject, typeDescriptor, knownTypes, memberName, deserializer, memberOptions, serializerOptions) {\n        return undefined;\n    }\n}\n//# sourceMappingURL=InternalRDFDeserializer.js.map","// **N3Store** objects store N3 quads by graph in memory.\nimport { default as N3DataFactory, termToId, termFromId } from './N3DataFactory';\nimport { Readable } from 'readable-stream';\nimport namespaces from './IRIs';\n\n// ## Constructor\nexport default class N3Store {\n  constructor(quads, options) {\n    // The number of quads is initially zero\n    this._size = 0;\n    // `_graphs` contains subject, predicate, and object indexes per graph\n    this._graphs = Object.create(null);\n    // `_ids` maps entities such as `http://xmlns.com/foaf/0.1/name` to numbers,\n    // saving memory by using only numbers as keys in `_graphs`\n    this._id = 0;\n    this._ids = Object.create(null);\n    this._ids['><'] = 0; // dummy entry, so the first actual key is non-zero\n    this._entities = Object.create(null); // inverse of `_ids`\n    // `_blankNodeIndex` is the index of the last automatically named blank node\n    this._blankNodeIndex = 0;\n\n    // Shift parameters if `quads` is not given\n    if (!options && quads && !quads[0])\n      options = quads, quads = null;\n    options = options || {};\n    this._factory = options.factory || N3DataFactory;\n\n    // Add quads if passed\n    if (quads)\n      this.addQuads(quads);\n  }\n\n  // ## Public properties\n\n  // ### `size` returns the number of quads in the store\n  get size() {\n    // Return the quad count if if was cached\n    let size = this._size;\n    if (size !== null)\n      return size;\n\n    // Calculate the number of quads by counting to the deepest level\n    size = 0;\n    const graphs = this._graphs;\n    let subjects, subject;\n    for (const graphKey in graphs)\n      for (const subjectKey in (subjects = graphs[graphKey].subjects))\n        for (const predicateKey in (subject = subjects[subjectKey]))\n          size += Object.keys(subject[predicateKey]).length;\n    return this._size = size;\n  }\n\n  // ## Private methods\n\n  // ### `_addToIndex` adds a quad to a three-layered index.\n  // Returns if the index has changed, if the entry did not already exist.\n  _addToIndex(index0, key0, key1, key2) {\n    // Create layers as necessary\n    const index1 = index0[key0] || (index0[key0] = {});\n    const index2 = index1[key1] || (index1[key1] = {});\n    // Setting the key to _any_ value signals the presence of the quad\n    const existed = key2 in index2;\n    if (!existed)\n      index2[key2] = null;\n    return !existed;\n  }\n\n  // ### `_removeFromIndex` removes a quad from a three-layered index\n  _removeFromIndex(index0, key0, key1, key2) {\n    // Remove the quad from the index\n    const index1 = index0[key0], index2 = index1[key1];\n    delete index2[key2];\n\n    // Remove intermediary index layers if they are empty\n    for (const key in index2) return;\n    delete index1[key1];\n    for (const key in index1) return;\n    delete index0[key0];\n  }\n\n  // ### `_findInIndex` finds a set of quads in a three-layered index.\n  // The index base is `index0` and the keys at each level are `key0`, `key1`, and `key2`.\n  // Any of these keys can be undefined, which is interpreted as a wildcard.\n  // `name0`, `name1`, and `name2` are the names of the keys at each level,\n  // used when reconstructing the resulting quad\n  // (for instance: _subject_, _predicate_, and _object_).\n  // Finally, `graphId` will be the graph of the created quads.\n  *_findInIndex(index0, key0, key1, key2, name0, name1, name2, graphId) {\n    let tmp, index1, index2;\n    // Depending on the number of variables, keys or reverse index are faster\n    const varCount = !key0 + !key1 + !key2,\n        entityKeys = varCount > 1 ? Object.keys(this._ids) : this._entities;\n    const graph = termFromId(graphId, this._factory);\n\n    // If a key is specified, use only that part of index 0.\n    if (key0) (tmp = index0, index0 = {})[key0] = tmp[key0];\n    for (const value0 in index0) {\n      const entity0 = entityKeys[value0];\n\n      if (index1 = index0[value0]) {\n        // If a key is specified, use only that part of index 1.\n        if (key1) (tmp = index1, index1 = {})[key1] = tmp[key1];\n        for (const value1 in index1) {\n          const entity1 = entityKeys[value1];\n\n          if (index2 = index1[value1]) {\n            // If a key is specified, use only that part of index 2, if it exists.\n            const values = key2 ? (key2 in index2 ? [key2] : []) : Object.keys(index2);\n            // Create quads for all items found in index 2.\n            for (let l = 0; l < values.length; l++) {\n              const parts = { subject: null, predicate: null, object: null };\n              parts[name0] = termFromId(entity0, this._factory);\n              parts[name1] = termFromId(entity1, this._factory);\n              parts[name2] = termFromId(entityKeys[values[l]], this._factory);\n              yield this._factory.quad(parts.subject, parts.predicate, parts.object, graph);\n            }\n          }\n        }\n      }\n    }\n  }\n\n  // ### `_loop` executes the callback on all keys of index 0\n  _loop(index0, callback) {\n    for (const key0 in index0)\n      callback(key0);\n  }\n\n  // ### `_loopByKey0` executes the callback on all keys of a certain entry in index 0\n  _loopByKey0(index0, key0, callback) {\n    let index1, key1;\n    if (index1 = index0[key0]) {\n      for (key1 in index1)\n        callback(key1);\n    }\n  }\n\n  // ### `_loopByKey1` executes the callback on given keys of all entries in index 0\n  _loopByKey1(index0, key1, callback) {\n    let key0, index1;\n    for (key0 in index0) {\n      index1 = index0[key0];\n      if (index1[key1])\n        callback(key0);\n    }\n  }\n\n  // ### `_loopBy2Keys` executes the callback on given keys of certain entries in index 2\n  _loopBy2Keys(index0, key0, key1, callback) {\n    let index1, index2, key2;\n    if ((index1 = index0[key0]) && (index2 = index1[key1])) {\n      for (key2 in index2)\n        callback(key2);\n    }\n  }\n\n  // ### `_countInIndex` counts matching quads in a three-layered index.\n  // The index base is `index0` and the keys at each level are `key0`, `key1`, and `key2`.\n  // Any of these keys can be undefined, which is interpreted as a wildcard.\n  _countInIndex(index0, key0, key1, key2) {\n    let count = 0, tmp, index1, index2;\n\n    // If a key is specified, count only that part of index 0\n    if (key0) (tmp = index0, index0 = {})[key0] = tmp[key0];\n    for (const value0 in index0) {\n      if (index1 = index0[value0]) {\n        // If a key is specified, count only that part of index 1\n        if (key1) (tmp = index1, index1 = {})[key1] = tmp[key1];\n        for (const value1 in index1) {\n          if (index2 = index1[value1]) {\n            // If a key is specified, count the quad if it exists\n            if (key2) (key2 in index2) && count++;\n            // Otherwise, count all quads\n            else count += Object.keys(index2).length;\n          }\n        }\n      }\n    }\n    return count;\n  }\n\n  // ### `_getGraphs` returns an array with the given graph,\n  // or all graphs if the argument is null or undefined.\n  _getGraphs(graph) {\n    if (!isString(graph))\n      return this._graphs;\n    const graphs = {};\n    graphs[graph] = this._graphs[graph];\n    return graphs;\n  }\n\n  // ### `_uniqueEntities` returns a function that accepts an entity ID\n  // and passes the corresponding entity to callback if it hasn't occurred before.\n  _uniqueEntities(callback) {\n    const uniqueIds = Object.create(null);\n    return id => {\n      if (!(id in uniqueIds)) {\n        uniqueIds[id] = true;\n        callback(termFromId(this._entities[id], this._factory));\n      }\n    };\n  }\n\n  // ## Public methods\n\n  // ### `add` adds the specified quad to the dataset.\n  // Returns the dataset instance it was called on.\n  // Existing quads, as defined in Quad.equals, will be ignored.\n  add(quad) {\n    this.addQuad(quad);\n    return this;\n  }\n\n  // ### `addQuad` adds a new quad to the store.\n  // Returns if the quad index has changed, if the quad did not already exist.\n  addQuad(subject, predicate, object, graph) {\n    // Shift arguments if a quad object is given instead of components\n    if (!predicate)\n      graph = subject.graph, object = subject.object,\n        predicate = subject.predicate, subject = subject.subject;\n\n    // Convert terms to internal string representation\n    subject = termToId(subject);\n    predicate = termToId(predicate);\n    object = termToId(object);\n    graph = termToId(graph);\n\n    // Find the graph that will contain the triple\n    let graphItem = this._graphs[graph];\n    // Create the graph if it doesn't exist yet\n    if (!graphItem) {\n      graphItem = this._graphs[graph] = { subjects: {}, predicates: {}, objects: {} };\n      // Freezing a graph helps subsequent `add` performance,\n      // and properties will never be modified anyway\n      Object.freeze(graphItem);\n    }\n\n    // Since entities can often be long IRIs, we avoid storing them in every index.\n    // Instead, we have a separate index that maps entities to numbers,\n    // which are then used as keys in the other indexes.\n    const ids = this._ids;\n    const entities = this._entities;\n    subject   = ids[subject]   || (ids[entities[++this._id] = subject]   = this._id);\n    predicate = ids[predicate] || (ids[entities[++this._id] = predicate] = this._id);\n    object    = ids[object]    || (ids[entities[++this._id] = object]    = this._id);\n\n    const changed = this._addToIndex(graphItem.subjects,   subject,   predicate, object);\n    this._addToIndex(graphItem.predicates, predicate, object,    subject);\n    this._addToIndex(graphItem.objects,    object,    subject,   predicate);\n\n    // The cached quad count is now invalid\n    this._size = null;\n    return changed;\n  }\n\n  // ### `addQuads` adds multiple quads to the store\n  addQuads(quads) {\n    for (let i = 0; i < quads.length; i++)\n      this.addQuad(quads[i]);\n  }\n\n  // ### `delete` removes the specified quad from the dataset.\n  // Returns the dataset instance it was called on.\n  delete(quad) {\n    this.removeQuad(quad);\n    return this;\n  }\n\n  // ### `has` determines whether a dataset includes a certain quad or quad pattern.\n  has(subjectOrQuad, predicate, object, graph) {\n    if (subjectOrQuad && subjectOrQuad.subject)\n      ({ subject: subjectOrQuad, predicate, object, graph } = subjectOrQuad);\n    return !this.readQuads(subjectOrQuad, predicate, object, graph).next().done;\n  }\n\n  // ### `import` adds a stream of quads to the store\n  import(stream) {\n    stream.on('data', quad => { this.addQuad(quad); });\n    return stream;\n  }\n\n  // ### `removeQuad` removes a quad from the store if it exists\n  removeQuad(subject, predicate, object, graph) {\n    // Shift arguments if a quad object is given instead of components\n    if (!predicate)\n      graph = subject.graph, object = subject.object,\n        predicate = subject.predicate, subject = subject.subject;\n\n    // Convert terms to internal string representation\n    subject = termToId(subject);\n    predicate = termToId(predicate);\n    object = termToId(object);\n    graph = termToId(graph);\n\n    // Find internal identifiers for all components\n    // and verify the quad exists.\n    const ids = this._ids, graphs = this._graphs;\n    let graphItem, subjects, predicates;\n    if (!(subject    = ids[subject]) || !(predicate = ids[predicate]) ||\n        !(object     = ids[object])  || !(graphItem = graphs[graph])  ||\n        !(subjects   = graphItem.subjects[subject]) ||\n        !(predicates = subjects[predicate]) ||\n        !(object in predicates))\n      return false;\n\n    // Remove it from all indexes\n    this._removeFromIndex(graphItem.subjects,   subject,   predicate, object);\n    this._removeFromIndex(graphItem.predicates, predicate, object,    subject);\n    this._removeFromIndex(graphItem.objects,    object,    subject,   predicate);\n    if (this._size !== null) this._size--;\n\n    // Remove the graph if it is empty\n    for (subject in graphItem.subjects) return true;\n    delete graphs[graph];\n    return true;\n  }\n\n  // ### `removeQuads` removes multiple quads from the store\n  removeQuads(quads) {\n    for (let i = 0; i < quads.length; i++)\n      this.removeQuad(quads[i]);\n  }\n\n  // ### `remove` removes a stream of quads from the store\n  remove(stream) {\n    stream.on('data', quad => { this.removeQuad(quad); });\n    return stream;\n  }\n\n  // ### `removeMatches` removes all matching quads from the store\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  removeMatches(subject, predicate, object, graph) {\n    const stream = new Readable({ objectMode: true });\n\n    stream._read = () => {\n      for (const quad of this.readQuads(subject, predicate, object, graph))\n        stream.push(quad);\n      stream.push(null);\n    };\n\n    return this.remove(stream);\n  }\n\n  // ### `deleteGraph` removes all triples with the given graph from the store\n  deleteGraph(graph) {\n    return this.removeMatches(null, null, null, graph);\n  }\n\n  // ### `getQuads` returns an array of quads matching a pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  getQuads(subject, predicate, object, graph) {\n    return [...this.readQuads(subject, predicate, object, graph)];\n  }\n\n  // ### `readQuads` returns an generator of quads matching a pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  *readQuads(subject, predicate, object, graph) {\n    // Convert terms to internal string representation\n    subject = subject && termToId(subject);\n    predicate = predicate && termToId(predicate);\n    object = object && termToId(object);\n    graph = graph && termToId(graph);\n\n    const graphs = this._getGraphs(graph), ids = this._ids;\n    let content, subjectId, predicateId, objectId;\n\n    // Translate IRIs to internal index keys.\n    if (isString(subject)   && !(subjectId   = ids[subject])   ||\n        isString(predicate) && !(predicateId = ids[predicate]) ||\n        isString(object)    && !(objectId    = ids[object]))\n      return;\n\n    for (const graphId in graphs) {\n      // Only if the specified graph contains triples, there can be results\n      if (content = graphs[graphId]) {\n        // Choose the optimal index, based on what fields are present\n        if (subjectId) {\n          if (objectId)\n            // If subject and object are given, the object index will be the fastest\n            yield* this._findInIndex(content.objects, objectId, subjectId, predicateId,\n                              'object', 'subject', 'predicate', graphId, null, true);\n          else\n            // If only subject and possibly predicate are given, the subject index will be the fastest\n            yield* this._findInIndex(content.subjects, subjectId, predicateId, null,\n                              'subject', 'predicate', 'object', graphId, null, true);\n        }\n        else if (predicateId)\n          // If only predicate and possibly object are given, the predicate index will be the fastest\n          yield* this._findInIndex(content.predicates, predicateId, objectId, null,\n                            'predicate', 'object', 'subject', graphId, null, true);\n        else if (objectId)\n          // If only object is given, the object index will be the fastest\n          yield* this._findInIndex(content.objects, objectId, null, null,\n                            'object', 'subject', 'predicate', graphId, null, true);\n        else\n          // If nothing is given, iterate subjects and predicates first\n          yield* this._findInIndex(content.subjects, null, null, null,\n                            'subject', 'predicate', 'object', graphId, null, true);\n      }\n    }\n  }\n\n  // ### `match` returns a new dataset that is comprised of all quads in the current instance matching the given arguments.\n  // The logic described in Quad Matching is applied for each quad in this dataset to check if it should be included in the output dataset.\n  // Note: This method always returns a new DatasetCore, even if that dataset contains no quads.\n  // Note: Since a DatasetCore is an unordered set, the order of the quads within the returned sequence is arbitrary.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  // For backwards compatibility, the object return also implements the Readable stream interface.\n  match(subject, predicate, object, graph) {\n    return new DatasetCoreAndReadableStream(this, subject, predicate, object, graph);\n  }\n\n  // ### `countQuads` returns the number of quads matching a pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  countQuads(subject, predicate, object, graph) {\n    // Convert terms to internal string representation\n    subject = subject && termToId(subject);\n    predicate = predicate && termToId(predicate);\n    object = object && termToId(object);\n    graph = graph && termToId(graph);\n\n    const graphs = this._getGraphs(graph), ids = this._ids;\n    let count = 0, content, subjectId, predicateId, objectId;\n\n    // Translate IRIs to internal index keys.\n    if (isString(subject)   && !(subjectId   = ids[subject])   ||\n        isString(predicate) && !(predicateId = ids[predicate]) ||\n        isString(object)    && !(objectId    = ids[object]))\n      return 0;\n\n    for (const graphId in graphs) {\n      // Only if the specified graph contains triples, there can be results\n      if (content = graphs[graphId]) {\n        // Choose the optimal index, based on what fields are present\n        if (subject) {\n          if (object)\n            // If subject and object are given, the object index will be the fastest\n            count += this._countInIndex(content.objects, objectId, subjectId, predicateId);\n          else\n            // If only subject and possibly predicate are given, the subject index will be the fastest\n            count += this._countInIndex(content.subjects, subjectId, predicateId, objectId);\n        }\n        else if (predicate) {\n          // If only predicate and possibly object are given, the predicate index will be the fastest\n          count += this._countInIndex(content.predicates, predicateId, objectId, subjectId);\n        }\n        else {\n          // If only object is possibly given, the object index will be the fastest\n          count += this._countInIndex(content.objects, objectId, subjectId, predicateId);\n        }\n      }\n    }\n    return count;\n  }\n\n  // ### `forEach` executes the callback on all quads.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  forEach(callback, subject, predicate, object, graph) {\n    this.some(quad => {\n      callback(quad);\n      return false;\n    }, subject, predicate, object, graph);\n  }\n\n  // ### `every` executes the callback on all quads,\n  // and returns `true` if it returns truthy for all them.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  every(callback, subject, predicate, object, graph) {\n    let some = false;\n    const every = !this.some(quad => {\n      some = true;\n      return !callback(quad);\n    }, subject, predicate, object, graph);\n    return some && every;\n  }\n\n  // ### `some` executes the callback on all quads,\n  // and returns `true` if it returns truthy for any of them.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  some(callback, subject, predicate, object, graph) {\n    for (const quad of this.readQuads(subject, predicate, object, graph))\n      if (callback(quad))\n        return true;\n    return false;\n  }\n\n  // ### `getSubjects` returns all subjects that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  getSubjects(predicate, object, graph) {\n    const results = [];\n    this.forSubjects(s => { results.push(s); }, predicate, object, graph);\n    return results;\n  }\n\n  // ### `forSubjects` executes the callback on all subjects that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  forSubjects(callback, predicate, object, graph) {\n    // Convert terms to internal string representation\n    predicate = predicate && termToId(predicate);\n    object = object && termToId(object);\n    graph = graph && termToId(graph);\n\n    const ids = this._ids, graphs = this._getGraphs(graph);\n    let content, predicateId, objectId;\n    callback = this._uniqueEntities(callback);\n\n    // Translate IRIs to internal index keys.\n    if (isString(predicate) && !(predicateId = ids[predicate]) ||\n        isString(object)    && !(objectId    = ids[object]))\n      return;\n\n    for (graph in graphs) {\n      // Only if the specified graph contains triples, there can be results\n      if (content = graphs[graph]) {\n        // Choose optimal index based on which fields are wildcards\n        if (predicateId) {\n          if (objectId)\n            // If predicate and object are given, the POS index is best.\n            this._loopBy2Keys(content.predicates, predicateId, objectId, callback);\n          else\n            // If only predicate is given, the SPO index is best.\n            this._loopByKey1(content.subjects, predicateId, callback);\n        }\n        else if (objectId)\n          // If only object is given, the OSP index is best.\n          this._loopByKey0(content.objects, objectId, callback);\n        else\n          // If no params given, iterate all the subjects\n          this._loop(content.subjects, callback);\n      }\n    }\n  }\n\n  // ### `getPredicates` returns all predicates that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  getPredicates(subject, object, graph) {\n    const results = [];\n    this.forPredicates(p => { results.push(p); }, subject, object, graph);\n    return results;\n  }\n\n  // ### `forPredicates` executes the callback on all predicates that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  forPredicates(callback, subject, object, graph) {\n    // Convert terms to internal string representation\n    subject = subject && termToId(subject);\n    object = object && termToId(object);\n    graph = graph && termToId(graph);\n\n    const ids = this._ids, graphs = this._getGraphs(graph);\n    let content, subjectId, objectId;\n    callback = this._uniqueEntities(callback);\n\n    // Translate IRIs to internal index keys.\n    if (isString(subject) && !(subjectId = ids[subject]) ||\n        isString(object)  && !(objectId  = ids[object]))\n      return;\n\n    for (graph in graphs) {\n      // Only if the specified graph contains triples, there can be results\n      if (content = graphs[graph]) {\n        // Choose optimal index based on which fields are wildcards\n        if (subjectId) {\n          if (objectId)\n            // If subject and object are given, the OSP index is best.\n            this._loopBy2Keys(content.objects, objectId, subjectId, callback);\n          else\n            // If only subject is given, the SPO index is best.\n            this._loopByKey0(content.subjects, subjectId, callback);\n        }\n        else if (objectId)\n          // If only object is given, the POS index is best.\n          this._loopByKey1(content.predicates, objectId, callback);\n        else\n          // If no params given, iterate all the predicates.\n          this._loop(content.predicates, callback);\n      }\n    }\n  }\n\n  // ### `getObjects` returns all objects that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  getObjects(subject, predicate, graph) {\n    const results = [];\n    this.forObjects(o => { results.push(o); }, subject, predicate, graph);\n    return results;\n  }\n\n  // ### `forObjects` executes the callback on all objects that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  forObjects(callback, subject, predicate, graph) {\n    // Convert terms to internal string representation\n    subject = subject && termToId(subject);\n    predicate = predicate && termToId(predicate);\n    graph = graph && termToId(graph);\n\n    const ids = this._ids, graphs = this._getGraphs(graph);\n    let content, subjectId, predicateId;\n    callback = this._uniqueEntities(callback);\n\n    // Translate IRIs to internal index keys.\n    if (isString(subject)   && !(subjectId   = ids[subject]) ||\n        isString(predicate) && !(predicateId = ids[predicate]))\n      return;\n\n    for (graph in graphs) {\n      // Only if the specified graph contains triples, there can be results\n      if (content = graphs[graph]) {\n        // Choose optimal index based on which fields are wildcards\n        if (subjectId) {\n          if (predicateId)\n            // If subject and predicate are given, the SPO index is best.\n            this._loopBy2Keys(content.subjects, subjectId, predicateId, callback);\n          else\n            // If only subject is given, the OSP index is best.\n            this._loopByKey1(content.objects, subjectId, callback);\n        }\n        else if (predicateId)\n          // If only predicate is given, the POS index is best.\n          this._loopByKey0(content.predicates, predicateId, callback);\n        else\n          // If no params given, iterate all the objects.\n          this._loop(content.objects, callback);\n      }\n    }\n  }\n\n  // ### `getGraphs` returns all graphs that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  getGraphs(subject, predicate, object) {\n    const results = [];\n    this.forGraphs(g => { results.push(g); }, subject, predicate, object);\n    return results;\n  }\n\n  // ### `forGraphs` executes the callback on all graphs that match the pattern.\n  // Setting any field to `undefined` or `null` indicates a wildcard.\n  forGraphs(callback, subject, predicate, object) {\n    for (const graph in this._graphs) {\n      this.some(quad => {\n        callback(quad.graph);\n        return true; // Halt iteration of some()\n      }, subject, predicate, object, graph);\n    }\n  }\n\n  // ### `createBlankNode` creates a new blank node, returning its name\n  createBlankNode(suggestedName) {\n    let name, index;\n    // Generate a name based on the suggested name\n    if (suggestedName) {\n      name = suggestedName = `_:${suggestedName}`, index = 1;\n      while (this._ids[name])\n        name = suggestedName + index++;\n    }\n    // Generate a generic blank node name\n    else {\n      do { name = `_:b${this._blankNodeIndex++}`; }\n      while (this._ids[name]);\n    }\n    // Add the blank node to the entities, avoiding the generation of duplicates\n    this._ids[name] = ++this._id;\n    this._entities[this._id] = name;\n    return this._factory.blankNode(name.substr(2));\n  }\n\n  // ### `extractLists` finds and removes all list triples\n  // and returns the items per list.\n  extractLists({ remove = false, ignoreErrors = false } = {}) {\n    const lists = {}; // has scalar keys so could be a simple Object\n    const onError = ignoreErrors ? (() => true) :\n                  ((node, message) => { throw new Error(`${node.value} ${message}`); });\n\n    // Traverse each list from its tail\n    const tails = this.getQuads(null, namespaces.rdf.rest, namespaces.rdf.nil, null);\n    const toRemove = remove ? [...tails] : [];\n    tails.forEach(tailQuad => {\n      const items = [];             // the members found as objects of rdf:first quads\n      let malformed = false;      // signals whether the current list is malformed\n      let head;                   // the head of the list (_:b1 in above example)\n      let headPos;                // set to subject or object when head is set\n      const graph = tailQuad.graph; // make sure list is in exactly one graph\n\n      // Traverse the list from tail to end\n      let current = tailQuad.subject;\n      while (current && !malformed) {\n        const objectQuads = this.getQuads(null, null, current, null);\n        const subjectQuads = this.getQuads(current, null, null, null);\n        let quad, first = null, rest = null, parent = null;\n\n        // Find the first and rest of this list node\n        for (let i = 0; i < subjectQuads.length && !malformed; i++) {\n          quad = subjectQuads[i];\n          if (!quad.graph.equals(graph))\n            malformed = onError(current, 'not confined to single graph');\n          else if (head)\n            malformed = onError(current, 'has non-list arcs out');\n\n          // one rdf:first\n          else if (quad.predicate.value === namespaces.rdf.first) {\n            if (first)\n              malformed = onError(current, 'has multiple rdf:first arcs');\n            else\n              toRemove.push(first = quad);\n          }\n\n          // one rdf:rest\n          else if (quad.predicate.value === namespaces.rdf.rest) {\n            if (rest)\n              malformed = onError(current, 'has multiple rdf:rest arcs');\n            else\n              toRemove.push(rest = quad);\n          }\n\n          // alien triple\n          else if (objectQuads.length)\n            malformed = onError(current, 'can\\'t be subject and object');\n          else {\n            head = quad; // e.g. { (1 2 3) :p :o }\n            headPos = 'subject';\n          }\n        }\n\n        // { :s :p (1 2) } arrives here with no head\n        // { (1 2) :p :o } arrives here with head set to the list.\n        for (let i = 0; i < objectQuads.length && !malformed; ++i) {\n          quad = objectQuads[i];\n          if (head)\n            malformed = onError(current, 'can\\'t have coreferences');\n          // one rdf:rest\n          else if (quad.predicate.value === namespaces.rdf.rest) {\n            if (parent)\n              malformed = onError(current, 'has incoming rdf:rest arcs');\n            else\n              parent = quad;\n          }\n          else {\n            head = quad; // e.g. { :s :p (1 2) }\n            headPos = 'object';\n          }\n        }\n\n        // Store the list item and continue with parent\n        if (!first)\n          malformed = onError(current, 'has no list head');\n        else\n          items.unshift(first.object);\n        current = parent && parent.subject;\n      }\n\n      // Don't remove any quads if the list is malformed\n      if (malformed)\n        remove = false;\n      // Store the list under the value of its head\n      else if (head)\n        lists[head[headPos].value] = items;\n    });\n\n    // Remove list quads if requested\n    if (remove)\n      this.removeQuads(toRemove);\n    return lists;\n  }\n\n  // ### Store is an iterable.\n  // Can be used where iterables are expected: for...of loops, array spread operator,\n  // `yield*`, and destructuring assignment (order is not guaranteed).\n  *[Symbol.iterator]() {\n    yield* this.readQuads();\n  }\n}\n\n// Determines whether the argument is a string\nfunction isString(s) {\n  return typeof s === 'string' || s instanceof String;\n}\n\n/**\n * A class that implements both DatasetCore and Readable.\n */\nclass DatasetCoreAndReadableStream extends Readable {\n  constructor(n3Store, subject, predicate, object, graph) {\n    super({ objectMode: true });\n    Object.assign(this, { n3Store, subject, predicate, object, graph });\n  }\n\n  get filtered() {\n    if (!this._filtered) {\n      const { n3Store, graph, object, predicate, subject } = this;\n      const quads = n3Store.getQuads(subject, predicate, object, graph);\n      this._filtered = new N3Store(quads, { factory: n3Store._factory });\n    }\n    return this._filtered;\n  }\n  get size() {\n    return this.filtered.size;\n  }\n\n  _read() {\n    for (const quad of this)\n      this.push(quad);\n    this.push(null);\n  }\n\n  add(quad) {\n    return this.filtered.add(quad);\n  }\n\n  delete(quad) {\n    return this.filtered.delete(quad);\n  }\n\n  has(quad) {\n    return this.filtered.has(quad);\n  }\n\n  match(subject, predicate, object, graph) {\n    return new DatasetCoreAndReadableStream(this.filtered, subject, predicate, object, graph);\n  }\n\n  *[Symbol.iterator]() {\n    yield* this._filtered || this.n3Store.readQuads(this.subject, this.predicate, this.object, this.graph);\n  }\n}\n","// **N3Writer** writes N3 documents.\nimport namespaces from './IRIs';\nimport { default as N3DataFactory, Term } from './N3DataFactory';\nimport { isDefaultGraph } from './N3Util';\n\nconst DEFAULTGRAPH = N3DataFactory.defaultGraph();\n\nconst { rdf, xsd } = namespaces;\n\n// Characters in literals that require escaping\nconst escape    = /[\"\\\\\\t\\n\\r\\b\\f\\u0000-\\u0019\\ud800-\\udbff]/,\n    escapeAll = /[\"\\\\\\t\\n\\r\\b\\f\\u0000-\\u0019]|[\\ud800-\\udbff][\\udc00-\\udfff]/g,\n    escapedCharacters = {\n      '\\\\': '\\\\\\\\', '\"': '\\\\\"', '\\t': '\\\\t',\n      '\\n': '\\\\n', '\\r': '\\\\r', '\\b': '\\\\b', '\\f': '\\\\f',\n    };\n\n// ## Placeholder class to represent already pretty-printed terms\nclass SerializedTerm extends Term {\n  // Pretty-printed nodes are not equal to any other node\n  // (e.g., [] does not equal [])\n  equals() {\n    return false;\n  }\n}\n\n// ## Constructor\nexport default class N3Writer {\n  constructor(outputStream, options) {\n    // ### `_prefixRegex` matches a prefixed name or IRI that begins with one of the added prefixes\n    this._prefixRegex = /$0^/;\n\n    // Shift arguments if the first argument is not a stream\n    if (outputStream && typeof outputStream.write !== 'function')\n      options = outputStream, outputStream = null;\n    options = options || {};\n    this._lists = options.lists;\n\n    // If no output stream given, send the output as string through the end callback\n    if (!outputStream) {\n      let output = '';\n      this._outputStream = {\n        write(chunk, encoding, done) { output += chunk; done && done(); },\n        end: done => { done && done(null, output); },\n      };\n      this._endStream = true;\n    }\n    else {\n      this._outputStream = outputStream;\n      this._endStream = options.end === undefined ? true : !!options.end;\n    }\n\n    // Initialize writer, depending on the format\n    this._subject = null;\n    if (!(/triple|quad/i).test(options.format)) {\n      this._lineMode = false;\n      this._graph = DEFAULTGRAPH;\n      this._prefixIRIs = Object.create(null);\n      options.prefixes && this.addPrefixes(options.prefixes);\n      if (options.baseIRI) {\n        this._baseMatcher = new RegExp(`^${escapeRegex(options.baseIRI)\n            }${options.baseIRI.endsWith('/') ? '' : '[#?]'}`);\n        this._baseLength = options.baseIRI.length;\n      }\n    }\n    else {\n      this._lineMode = true;\n      this._writeQuad = this._writeQuadLine;\n    }\n  }\n\n  // ## Private methods\n\n  // ### Whether the current graph is the default graph\n  get _inDefaultGraph() {\n    return DEFAULTGRAPH.equals(this._graph);\n  }\n\n  // ### `_write` writes the argument to the output stream\n  _write(string, callback) {\n    this._outputStream.write(string, 'utf8', callback);\n  }\n\n  // ### `_writeQuad` writes the quad to the output stream\n  _writeQuad(subject, predicate, object, graph, done) {\n    try {\n      // Write the graph's label if it has changed\n      if (!graph.equals(this._graph)) {\n        // Close the previous graph and start the new one\n        this._write((this._subject === null ? '' : (this._inDefaultGraph ? '.\\n' : '\\n}\\n')) +\n                    (DEFAULTGRAPH.equals(graph) ? '' : `${this._encodeIriOrBlank(graph)} {\\n`));\n        this._graph = graph;\n        this._subject = null;\n      }\n      // Don't repeat the subject if it's the same\n      if (subject.equals(this._subject)) {\n        // Don't repeat the predicate if it's the same\n        if (predicate.equals(this._predicate))\n          this._write(`, ${this._encodeObject(object)}`, done);\n        // Same subject, different predicate\n        else\n          this._write(`;\\n    ${\n                      this._encodePredicate(this._predicate = predicate)} ${\n                      this._encodeObject(object)}`, done);\n      }\n      // Different subject; write the whole quad\n      else\n        this._write(`${(this._subject === null ? '' : '.\\n') +\n                    this._encodeSubject(this._subject = subject)} ${\n                    this._encodePredicate(this._predicate = predicate)} ${\n                    this._encodeObject(object)}`, done);\n    }\n    catch (error) { done && done(error); }\n  }\n\n  // ### `_writeQuadLine` writes the quad to the output stream as a single line\n  _writeQuadLine(subject, predicate, object, graph, done) {\n    // Write the quad without prefixes\n    delete this._prefixMatch;\n    this._write(this.quadToString(subject, predicate, object, graph), done);\n  }\n\n  // ### `quadToString` serializes a quad as a string\n  quadToString(subject, predicate, object, graph) {\n    return  `${this._encodeSubject(subject)} ${\n            this._encodeIriOrBlank(predicate)} ${\n            this._encodeObject(object)\n            }${graph && graph.value ? ` ${this._encodeIriOrBlank(graph)} .\\n` : ' .\\n'}`;\n  }\n\n  // ### `quadsToString` serializes an array of quads as a string\n  quadsToString(quads) {\n    return quads.map(t => {\n      return this.quadToString(t.subject, t.predicate, t.object, t.graph);\n    }).join('');\n  }\n\n  // ### `_encodeSubject` represents a subject\n  _encodeSubject(entity) {\n    return entity.termType === 'Quad' ?\n      this._encodeQuad(entity) : this._encodeIriOrBlank(entity);\n  }\n\n  // ### `_encodeIriOrBlank` represents an IRI or blank node\n  _encodeIriOrBlank(entity) {\n    // A blank node or list is represented as-is\n    if (entity.termType !== 'NamedNode') {\n      // If it is a list head, pretty-print it\n      if (this._lists && (entity.value in this._lists))\n        entity = this.list(this._lists[entity.value]);\n      return 'id' in entity ? entity.id : `_:${entity.value}`;\n    }\n    let iri = entity.value;\n    // Use relative IRIs if requested and possible\n    if (this._baseMatcher && this._baseMatcher.test(iri))\n      iri = iri.substr(this._baseLength);\n    // Escape special characters\n    if (escape.test(iri))\n      iri = iri.replace(escapeAll, characterReplacer);\n    // Try to represent the IRI as prefixed name\n    const prefixMatch = this._prefixRegex.exec(iri);\n    return !prefixMatch ? `<${iri}>` :\n           (!prefixMatch[1] ? iri : this._prefixIRIs[prefixMatch[1]] + prefixMatch[2]);\n  }\n\n  // ### `_encodeLiteral` represents a literal\n  _encodeLiteral(literal) {\n    // Escape special characters\n    let value = literal.value;\n    if (escape.test(value))\n      value = value.replace(escapeAll, characterReplacer);\n\n    // Write a language-tagged literal\n    if (literal.language)\n      return `\"${value}\"@${literal.language}`;\n\n    // Write dedicated literals per data type\n    if (this._lineMode) {\n      // Only abbreviate strings in N-Triples or N-Quads\n      if (literal.datatype.value === xsd.string)\n        return `\"${value}\"`;\n    }\n    else {\n      // Use common datatype abbreviations in Turtle or TriG\n      switch (literal.datatype.value) {\n      case xsd.string:\n        return `\"${value}\"`;\n      case xsd.boolean:\n        if (value === 'true' || value === 'false')\n          return value;\n        break;\n      case xsd.integer:\n        if (/^[+-]?\\d+$/.test(value))\n          return value;\n        break;\n      case xsd.decimal:\n        if (/^[+-]?\\d*\\.\\d+$/.test(value))\n          return value;\n        break;\n      case xsd.double:\n        if (/^[+-]?(?:\\d+\\.\\d*|\\.?\\d+)[eE][+-]?\\d+$/.test(value))\n          return value;\n        break;\n      }\n    }\n\n    // Write a regular datatyped literal\n    return `\"${value}\"^^${this._encodeIriOrBlank(literal.datatype)}`;\n  }\n\n  // ### `_encodePredicate` represents a predicate\n  _encodePredicate(predicate) {\n    return predicate.value === rdf.type ? 'a' : this._encodeIriOrBlank(predicate);\n  }\n\n  // ### `_encodeObject` represents an object\n  _encodeObject(object) {\n    switch (object.termType) {\n    case 'Quad':\n      return this._encodeQuad(object);\n    case 'Literal':\n      return this._encodeLiteral(object);\n    default:\n      return this._encodeIriOrBlank(object);\n    }\n  }\n\n  // ### `_encodeQuad` encodes an RDF* quad\n  _encodeQuad({ subject, predicate, object, graph }) {\n    return `<<${\n      this._encodeSubject(subject)} ${\n      this._encodePredicate(predicate)} ${\n      this._encodeObject(object)}${\n      isDefaultGraph(graph) ? '' : ` ${this._encodeIriOrBlank(graph)}`}>>`;\n  }\n\n  // ### `_blockedWrite` replaces `_write` after the writer has been closed\n  _blockedWrite() {\n    throw new Error('Cannot write because the writer has been closed.');\n  }\n\n  // ### `addQuad` adds the quad to the output stream\n  addQuad(subject, predicate, object, graph, done) {\n    // The quad was given as an object, so shift parameters\n    if (object === undefined)\n      this._writeQuad(subject.subject, subject.predicate, subject.object, subject.graph, predicate);\n    // The optional `graph` parameter was not provided\n    else if (typeof graph === 'function')\n      this._writeQuad(subject, predicate, object, DEFAULTGRAPH, graph);\n    // The `graph` parameter was provided\n    else\n      this._writeQuad(subject, predicate, object, graph || DEFAULTGRAPH, done);\n  }\n\n  // ### `addQuads` adds the quads to the output stream\n  addQuads(quads) {\n    for (let i = 0; i < quads.length; i++)\n      this.addQuad(quads[i]);\n  }\n\n  // ### `addPrefix` adds the prefix to the output stream\n  addPrefix(prefix, iri, done) {\n    const prefixes = {};\n    prefixes[prefix] = iri;\n    this.addPrefixes(prefixes, done);\n  }\n\n  // ### `addPrefixes` adds the prefixes to the output stream\n  addPrefixes(prefixes, done) {\n    // Ignore prefixes if not supported by the serialization\n    if (!this._prefixIRIs)\n      return done && done();\n\n    // Write all new prefixes\n    let hasPrefixes = false;\n    for (let prefix in prefixes) {\n      let iri = prefixes[prefix];\n      if (typeof iri !== 'string')\n        iri = iri.value;\n      hasPrefixes = true;\n      // Finish a possible pending quad\n      if (this._subject !== null) {\n        this._write(this._inDefaultGraph ? '.\\n' : '\\n}\\n');\n        this._subject = null, this._graph = '';\n      }\n      // Store and write the prefix\n      this._prefixIRIs[iri] = (prefix += ':');\n      this._write(`@prefix ${prefix} <${iri}>.\\n`);\n    }\n    // Recreate the prefix matcher\n    if (hasPrefixes) {\n      let IRIlist = '', prefixList = '';\n      for (const prefixIRI in this._prefixIRIs) {\n        IRIlist += IRIlist ? `|${prefixIRI}` : prefixIRI;\n        prefixList += (prefixList ? '|' : '') + this._prefixIRIs[prefixIRI];\n      }\n      IRIlist = escapeRegex(IRIlist, /[\\]\\/\\(\\)\\*\\+\\?\\.\\\\\\$]/g, '\\\\$&');\n      this._prefixRegex = new RegExp(`^(?:${prefixList})[^\\/]*$|` +\n                                     `^(${IRIlist})([a-zA-Z][\\\\-_a-zA-Z0-9]*)$`);\n    }\n    // End a prefix block with a newline\n    this._write(hasPrefixes ? '\\n' : '', done);\n  }\n\n  // ### `blank` creates a blank node with the given content\n  blank(predicate, object) {\n    let children = predicate, child, length;\n    // Empty blank node\n    if (predicate === undefined)\n      children = [];\n    // Blank node passed as blank(Term(\"predicate\"), Term(\"object\"))\n    else if (predicate.termType)\n      children = [{ predicate: predicate, object: object }];\n    // Blank node passed as blank({ predicate: predicate, object: object })\n    else if (!('length' in predicate))\n      children = [predicate];\n\n    switch (length = children.length) {\n    // Generate an empty blank node\n    case 0:\n      return new SerializedTerm('[]');\n    // Generate a non-nested one-triple blank node\n    case 1:\n      child = children[0];\n      if (!(child.object instanceof SerializedTerm))\n        return new SerializedTerm(`[ ${this._encodePredicate(child.predicate)} ${\n                                  this._encodeObject(child.object)} ]`);\n    // Generate a multi-triple or nested blank node\n    default:\n      let contents = '[';\n      // Write all triples in order\n      for (let i = 0; i < length; i++) {\n        child = children[i];\n        // Write only the object is the predicate is the same as the previous\n        if (child.predicate.equals(predicate))\n          contents += `, ${this._encodeObject(child.object)}`;\n        // Otherwise, write the predicate and the object\n        else {\n          contents += `${(i ? ';\\n  ' : '\\n  ') +\n                      this._encodePredicate(child.predicate)} ${\n                      this._encodeObject(child.object)}`;\n          predicate = child.predicate;\n        }\n      }\n      return new SerializedTerm(`${contents}\\n]`);\n    }\n  }\n\n  // ### `list` creates a list node with the given content\n  list(elements) {\n    const length = elements && elements.length || 0, contents = new Array(length);\n    for (let i = 0; i < length; i++)\n      contents[i] = this._encodeObject(elements[i]);\n    return new SerializedTerm(`(${contents.join(' ')})`);\n  }\n\n  // ### `end` signals the end of the output stream\n  end(done) {\n    // Finish a possible pending quad\n    if (this._subject !== null) {\n      this._write(this._inDefaultGraph ? '.\\n' : '\\n}\\n');\n      this._subject = null;\n    }\n    // Disallow further writing\n    this._write = this._blockedWrite;\n\n    // Try to end the underlying stream, ensuring done is called exactly one time\n    let singleDone = done && ((error, result) => { singleDone = null, done(error, result); });\n    if (this._endStream) {\n      try { return this._outputStream.end(singleDone); }\n      catch (error) { /* error closing stream */ }\n    }\n    singleDone && singleDone();\n  }\n}\n\n// Replaces a character by its escaped version\nfunction characterReplacer(character) {\n  // Replace a single character by its escaped version\n  let result = escapedCharacters[character];\n  if (result === undefined) {\n    // Replace a single character with its 4-bit unicode escape sequence\n    if (character.length === 1) {\n      result = character.charCodeAt(0).toString(16);\n      result = '\\\\u0000'.substr(0, 6 - result.length) + result;\n    }\n    // Replace a surrogate pair with its 8-bit unicode escape sequence\n    else {\n      result = ((character.charCodeAt(0) - 0xD800) * 0x400 +\n                 character.charCodeAt(1) + 0x2400).toString(16);\n      result = '\\\\U00000000'.substr(0, 10 - result.length) + result;\n    }\n  }\n  return result;\n}\n\nfunction escapeRegex(regex) {\n  return regex.replace(/[\\]\\/\\(\\)\\*\\+\\?\\.\\\\\\$]/g, '\\\\$&');\n}\n","const namespaces = {\n    geo: 'http://www.w3.org/2003/01/geo/wgs84_pos#',\n    schema: 'http://schema.org/',\n    rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',\n    rdfs: 'http://www.w3.org/2000/01/rdf-schema#',\n    vcard: 'http://www.w3.org/2006/vcard/ns#',\n    owl: 'http://www.w3.org/2002/07/owl#',\n    time: 'http://www.w3.org/2006/time#',\n    dcterms: 'http://purl.org/dc/terms/',\n    dcmi: 'http://purl.org/dc/terms/',\n    dqm: 'http://purl.org/dqm-vocabulary/v1/dqm#',\n    foaf: 'http://xmlns.com/foaf/0.1/',\n    qudt: 'http://qudt.org/schema/qudt/',\n    qudt_unit: 'http://qudt.org/vocab/unit/',\n    quantitykind: 'http://qudt.org/vocab/quantitykind/',\n    sosa: 'http://www.w3.org/ns/sosa/',\n    ssn: 'http://www.w3.org/ns/ssn/',\n    ssns: 'http://www.w3.org/ns/ssn/systems/',\n    openhps: 'http://openhps.org/terms#',\n    ogc: 'http://www.opengis.net/ont/geosparql#',\n};\nconst mirrors = {\n    'http://www.opengis.net/ont/geosparql#': 'https://cdn.jsdelivr.net/gh/opengeospatial/ogc-geosparql@master/1.1/geo.ttl',\n    'http://schema.org/': 'https://schema.org/version/latest/schemaorg-all-http.ttl',\n    'http://purl.org/dc/terms/': 'https://www.dublincore.org/specifications/dublin-core/dcmi-terms/dublin_core_terms.nt',\n    'http://purl.org/dqm-vocabulary/v1/dqm#': 'http://semwebquality.org/dqm-vocabulary/v1/dqm.owl',\n    'http://openhps.org/terms#': 'https://cdn.jsdelivr.net/gh/OpenHPS/openhps-rdf@master/ontology/v1/openhps.ttl',\n};\nexport { namespaces, mirrors };\n//# sourceMappingURL=namespaces.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar _a;\nimport { DataSerializer, } from '@openhps/core';\nimport { InternalRDFSerializer } from './InternalRDFSerializer';\nimport { InternalRDFDeserializer } from './InternalRDFDeserializer';\nimport * as N3 from 'n3';\nimport { namespaces } from '../namespaces';\nimport { rdf } from '../vocab';\nexport class RDFSerializer extends DataSerializer {\n    static get options() {\n        return {\n            serializer: new InternalRDFSerializer(),\n            deserializer: new InternalRDFDeserializer(),\n        };\n    }\n    static registerRDFType(type) {\n        const meta = this.getMetadata(type);\n        if (!meta.options || !meta.options.rdf) {\n            return;\n        }\n        const rdfOptions = meta.options.rdf;\n        if (rdfOptions.predicates) {\n            Object.entries(rdfOptions.predicates)\n                .filter(([k, _]) => k === rdf.type)\n                .map(([_, v]) => v.flat())\n                .flat()\n                .forEach((typeIri) => {\n                var _b;\n                const results = (_b = this.knownRDFTypes.get(typeIri)) !== null && _b !== void 0 ? _b : [];\n                results.push(type.name);\n                this.knownRDFTypes.set(typeIri, results);\n            });\n        }\n    }\n    static serialize(data, baseUri) {\n        return super.serialize(data, Object.assign({ rdf: {\n                baseUri,\n            } }, this.options));\n    }\n    static deserializeFromStore(subject, store) {\n        function quadsToThing(subject, store) {\n            return {\n                termType: subject.termType,\n                value: subject.value,\n                predicates: Object.assign({}, store\n                    .getPredicates(subject, null, null)\n                    .map((predicate) => {\n                    return {\n                        [predicate.value]: store.getObjects(subject, predicate, null).map((object) => {\n                            if (object.constructor.name === 'BlankNode' ||\n                                object.constructor.name === 'NamedNode') {\n                                return quadsToThing(object, store);\n                            }\n                            else {\n                                return object;\n                            }\n                        }),\n                    };\n                })\n                    .reduce((a, b) => (Object.assign(Object.assign({}, a), b)), {})),\n            };\n        }\n        const thing = quadsToThing(subject, store);\n        return this.deserialize(thing);\n    }\n    static serializeToSubjects(data, baseUri) {\n        const quads = RDFSerializer.serializeToQuads(data, baseUri);\n        const store = new N3.Store(quads);\n        const quadSubjects = store.getSubjects(null, null, null);\n        function serializePredicates(quadSubject) {\n            const quadPredicates = store.getPredicates(quadSubject, null, null);\n            return quadPredicates\n                .map((quadPredicate) => {\n                const quadObjects = store.getObjects(quadSubject, quadPredicate, null);\n                const literals = quadObjects\n                    .filter((obj) => obj instanceof N3.Literal)\n                    .filter((obj) => obj.language === '')\n                    .map((obj) => ({ [obj.datatype.value]: [obj.value] }))\n                    .reduce((a, b) => (Object.assign(Object.assign({}, a), b)), {});\n                const langStrings = quadObjects\n                    .filter((obj) => obj instanceof N3.Literal)\n                    .filter((obj) => obj.language !== '')\n                    .map((obj) => ({ [obj.language]: [obj.value] }))\n                    .reduce((a, b) => (Object.assign(Object.assign({}, a), b)), {});\n                const namedNodes = quadObjects\n                    .filter((obj) => obj instanceof N3.NamedNode)\n                    .map((obj) => obj.value);\n                const blankNodes = quadObjects\n                    .filter((obj) => obj instanceof N3.BlankNode)\n                    .map((obj) => serializePredicates(N3.DataFactory.blankNode(obj.value)));\n                return {\n                    [quadPredicate.value]: {\n                        namedNodes,\n                        blankNodes,\n                        literals,\n                        langStrings,\n                    },\n                };\n            })\n                .reduce((a, b) => (Object.assign(Object.assign({}, a), b)), {});\n        }\n        const subjects = quadSubjects\n            .filter((quadSubject) => quadSubject instanceof N3.NamedNode)\n            .map((quadSubject) => {\n            return {\n                type: 'Subject',\n                url: quadSubject.value,\n                predicates: serializePredicates(quadSubject),\n            };\n        });\n        return subjects;\n    }\n    static serializeToQuads(data, baseUri) {\n        const thing = data['predicates'] !== undefined ? data : this.serialize(data, baseUri);\n        const subject = thing.termType === 'BlankNode'\n            ? N3.DataFactory.blankNode(thing.value)\n            : N3.DataFactory.namedNode(thing.value);\n        return Object.keys(thing.predicates)\n            .map((predicateIri) => {\n            const predicate = N3.DataFactory.namedNode(predicateIri);\n            return thing.predicates[predicateIri].map((object) => {\n                if (object['predicates'] !== undefined) {\n                    return [\n                        N3.DataFactory.quad(subject, predicate, object),\n                        ...this.serializeToQuads(object),\n                    ];\n                }\n                else {\n                    return [N3.DataFactory.quad(subject, predicate, object)];\n                }\n            });\n        })\n            .flat()\n            .flat();\n    }\n    static stringify(thing, options = {}) {\n        return __awaiter(this, void 0, void 0, function* () {\n            return new Promise((resolve, reject) => {\n                const quads = this.serializeToQuads(thing, options.baseUri);\n                const store = new N3.Store(quads);\n                const prefixes = Object.assign({ xsd: 'http://www.w3.org/2001/XMLSchema#' }, namespaces);\n                const ns = Object.keys(prefixes)\n                    .map((k) => {\n                    return { [prefixes[k]]: k };\n                })\n                    .reduce((a, b) => {\n                    return Object.assign(Object.assign({}, a), b);\n                });\n                const filteredPrefixes = {};\n                quads.map((quad) => {\n                    const usedNamespacesInQuad = [\n                        quad.subject.value,\n                        quad.predicate.value,\n                        quad.object.termType === 'NamedNode'\n                            ? quad.object.termType\n                            : quad.object.termType === 'Literal'\n                                ? quad.object.datatype.value\n                                : quad.object.value,\n                    ];\n                    usedNamespacesInQuad.map((namespace) => {\n                        Object.keys(ns).forEach((n) => {\n                            if (namespace.includes(n)) {\n                                filteredPrefixes[ns[n]] = n;\n                            }\n                        });\n                    });\n                });\n                options.prefixes = Object.assign(Object.assign({}, filteredPrefixes), options.prefixes);\n                const writer = new N3.Writer(options);\n                if (options.prettyPrint) {\n                    store.getSubjects(null, null, null).forEach((subject) => {\n                        if (subject.termType === 'BlankNode') {\n                            return;\n                        }\n                        else {\n                            store.getPredicates(subject, null, null).forEach((predicate) => {\n                                store.getObjects(subject, predicate, null).forEach((object) => {\n                                    if (object.termType === 'BlankNode') {\n                                        writer.addQuad(subject, predicate, this.writeBlankNode(writer, object, store));\n                                    }\n                                    else {\n                                        writer.addQuad(subject, predicate, object);\n                                    }\n                                });\n                            });\n                        }\n                    });\n                }\n                else {\n                    writer.addQuads(quads);\n                }\n                writer.end((err, result) => {\n                    if (err) {\n                        return reject(err);\n                    }\n                    resolve(result);\n                });\n            });\n        });\n    }\n    static writeBlankNode(writer, object, store) {\n        const blankNodePredicates = store.getPredicates(object, null, null);\n        return writer.blank(blankNodePredicates\n            .map((predicate) => {\n            const blankNodeObjects = store.getObjects(object, predicate, null);\n            return blankNodeObjects.map((object) => {\n                if (object.termType === 'BlankNode') {\n                    return {\n                        predicate,\n                        object: this.writeBlankNode(writer, object, store),\n                    };\n                }\n                else {\n                    return {\n                        predicate,\n                        object,\n                    };\n                }\n            });\n        })\n            .flat());\n    }\n    static deserialize(serializedData, dataType) {\n        if (serializedData['predicates'] === undefined) {\n            return super.deserialize(serializedData, dataType);\n        }\n        const deserializer = new InternalRDFDeserializer();\n        const finalType = dataType !== null && dataType !== void 0 ? dataType : deserializer.rdfTypeResolver(serializedData, this.knownTypes, this.knownRDFTypes);\n        if (finalType === Object) {\n            return serializedData;\n        }\n        return deserializer.convertSingleValue(serializedData, this.ensureTypeDescriptor(finalType), this.knownTypes, undefined, undefined, {\n            rdf: {\n                knownTypes: this.knownRDFTypes,\n            },\n        });\n    }\n    static getUriMetadata(dataType) {\n        const metadata = DataSerializer.getMetadata(dataType);\n        const rootMetadata = DataSerializer.getRootMetadata(dataType);\n        const options = metadata.options && metadata.options.rdf\n            ? metadata.options.rdf\n            : rootMetadata.options && rootMetadata.options.rdf\n                ? rootMetadata.options.rdf\n                : undefined;\n        if (!options) {\n            return undefined;\n        }\n        const identifierMember = Array.from(metadata.dataMembers.values()).filter((member) => {\n            return (member &&\n                member.options &&\n                member.options.rdf &&\n                member.options.rdf.identifier);\n        })[0];\n        return identifierMember;\n    }\n    static normalizeUri(dataType, identifier, baseUri) {\n        const identifierMember = this.getUriMetadata(dataType);\n        let uri = undefined;\n        if (identifierMember) {\n            const rdfOptions = identifierMember.options.rdf;\n            uri = rdfOptions.serializer ? rdfOptions.serializer(identifier, dataType) : identifier;\n            uri = uri && !uri.startsWith('http') && baseUri ? baseUri + uri : N3.DataFactory.blankNode(uri).value;\n        }\n        else {\n            return baseUri;\n        }\n    }\n}\n_a = RDFSerializer;\nRDFSerializer.knownRDFTypes = new Map();\n(() => {\n    _a.eventEmitter.on('updateSerializableObject', (_, options) => {\n        if (options && options.rdf && options.rdf.type) {\n            options.rdf.predicates = options.rdf.predicates || {};\n            const types = options.rdf.predicates[rdf.type] || [];\n            types.push(options.rdf.type);\n            options.rdf.predicates[rdf.type] = types;\n        }\n    });\n    _a.eventEmitter.on('registerType', (type) => {\n        RDFSerializer.registerRDFType(type);\n    });\n})();\n//# sourceMappingURL=RDFSerializer.js.map","var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar SerializableNamedNode_1;\nimport { SerializableObject } from '@openhps/core';\nimport * as N3 from 'n3';\nlet SerializableNamedNode = SerializableNamedNode_1 = class SerializableNamedNode extends N3.NamedNode {\n};\nSerializableNamedNode = SerializableNamedNode_1 = __decorate([\n    SerializableObject({\n        rdf: {\n            serializer: (object) => {\n                return {\n                    value: object.value,\n                };\n            },\n            deserializer: (thing) => {\n                return new SerializableNamedNode_1(thing.value);\n            },\n        },\n    })\n], SerializableNamedNode);\nexport { SerializableNamedNode };\n//# sourceMappingURL=SerializableNamedNode.js.map","// **N3Lexer** tokenizes N3 documents.\nimport namespaces from './IRIs';\nimport queueMicrotask from 'queue-microtask';\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      case '}':\n        if (!this._lineMode) {\n          matchLength = 1;\n          type = firstChar;\n        }\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","// **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      subject: subject, predicate: predicate, object: object,\n      graph: graph, type: type,\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.id.substr(2)}.` : '.');\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() {\n    const context = this._contextStack.pop(), n3Mode = this._n3Mode;\n    this._subject   = context.subject;\n    this._predicate = context.predicate;\n    this._object    = context.object;\n    this._graph     = context.graph;\n    // The settings below only apply to N3 streams\n    if (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();\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();\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();\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    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();\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();\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","// **N3StreamParser** parses a text stream into a quad stream.\nimport N3Parser from './N3Parser';\nimport { Transform } from 'readable-stream';\n\n// ## Constructor\nexport default class N3StreamParser extends Transform {\n  constructor(options) {\n    super({ decodeStrings: true });\n    this._readableState.objectMode = true;\n\n    // Set up parser with dummy stream to obtain `data` and `end` callbacks\n    const parser = new N3Parser(options);\n    let onData, onEnd;\n    parser.parse({\n      on: (event, callback) => {\n        switch (event) {\n        case 'data': onData = callback; break;\n        case 'end':   onEnd = callback; break;\n        }\n      },\n    },\n      // Handle quads by pushing them down the pipeline\n      (error, quad) => { error && this.emit('error', error) || quad && this.push(quad); },\n      // Emit prefixes through the `prefix` event\n      (prefix, uri) => { this.emit('prefix', prefix, uri); }\n    );\n\n    // Implement Transform methods through parser callbacks\n    this._transform = (chunk, encoding, done) => { onData(chunk); done(); };\n    this._flush = done => { onEnd(); done(); };\n  }\n\n  // ### Parses a stream of strings\n  import(stream) {\n    stream.on('data',  chunk => { this.write(chunk); });\n    stream.on('end',   ()      => { this.end(); });\n    stream.on('error', error => { this.emit('error', error); });\n    return this;\n  }\n}\n","// **N3StreamWriter** serializes a quad stream into a text stream.\nimport { Transform } from 'readable-stream';\nimport N3Writer from './N3Writer';\n\n// ## Constructor\nexport default class N3StreamWriter extends Transform {\n  constructor(options) {\n    super({ encoding: 'utf8', writableObjectMode: true });\n\n    // Set up writer with a dummy stream object\n    const writer = this._writer = new N3Writer({\n      write: (quad, encoding, callback) => { this.push(quad); callback && callback(); },\n      end: callback => { this.push(null); callback && callback(); },\n    }, options);\n\n    // Implement Transform methods on top of writer\n    this._transform = (quad, encoding, done) => { writer.addQuad(quad, done); };\n    this._flush = done => { writer.end(done); };\n  }\n\n// ### Serializes a stream of quads\n  import(stream) {\n    stream.on('data',   quad => { this.write(quad); });\n    stream.on('end',    () => { this.end(); });\n    stream.on('error',  error => { this.emit('error', error); });\n    stream.on('prefix', (prefix, iri) => { this._writer.addPrefix(prefix, iri); });\n    return this;\n  }\n}\n","import Lexer from './N3Lexer';\nimport Parser from './N3Parser';\nimport Writer from './N3Writer';\nimport Store from './N3Store';\nimport StreamParser from './N3StreamParser';\nimport StreamWriter from './N3StreamWriter';\nimport * as Util from './N3Util';\n\nimport {\n  default as DataFactory,\n\n  Term,\n  NamedNode,\n  Literal,\n  BlankNode,\n  Variable,\n  DefaultGraph,\n  Quad,\n  Triple,\n\n  termFromId,\n  termToId,\n} from './N3DataFactory';\n\n// Named exports\nexport {\n  Lexer,\n  Parser,\n  Writer,\n  Store,\n  StreamParser,\n  StreamWriter,\n  Util,\n\n  DataFactory,\n\n  Term,\n  NamedNode,\n  Literal,\n  BlankNode,\n  Variable,\n  DefaultGraph,\n  Quad,\n  Triple,\n\n  termFromId,\n  termToId,\n};\n\n// Export all named exports as a default object for backward compatibility\nexport default {\n  Lexer,\n  Parser,\n  Writer,\n  Store,\n  StreamParser,\n  StreamWriter,\n  Util,\n\n  DataFactory,\n\n  Term,\n  NamedNode,\n  Literal,\n  BlankNode,\n  Variable,\n  DefaultGraph,\n  Quad,\n  Triple,\n\n  termFromId,\n  termToId,\n};\n"],"names":["root","factory","exports","module","require","define","amd","self","this","__WEBPACK_EXTERNAL_MODULE__0__","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","i","arr","Arr","_byteLength","curByte","len","revLookup","charCodeAt","fromByteArray","uint8","length","extraBytes","parts","maxChunkLength","len2","push","encodeChunk","lookup","join","Uint8Array","Array","code","Error","indexOf","start","end","num","output","base64","ieee754","customInspectSymbol","Symbol","Buffer","SlowBuffer","alloc","INSPECT_MAX_BYTES","K_MAX_LENGTH","createBuffer","RangeError","buf","Object","setPrototypeOf","prototype","arg","encodingOrOffset","TypeError","allocUnsafe","from","value","string","encoding","isEncoding","actual","write","slice","fromString","ArrayBuffer","isView","arrayView","isInstance","copy","fromArrayBuffer","buffer","byteOffset","fromArrayLike","fromArrayView","SharedArrayBuffer","valueOf","b","obj","isBuffer","checked","undefined","numberIsNaN","type","isArray","data","fromObject","toPrimitive","assertSize","size","array","toString","mustMatch","arguments","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","n","m","bidirectionalIndexOf","val","dir","arrayIndexOf","call","lastIndexOf","indexSize","arrLength","valLength","String","read","readUInt16BE","foundIndex","found","j","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","str","byteArray","asciiToBytes","base64Write","ucs2Write","units","c","hi","lo","utf16leToBytes","Math","min","res","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","apply","decodeCodePointsArray","kMaxLength","TYPED_ARRAY_SUPPORT","proto","foo","e","typedArraySupport","console","error","defineProperty","enumerable","get","poolSize","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","concat","list","pos","set","swap16","swap32","swap64","toLocaleString","equals","inspect","max","replace","trim","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_arr","ret","out","hexSliceLookupTable","bytes","checkOffset","ext","checkInt","wrtBigUInt64LE","checkIntBI","BigInt","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","last","boundsError","readBigUInt64BE","readIntLE","pow","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","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeBigInt64LE","writeBigInt64BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","errors","E","sym","getMessage","Base","NodeError","constructor","super","writable","configurable","name","stack","message","addNumericalSeparator","range","ERR_OUT_OF_RANGE","checkBounds","ERR_INVALID_ARG_TYPE","floor","ERR_BUFFER_OUT_OF_BOUNDS","input","msg","received","isInteger","abs","INVALID_BASE64_RE","Infinity","leadSurrogate","split","base64clean","src","dst","alphabet","table","i16","fn","BufferBigIntNotDefined","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","args","Function","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","NumberIsNaN","isNaN","EventEmitter","init","once","emitter","Promise","resolve","reject","errorListener","err","removeListener","resolver","eventTargetAgnosticAddListener","handler","flags","on","addErrorHandlerIfEventEmitter","_events","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","that","_addListener","prepend","events","existing","warning","create","newListener","emit","unshift","warned","w","count","warn","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","bind","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","addEventListener","wrapListener","removeEventListener","getPrototypeOf","setMaxListeners","getMaxListeners","doError","er","context","listeners","addListener","prependListener","prependOnceListener","position","originalListener","shift","index","pop","spliceOne","off","removeAllListeners","key","keys","rawListeners","eventNames","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","d","s","NaN","rt","log","LN2","ctor","superCtor","super_","TempCtor","promise","queueMicrotask","window","g","cb","then","catch","setTimeout","codes","createErrorType","_Base","subClass","superClass","arg1","arg2","arg3","__proto__","oneOf","expected","thing","map","determiner","search","this_len","substring","endsWith","objectKeys","Duplex","Readable","Writable","v","method","options","allowHalfOpen","readable","onend","_writableState","ended","process","nextTick","onEndNT","highWaterMark","getBuffer","_readableState","destroyed","PassThrough","Transform","_transform","chunk","ReadableState","EElistenerCount","Stream","OurUint8Array","debug","debugUtil","debuglog","StringDecoder","createReadableStreamAsyncIterator","BufferList","destroyImpl","getHighWaterMark","_require$codes","ERR_STREAM_PUSH_AFTER_EOF","ERR_METHOD_NOT_IMPLEMENTED","ERR_STREAM_UNSHIFT_AFTER_END_EVENT","errorOrDestroy","kProxyEvents","stream","isDuplex","objectMode","readableObjectMode","pipes","pipesCount","flowing","endEmitted","reading","sync","needReadable","emittedReadable","readableListening","resumeScheduled","paused","emitClose","autoDestroy","defaultEncoding","awaitDrain","readingMore","decoder","_read","destroy","_destroy","readableAddChunk","addToFront","skipChunkCheck","emitReadable","emitReadable_","onEofChunk","chunkInvalid","_uint8ArrayToBuffer","addChunk","maybeReadMore","_undestroy","undestroy","isPaused","setEncoding","enc","p","head","content","next","clear","MAX_HWM","howMuchToRead","computeNewHighWaterMark","flow","maybeReadMore_","updateReadableListening","resume","nReadingNextTick","resume_","fromList","consume","endReadable","endReadableNT","wState","finished","xs","l","nOrig","doRead","pipe","dest","pipeOpts","endFn","stdout","stderr","unpipe","onunpipe","unpipeInfo","hasUnpiped","onclose","onfinish","ondrain","onerror","ondata","cleanedUp","needDrain","pipeOnDrain","pause","event","dests","splice","ev","wrap","_this","asyncIterator","_fromList","iterable","opts","ERR_MULTIPLE_CALLBACK","ERR_TRANSFORM_ALREADY_TRANSFORMING","ERR_TRANSFORM_WITH_LENGTH_0","afterTransform","ts","_transformState","transforming","writecb","writechunk","rs","needTransform","writeencoding","transform","flush","_flush","prefinish","done","_write","err2","CorkedRequest","entry","finish","corkReq","callback","pendingcb","corkedRequestsFree","onCorkedFinish","WritableState","internalUtil","deprecate","realHasInstance","ERR_STREAM_CANNOT_PIPE","ERR_STREAM_DESTROYED","ERR_STREAM_NULL_VALUES","ERR_STREAM_WRITE_AFTER_END","ERR_UNKNOWN_ENCODING","nop","writableObjectMode","finalCalled","ending","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writelen","onwriteStateUpdate","finishMaybe","errorEmitted","onwriteError","needFinish","bufferedRequest","clearBuffer","afterWrite","lastBufferedRequest","prefinished","bufferedRequestCount","writev","_writev","final","_final","doWrite","onwriteDrain","holder","allBuffers","isBuf","callFinal","need","rState","current","_","hasInstance","object","writeAfterEnd","validChunk","newChunk","decodeChunk","writeOrBuffer","cork","uncork","setDefaultEncoding","endWritable","_Object$setPrototypeO","_defineProperty","kLastResolve","kLastReject","kError","kEnded","kLastPromise","kHandlePromise","kStream","createIterResult","readAndResolve","iter","onReadable","AsyncIteratorPrototype","ReadableStreamAsyncIteratorPrototype","lastPromise","wrapForNext","_this2","_Object$create","iterator","enumerableOnly","symbols","filter","getOwnPropertyDescriptor","_defineProperties","props","descriptor","custom","instance","Constructor","_classCallCheck","tail","protoProps","staticProps","hasStrings","_getString","_getBuffer","nb","source","forEach","getOwnPropertyDescriptors","defineProperties","_objectSpread","depth","customInspect","emitErrorAndCloseNT","emitErrorNT","emitCloseNT","readableDestroyed","writableDestroyed","ERR_STREAM_PREMATURE_CLOSE","noop","eos","called","_len","_key","onlegacyfinish","writableEnded","readableEnded","onrequest","req","setHeader","abort","isRequest","ERR_MISSING_ARGS","destroyer","closed","to","popCallback","streams","destroys","reduce","ERR_INVALID_OPT_VALUE","duplexKey","hwm","highWaterMarkFrom","pipeline","copyProps","SafeBuffer","nenc","retried","_normalizeEncoding","normalizeEncoding","text","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","r","utf8CheckExtraBytes","total","utf8CheckIncomplete","config","localStorage","trace","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","__esModule","definition","o","globalThis","prop","hasOwnProperty","toStringTag","RDF","XSD","SWAP","xsd","decimal","boolean","double","integer","rdf","nil","rest","langString","owl","sameAs","forSome","forAll","implies","isNamedNode","term","termType","isBlankNode","isLiteral","isVariable","isDefaultGraph","inDefaultGraph","quad","graph","prefix","iri","prefixes","defaultPrefixes","processPrefix","cache","local","namedNode","N3DataFactory","DEFAULTGRAPH","_blankNodeCounter","escapedLiteral","quadId","DataFactory","NamedNode","blankNode","BlankNode","variable","Variable","literal","languageOrDataType","Literal","datatype","defaultGraph","triple","Term","id","other","hashCode","language","atPos","datatypeString","dtPos","char","DefaultGraph","termFromId","endPos","components","exec","unescapeQuotes","termToId","escapeQuotes","subject","predicate","Quad","_subject","_predicate","_object","_graph","quoted","dateTime","date","time","anyURI","mergeDeep","assign","isObject","item","InternalRDFSerializer","Serializer","serializationStrategy","Map","serializeLiteral","Boolean","Date","serializeDate","serializeArray","serializeMap","Set","serializeSet","convertSingleValue","sourceObject","typeDescriptor","memberName","memberOptions","serializerOptions","retrievePreserveNull","serializer","serializeObject","hasFriendlyName","errorHandler","metadata","rootMetadata","DataSerializer","identifierMember","dataMembers","values","member","identifier","uri","rdfOptions","startsWith","baseUri","predicates","entries","k","rootMember","predicateIri","elementType","valueType","_a","xsdDatatype","dataTypeNode","iriToNode","dateString","toISOString","direction","Property","Statement","Bag","Seq","Alt","List","CompoundLiteral","HTML","PlainLiteral","XMLLiteral","JSON__workaround","InternalRDFDeserializer","Deserializer","deserializationStrategy","deserializeLiteral","deserializeArray","deserializeMap","deserializeSet","rdfTypeResolver","knownTypes","knownRDFTypes","mappedTypes","flat","deserializer","deserializeObject","expectedSelfType","finalType","targetObject","instantiateType","isInstanceOf","getTime","deserializeDate","N3Store","quads","_size","_graphs","_id","_ids","_entities","_blankNodeIndex","_factory","addQuads","graphs","subjects","graphKey","subjectKey","predicateKey","_addToIndex","index0","key0","key1","key2","index1","index2","existed","_removeFromIndex","name0","name1","name2","graphId","entityKeys","value0","entity0","value1","entity1","_loop","_loopByKey0","_loopByKey1","_loopBy2Keys","_countInIndex","_getGraphs","isString","_uniqueEntities","uniqueIds","add","addQuad","graphItem","objects","freeze","ids","entities","changed","delete","removeQuad","has","subjectOrQuad","readQuads","import","removeQuads","remove","removeMatches","deleteGraph","getQuads","subjectId","predicateId","objectId","_findInIndex","match","DatasetCoreAndReadableStream","countQuads","some","every","getSubjects","results","forSubjects","getPredicates","forPredicates","getObjects","forObjects","getGraphs","forGraphs","createBlankNode","suggestedName","extractLists","ignoreErrors","lists","onError","node","tails","toRemove","tailQuad","items","headPos","malformed","objectQuads","subjectQuads","parent","n3Store","filtered","_filtered","escapeAll","escapedCharacters","SerializedTerm","N3Writer","outputStream","_prefixRegex","_lists","_outputStream","_endStream","test","format","_lineMode","_writeQuad","_writeQuadLine","_prefixIRIs","addPrefixes","baseIRI","_baseMatcher","RegExp","escapeRegex","_baseLength","_inDefaultGraph","_encodeIriOrBlank","_encodeObject","_encodePredicate","_encodeSubject","_prefixMatch","quadToString","quadsToString","t","entity","_encodeQuad","characterReplacer","prefixMatch","_encodeLiteral","_blockedWrite","addPrefix","hasPrefixes","IRIlist","prefixList","prefixIRI","blank","child","children","contents","elements","singleDone","result","character","regex","namespaces","geo","schema","rdfs","vcard","dcterms","dcmi","dqm","foaf","qudt","qudt_unit","quantitykind","sosa","ssn","ssns","openhps","ogc","__awaiter","thisArg","_arguments","P","generator","fulfilled","step","rejected","adopt","RDFSerializer","static","meta","getMetadata","typeIri","_b","serialize","store","quadsToThing","deserialize","serializeToQuads","serializePredicates","quadSubject","quadPredicate","quadObjects","literals","langStrings","namedNodes","blankNodes","url","ns","filteredPrefixes","namespace","writer","prettyPrint","writeBlankNode","blankNodePredicates","serializedData","dataType","ensureTypeDescriptor","getUriMetadata","eventEmitter","types","registerRDFType","SerializableNamedNode_1","__decorate","decorators","desc","decorate","SerializableNamedNode","SerializableObject","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","_n3Mode","n3","_comments","comments","_literalClosingPos","_tokenizeToEnd","inputFinished","_input","currentLineLength","whiteSpaceMatch","comment","emitToken","_line","line","firstChar","matchLength","inconclusive","_previousMarker","_unescape","reportSyntaxError","_parseLiteral","toUpperCase","token","previousToken","_syntaxError","invalid","replaced","sequence","unicode4","unicode8","escapedChar","charCode","opening","openingLength","closingPos","backslashCount","raw","lines","issue","_readStartingBom","tokenize","tokens","_pendingBuffer","blankNodePrefix","N3Parser","_contextStack","_setBase","initDataFactory","isTurtle","isTriG","isNTriples","isNQuads","isN3","isLineMode","_supportsNamedGraphs","_readPredicateOrNamedGraph","_readPredicate","_supportsQuads","_supportsRDFStar","_resolveRelativeIRI","_blankNodePrefix","_lexer","lexer","_explicitQuantifiers","explicitQuantifiers","fragmentPos","_base","_basePath","_baseRoot","_baseScheme","_saveContext","n3Mode","inverse","_inversePredicate","blankPrefix","_prefixes","quantified","_quantified","_restoreContext","_readInTopContext","_error","_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","listItem","completed","_readCallback","_readFormulaTail","inversePredicate","_readQuadPunctuation","_readPrefixIRI","prefixNode","_prefixCallback","_readDeclarationPunctuation","_readNamedGraphBlankLabel","QUANTIFIERS_GRAPH","_readQuantifierPunctuation","afterPath","_afterPath","_readPath","_readForwardPath","_readBackwardPath","_readRDFStarTailOrGraph","_readRDFStarTail","_quad","contextStack","_removeDotSegments","pathStart","segmentStart","parse","quadCallback","prefixCallback","parser","N3StreamParser","onData","onEnd","N3StreamWriter","_writer","Lexer","Parser","Writer","Store","StreamParser","StreamWriter","Util","Triple"],"sourceRoot":""}