@openhps/rdf 0.1.9 → 0.1.10

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

@@ -1 +1 @@
-{"version":3,"file":"web/openhps-rdf.serialization.es.min.js","mappings":"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","sources":["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/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/external module \"./openhps-core.es.min.js\"","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/rdfs.js","webpack://@openhps/rdf/./dist/esm/vocab/qudt.js","webpack://@openhps/rdf/./dist/esm/vocab/sosa.js","webpack://@openhps/rdf/./dist/esm/vocab/ssn.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/data/ObservableProperty.js","webpack://@openhps/rdf/./dist/esm/data/Observation.js","webpack://@openhps/rdf/./dist/esm/data/FeatureOfInterest.js","webpack://@openhps/rdf/./dist/esm/data/QuantityValue.js"],"sourcesContent":["'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","// 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};","var x = y => { var x = {}; __webpack_require__.d(x, y); return x; }\nvar y = x => () => x\nconst __WEBPACK_NAMESPACE_OBJECT__ = x({ [\"DataSerializer\"]: () => __WEBPACK_EXTERNAL_MODULE__openhps_core_es_min_js_27733f5f__.DataSerializer, [\"Deserializer\"]: () => __WEBPACK_EXTERNAL_MODULE__openhps_core_es_min_js_27733f5f__.Deserializer, [\"SerializableArrayMember\"]: () => __WEBPACK_EXTERNAL_MODULE__openhps_core_es_min_js_27733f5f__.SerializableArrayMember, [\"SerializableMember\"]: () => __WEBPACK_EXTERNAL_MODULE__openhps_core_es_min_js_27733f5f__.SerializableMember, [\"SerializableObject\"]: () => __WEBPACK_EXTERNAL_MODULE__openhps_core_es_min_js_27733f5f__.SerializableObject, [\"Serializer\"]: () => __WEBPACK_EXTERNAL_MODULE__openhps_core_es_min_js_27733f5f__.Serializer, [\"Unit\"]: () => __WEBPACK_EXTERNAL_MODULE__openhps_core_es_min_js_27733f5f__.Unit });","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","export const isDefinedBy = 'http://www.w3.org/2000/01/rdf-schema#isDefinedBy';\nexport const label = 'http://www.w3.org/2000/01/rdf-schema#label';\nexport const comment = 'http://www.w3.org/2000/01/rdf-schema#comment';\nexport const subClassOf = 'http://www.w3.org/2000/01/rdf-schema#subClassOf';\nexport const range = 'http://www.w3.org/2000/01/rdf-schema#range';\nexport const domain = 'http://www.w3.org/2000/01/rdf-schema#domain';\nexport const subPropertyOf = 'http://www.w3.org/2000/01/rdf-schema#subPropertyOf';\nexport const seeAlso = 'http://www.w3.org/2000/01/rdf-schema#seeAlso';\nexport const ContainerMembershipProperty = 'http://www.w3.org/2000/01/rdf-schema#ContainerMembershipProperty';\nexport const member = 'http://www.w3.org/2000/01/rdf-schema#member';\nexport const Resource = 'http://www.w3.org/2000/01/rdf-schema#Resource';\nexport const Class = 'http://www.w3.org/2000/01/rdf-schema#Class';\nexport const Literal = 'http://www.w3.org/2000/01/rdf-schema#Literal';\nexport const Container = 'http://www.w3.org/2000/01/rdf-schema#Container';\nexport const Datatype = 'http://www.w3.org/2000/01/rdf-schema#Datatype';\n//# sourceMappingURL=rdfs.js.map","export const bytes = 'http://qudt.org/schema/qudt/bytes';\nexport const cardinality = 'http://qudt.org/schema/qudt/cardinality';\nexport const basis = 'http://qudt.org/schema/qudt/basis';\nexport const orderedType = 'http://qudt.org/schema/qudt/orderedType';\nexport const ansiSQLName = 'http://qudt.org/schema/qudt/ansiSQLName';\nexport const bounded = 'http://qudt.org/schema/qudt/bounded';\nexport const cName = 'http://qudt.org/schema/qudt/cName';\nexport const oracleSQLName = 'http://qudt.org/schema/qudt/oracleSQLName';\nexport const protocolBuffersName = 'http://qudt.org/schema/qudt/protocolBuffersName';\nexport const pythonName = 'http://qudt.org/schema/qudt/pythonName';\nexport const vbName = 'http://qudt.org/schema/qudt/vbName';\nexport const allowedPattern = 'http://qudt.org/schema/qudt/allowedPattern';\nexport const bits = 'http://qudt.org/schema/qudt/bits';\nexport const rdfsDatatype = 'http://qudt.org/schema/qudt/rdfsDatatype';\nexport const length = 'http://qudt.org/schema/qudt/length';\nexport const minExclusive = 'http://qudt.org/schema/qudt/minExclusive';\nexport const elementType = 'http://qudt.org/schema/qudt/elementType';\nexport const AspectClass = 'http://qudt.org/schema/qudt/AspectClass';\nexport const Statement = 'http://qudt.org/schema/qudt/Statement';\nexport const LatexString = 'http://qudt.org/schema/qudt/LatexString';\nexport const UCUMci = 'http://qudt.org/schema/qudt/UCUMci';\nexport const UCUMcs = 'http://qudt.org/schema/qudt/UCUMcs';\nexport const floatPercentage = 'http://qudt.org/schema/qudt/floatPercentage';\nexport const integerPercentage = 'http://qudt.org/schema/qudt/integerPercentage';\nexport const valueUnion = 'http://qudt.org/schema/qudt/valueUnion';\nexport const AbstractQuantityKind = 'http://qudt.org/schema/qudt/AbstractQuantityKind';\nexport const Concept = 'http://qudt.org/schema/qudt/Concept';\nexport const QuantityKind = 'http://qudt.org/schema/qudt/QuantityKind';\nexport const BaseDimensionMagnitude = 'http://qudt.org/schema/qudt/BaseDimensionMagnitude';\nexport const EndianType = 'http://qudt.org/schema/qudt/EndianType';\nexport const BinaryPrefix = 'http://qudt.org/schema/qudt/BinaryPrefix';\nexport const Prefix = 'http://qudt.org/schema/qudt/Prefix';\nexport const BitEncodingType = 'http://qudt.org/schema/qudt/BitEncodingType';\nexport const Encoding = 'http://qudt.org/schema/qudt/Encoding';\nexport const BooleanEncodingType = 'http://qudt.org/schema/qudt/BooleanEncodingType';\nexport const ByteEncodingType = 'http://qudt.org/schema/qudt/ByteEncodingType';\nexport const CardinalityType = 'http://qudt.org/schema/qudt/CardinalityType';\nexport const EnumeratedValue = 'http://qudt.org/schema/qudt/EnumeratedValue';\nexport const CharEncodingType = 'http://qudt.org/schema/qudt/CharEncodingType';\nexport const Citation = 'http://qudt.org/schema/qudt/Citation';\nexport const Comment = 'http://qudt.org/schema/qudt/Comment';\nexport const Rule = 'http://qudt.org/schema/qudt/Rule';\nexport const ConstantValue = 'http://qudt.org/schema/qudt/ConstantValue';\nexport const QuantityValue = 'http://qudt.org/schema/qudt/QuantityValue';\nexport const CountingUnit = 'http://qudt.org/schema/qudt/CountingUnit';\nexport const DimensionlessUnit = 'http://qudt.org/schema/qudt/DimensionlessUnit';\nexport const CurrencyUnit = 'http://qudt.org/schema/qudt/CurrencyUnit';\nexport const DataEncoding = 'http://qudt.org/schema/qudt/DataEncoding';\nexport const Datatype = 'http://qudt.org/schema/qudt/Datatype';\nexport const OrderedType = 'http://qudt.org/schema/qudt/OrderedType';\nexport const DateTimeStringEncodingType = 'http://qudt.org/schema/qudt/DateTimeStringEncodingType';\nexport const StringEncodingType = 'http://qudt.org/schema/qudt/StringEncodingType';\nexport const DecimalPrefix = 'http://qudt.org/schema/qudt/DecimalPrefix';\nexport const DerivedUnit = 'http://qudt.org/schema/qudt/DerivedUnit';\nexport const Unit = 'http://qudt.org/schema/qudt/Unit';\nexport const Discipline = 'http://qudt.org/schema/qudt/Discipline';\nexport const FloatingPointEncodingType = 'http://qudt.org/schema/qudt/FloatingPointEncodingType';\nexport const Enumeration = 'http://qudt.org/schema/qudt/Enumeration';\nexport const EnumerationScale = 'http://qudt.org/schema/qudt/EnumerationScale';\nexport const Scale = 'http://qudt.org/schema/qudt/Scale';\nexport const Figure = 'http://qudt.org/schema/qudt/Figure';\nexport const IntegerEncodingType = 'http://qudt.org/schema/qudt/IntegerEncodingType';\nexport const IntervalScale = 'http://qudt.org/schema/qudt/IntervalScale';\nexport const NominalScale = 'http://qudt.org/schema/qudt/NominalScale';\nexport const OrdinalScale = 'http://qudt.org/schema/qudt/OrdinalScale';\nexport const RatioScale = 'http://qudt.org/schema/qudt/RatioScale';\nexport const LogarithmicUnit = 'http://qudt.org/schema/qudt/LogarithmicUnit';\nexport const MathFunctionType = 'http://qudt.org/schema/qudt/MathFunctionType';\nexport const NIST_SP811_Comment = 'http://qudt.org/schema/qudt/NIST_SP811_Comment';\nexport const Organization = 'http://qudt.org/schema/qudt/Organization';\nexport const PhysicalConstant = 'http://qudt.org/schema/qudt/PhysicalConstant';\nexport const Quantity = 'http://qudt.org/schema/qudt/Quantity';\nexport const Quantifiable = 'http://qudt.org/schema/qudt/Quantifiable';\nexport const QuantityKindDimensionVector = 'http://qudt.org/schema/qudt/QuantityKindDimensionVector';\nexport const QuantityKindDimensionVector_SI = 'http://qudt.org/schema/qudt/QuantityKindDimensionVector_SI';\nexport const SystemOfQuantityKinds = 'http://qudt.org/schema/qudt/SystemOfQuantityKinds';\nexport const QuantityKindDimensionVector_CGS = 'http://qudt.org/schema/qudt/QuantityKindDimensionVector_CGS';\nexport const QuantityKindDimensionVector_ISO = 'http://qudt.org/schema/qudt/QuantityKindDimensionVector_ISO';\nexport const QuantityKindDimensionVector_Imperial = 'http://qudt.org/schema/qudt/QuantityKindDimensionVector_Imperial';\nexport const QuantityType = 'http://qudt.org/schema/qudt/QuantityType';\nexport const RuleType = 'http://qudt.org/schema/qudt/RuleType';\nexport const SignednessType = 'http://qudt.org/schema/qudt/SignednessType';\nexport const ScalarDatatype = 'http://qudt.org/schema/qudt/ScalarDatatype';\nexport const ScaleType = 'http://qudt.org/schema/qudt/ScaleType';\nexport const StructuredDatatype = 'http://qudt.org/schema/qudt/StructuredDatatype';\nexport const Symbol__workaround = 'http://qudt.org/schema/qudt/Symbol';\nexport const SystemOfUnits = 'http://qudt.org/schema/qudt/SystemOfUnits';\nexport const UserQuantityKind = 'http://qudt.org/schema/qudt/UserQuantityKind';\nexport const hasBaseQuantityKind = 'http://qudt.org/schema/qudt/hasBaseQuantityKind';\nexport const hasRule = 'http://qudt.org/schema/qudt/hasRule';\nexport const encoding = 'http://qudt.org/schema/qudt/encoding';\nexport const bitOrder = 'http://qudt.org/schema/qudt/bitOrder';\nexport const byteOrder = 'http://qudt.org/schema/qudt/byteOrder';\nexport const default__workaround = 'http://qudt.org/schema/qudt/default';\nexport const element = 'http://qudt.org/schema/qudt/element';\nexport const dataEncoding = 'http://qudt.org/schema/qudt/dataEncoding';\nexport const dataType = 'http://qudt.org/schema/qudt/dataType';\nexport const unit = 'http://qudt.org/schema/qudt/unit';\nexport const value = 'http://qudt.org/schema/qudt/value';\nexport const quantityValue = 'http://qudt.org/schema/qudt/quantityValue';\nexport const hasQuantityKind = 'http://qudt.org/schema/qudt/hasQuantityKind';\nexport const generalization = 'http://qudt.org/schema/qudt/generalization';\nexport const hasDimensionVector = 'http://qudt.org/schema/qudt/hasDimensionVector';\nexport const dimensionVectorForSI = 'http://qudt.org/schema/qudt/dimensionVectorForSI';\nexport const isQuantityKindOf = 'http://qudt.org/schema/qudt/isQuantityKindOf';\nexport const qkdvDenominator = 'http://qudt.org/schema/qudt/qkdvDenominator';\nexport const qkdvNumerator = 'http://qudt.org/schema/qudt/qkdvNumerator';\nexport const applicableCGSUnit = 'http://qudt.org/schema/qudt/applicableCGSUnit';\nexport const applicableISOUnit = 'http://qudt.org/schema/qudt/applicableISOUnit';\nexport const applicableImperialUnit = 'http://qudt.org/schema/qudt/applicableImperialUnit';\nexport const applicableSIUnit = 'http://qudt.org/schema/qudt/applicableSIUnit';\nexport const applicableUSCustomaryUnit = 'http://qudt.org/schema/qudt/applicableUSCustomaryUnit';\nexport const applicableUnit = 'http://qudt.org/schema/qudt/applicableUnit';\nexport const ruleType = 'http://qudt.org/schema/qudt/ruleType';\nexport const permissibleMaths = 'http://qudt.org/schema/qudt/permissibleMaths';\nexport const scaleType = 'http://qudt.org/schema/qudt/scaleType';\nexport const permissibleTransformation = 'http://qudt.org/schema/qudt/permissibleTransformation';\nexport const baseDimensionEnumeration = 'http://qudt.org/schema/qudt/baseDimensionEnumeration';\nexport const hasUnitSystem = 'http://qudt.org/schema/qudt/hasUnitSystem';\nexport const applicablePhysicalConstant = 'http://qudt.org/schema/qudt/applicablePhysicalConstant';\nexport const hasAllowedUnit = 'http://qudt.org/schema/qudt/hasAllowedUnit';\nexport const hasBaseUnit = 'http://qudt.org/schema/qudt/hasBaseUnit';\nexport const hasCoherentUnit = 'http://qudt.org/schema/qudt/hasCoherentUnit';\nexport const hasDefinedUnit = 'http://qudt.org/schema/qudt/hasDefinedUnit';\nexport const hasDerivedCoherentUnit = 'http://qudt.org/schema/qudt/hasDerivedCoherentUnit';\nexport const hasDerivedUnit = 'http://qudt.org/schema/qudt/hasDerivedUnit';\nexport const hasUnit = 'http://qudt.org/schema/qudt/hasUnit';\nexport const unitOfSystem = 'http://qudt.org/schema/qudt/unitOfSystem';\nexport const allowedUnitOfSystem = 'http://qudt.org/schema/qudt/allowedUnitOfSystem';\nexport const applicablePlanckUnit = 'http://qudt.org/schema/qudt/applicablePlanckUnit';\nexport const baseUnitOfSystem = 'http://qudt.org/schema/qudt/baseUnitOfSystem';\nexport const coherentUnitOfSystem = 'http://qudt.org/schema/qudt/coherentUnitOfSystem';\nexport const belongsToSystemOfQuantities = 'http://qudt.org/schema/qudt/belongsToSystemOfQuantities';\nexport const categorizedAs = 'http://qudt.org/schema/qudt/categorizedAs';\nexport const definedUnitOfSystem = 'http://qudt.org/schema/qudt/definedUnitOfSystem';\nexport const coherentUnitSystem = 'http://qudt.org/schema/qudt/coherentUnitSystem';\nexport const denominatorDimensionVector = 'http://qudt.org/schema/qudt/denominatorDimensionVector';\nexport const derivedCoherentUnitOfSystem = 'http://qudt.org/schema/qudt/derivedCoherentUnitOfSystem';\nexport const derivedUnitOfSystem = 'http://qudt.org/schema/qudt/derivedUnitOfSystem';\nexport const derivedNonCoherentUnitOfSystem = 'http://qudt.org/schema/qudt/derivedNonCoherentUnitOfSystem';\nexport const hasDerivedNonCoherentUnit = 'http://qudt.org/schema/qudt/hasDerivedNonCoherentUnit';\nexport const derivedQuantityKindOfSystem = 'http://qudt.org/schema/qudt/derivedQuantityKindOfSystem';\nexport const systemDerivedQuantityKind = 'http://qudt.org/schema/qudt/systemDerivedQuantityKind';\nexport const dimensionInverse = 'http://qudt.org/schema/qudt/dimensionInverse';\nexport const elementKind = 'http://qudt.org/schema/qudt/elementKind';\nexport const exactMatch = 'http://qudt.org/schema/qudt/exactMatch';\nexport const figure = 'http://qudt.org/schema/qudt/figure';\nexport const specialization = 'http://qudt.org/schema/qudt/specialization';\nexport const isBaseQuantityKindOfSystem = 'http://qudt.org/schema/qudt/isBaseQuantityKindOfSystem';\nexport const hasDenominatorPart = 'http://qudt.org/schema/qudt/hasDenominatorPart';\nexport const hasDimension = 'http://qudt.org/schema/qudt/hasDimension';\nexport const hasDimensionExpression = 'http://qudt.org/schema/qudt/hasDimensionExpression';\nexport const hasNonCoherentUnit = 'http://qudt.org/schema/qudt/hasNonCoherentUnit';\nexport const hasNumeratorPart = 'http://qudt.org/schema/qudt/hasNumeratorPart';\nexport const hasPrefixUnit = 'http://qudt.org/schema/qudt/hasPrefixUnit';\nexport const hasQuantity = 'http://qudt.org/schema/qudt/hasQuantity';\nexport const hasReferenceQuantityKind = 'http://qudt.org/schema/qudt/hasReferenceQuantityKind';\nexport const hasVocabulary = 'http://qudt.org/schema/qudt/hasVocabulary';\nexport const isDimensionInSystem = 'http://qudt.org/schema/qudt/isDimensionInSystem';\nexport const isScalingOf = 'http://qudt.org/schema/qudt/isScalingOf';\nexport const numeratorDimensionVector = 'http://qudt.org/schema/qudt/numeratorDimensionVector';\nexport const omUnit = 'http://qudt.org/schema/qudt/omUnit';\nexport const prefix = 'http://qudt.org/schema/qudt/prefix';\nexport const quantity = 'http://qudt.org/schema/qudt/quantity';\nexport const reference = 'http://qudt.org/schema/qudt/reference';\nexport const referenceUnit = 'http://qudt.org/schema/qudt/referenceUnit';\nexport const relevantQuantityKind = 'http://qudt.org/schema/qudt/relevantQuantityKind';\nexport const relevantUnit = 'http://qudt.org/schema/qudt/relevantUnit';\nexport const systemDefinition = 'http://qudt.org/schema/qudt/systemDefinition';\nexport const systemDimension = 'http://qudt.org/schema/qudt/systemDimension';\nexport const unitFor = 'http://qudt.org/schema/qudt/unitFor';\nexport const valueQuantity = 'http://qudt.org/schema/qudt/valueQuantity';\nexport const latexSymbol = 'http://qudt.org/schema/qudt/latexSymbol';\nexport const symbol = 'http://qudt.org/schema/qudt/symbol';\nexport const informativeReference = 'http://qudt.org/schema/qudt/informativeReference';\nexport const vectorMagnitude = 'http://qudt.org/schema/qudt/vectorMagnitude';\nexport const literal = 'http://qudt.org/schema/qudt/literal';\nexport const plainTextDescription = 'http://qudt.org/schema/qudt/plainTextDescription';\nexport const description = 'http://qudt.org/schema/qudt/description';\nexport const url = 'http://qudt.org/schema/qudt/url';\nexport const rationale = 'http://qudt.org/schema/qudt/rationale';\nexport const abbreviation = 'http://qudt.org/schema/qudt/abbreviation';\nexport const id = 'http://qudt.org/schema/qudt/id';\nexport const exactConstant = 'http://qudt.org/schema/qudt/exactConstant';\nexport const javaName = 'http://qudt.org/schema/qudt/javaName';\nexport const jsName = 'http://qudt.org/schema/qudt/jsName';\nexport const matlabName = 'http://qudt.org/schema/qudt/matlabName';\nexport const microsoftSQLServerName = 'http://qudt.org/schema/qudt/microsoftSQLServerName';\nexport const mySQLName = 'http://qudt.org/schema/qudt/mySQLName';\nexport const odbcName = 'http://qudt.org/schema/qudt/odbcName';\nexport const oleDBName = 'http://qudt.org/schema/qudt/oleDBName';\nexport const dbpediaMatch = 'http://qudt.org/schema/qudt/dbpediaMatch';\nexport const imageLocation = 'http://qudt.org/schema/qudt/imageLocation';\nexport const figureCaption = 'http://qudt.org/schema/qudt/figureCaption';\nexport const figureLabel = 'http://qudt.org/schema/qudt/figureLabel';\nexport const height = 'http://qudt.org/schema/qudt/height';\nexport const image = 'http://qudt.org/schema/qudt/image';\nexport const landscape = 'http://qudt.org/schema/qudt/landscape';\nexport const width = 'http://qudt.org/schema/qudt/width';\nexport const order = 'http://qudt.org/schema/qudt/order';\nexport const latexDefinition = 'http://qudt.org/schema/qudt/latexDefinition';\nexport const mathMLdefinition = 'http://qudt.org/schema/qudt/mathMLdefinition';\nexport const ucumCode = 'http://qudt.org/schema/qudt/ucumCode';\nexport const prefixMultiplier = 'http://qudt.org/schema/qudt/prefixMultiplier';\nexport const relativeStandardUncertainty = 'http://qudt.org/schema/qudt/relativeStandardUncertainty';\nexport const standardUncertainty = 'http://qudt.org/schema/qudt/standardUncertainty';\nexport const isDeltaQuantity = 'http://qudt.org/schema/qudt/isDeltaQuantity';\nexport const baseCGSUnitDimensions = 'http://qudt.org/schema/qudt/baseCGSUnitDimensions';\nexport const baseISOUnitDimensions = 'http://qudt.org/schema/qudt/baseISOUnitDimensions';\nexport const baseImperialUnitDimensions = 'http://qudt.org/schema/qudt/baseImperialUnitDimensions';\nexport const baseSIUnitDimensions = 'http://qudt.org/schema/qudt/baseSIUnitDimensions';\nexport const baseUSCustomaryUnitDimensions = 'http://qudt.org/schema/qudt/baseUSCustomaryUnitDimensions';\nexport const baseUnitDimensions = 'http://qudt.org/schema/qudt/baseUnitDimensions';\nexport const dimensionExponentForAmountOfSubstance = 'http://qudt.org/schema/qudt/dimensionExponentForAmountOfSubstance';\nexport const dimensionExponentForElectricCurrent = 'http://qudt.org/schema/qudt/dimensionExponentForElectricCurrent';\nexport const dimensionExponentForLength = 'http://qudt.org/schema/qudt/dimensionExponentForLength';\nexport const dimensionExponentForLuminousIntensity = 'http://qudt.org/schema/qudt/dimensionExponentForLuminousIntensity';\nexport const dimensionExponentForMass = 'http://qudt.org/schema/qudt/dimensionExponentForMass';\nexport const dimensionExponentForThermodynamicTemperature = 'http://qudt.org/schema/qudt/dimensionExponentForThermodynamicTemperature';\nexport const dimensionExponentForTime = 'http://qudt.org/schema/qudt/dimensionExponentForTime';\nexport const dimensionlessExponent = 'http://qudt.org/schema/qudt/dimensionlessExponent';\nexport const maxExclusive = 'http://qudt.org/schema/qudt/maxExclusive';\nexport const maxInclusive = 'http://qudt.org/schema/qudt/maxInclusive';\nexport const minInclusive = 'http://qudt.org/schema/qudt/minInclusive';\nexport const dataStructure = 'http://qudt.org/schema/qudt/dataStructure';\nexport const iec61360Code = 'http://qudt.org/schema/qudt/iec61360Code';\nexport const conversionMultiplier = 'http://qudt.org/schema/qudt/conversionMultiplier';\nexport const conversionOffset = 'http://qudt.org/schema/qudt/conversionOffset';\nexport const siUnitsExpression = 'http://qudt.org/schema/qudt/siUnitsExpression';\nexport const isoNormativeReference = 'http://qudt.org/schema/qudt/isoNormativeReference';\nexport const normativeReference = 'http://qudt.org/schema/qudt/normativeReference';\nexport const acronym = 'http://qudt.org/schema/qudt/acronym';\nexport const citation = 'http://qudt.org/schema/qudt/citation';\nexport const code = 'http://qudt.org/schema/qudt/code';\nexport const conversionCoefficient = 'http://qudt.org/schema/qudt/conversionCoefficient';\nexport const currencyExponent = 'http://qudt.org/schema/qudt/currencyExponent';\nexport const dimensionExponent = 'http://qudt.org/schema/qudt/dimensionExponent';\nexport const fieldCode = 'http://qudt.org/schema/qudt/fieldCode';\nexport const guidance = 'http://qudt.org/schema/qudt/guidance';\nexport const isMetricUnit = 'http://qudt.org/schema/qudt/isMetricUnit';\nexport const lowerBound = 'http://qudt.org/schema/qudt/lowerBound';\nexport const mathDefinition = 'http://qudt.org/schema/qudt/mathDefinition';\nexport const upperBound = 'http://qudt.org/schema/qudt/upperBound';\nexport const negativeDeltaLimit = 'http://qudt.org/schema/qudt/negativeDeltaLimit';\nexport const numericValue = 'http://qudt.org/schema/qudt/numericValue';\nexport const onlineReference = 'http://qudt.org/schema/qudt/onlineReference';\nexport const outOfScope = 'http://qudt.org/schema/qudt/outOfScope';\nexport const positiveDeltaLimit = 'http://qudt.org/schema/qudt/positiveDeltaLimit';\nexport const uneceCommonCode = 'http://qudt.org/schema/qudt/uneceCommonCode';\nexport const Aspect = 'http://qudt.org/schema/qudt/Aspect';\nexport const BigEndian = 'http://qudt.org/schema/qudt/BigEndian';\nexport const BooleanEncoding = 'http://qudt.org/schema/qudt/BooleanEncoding';\nexport const CT_FINITE = 'http://qudt.org/schema/qudt/CT_FINITE';\nexport const CT_UNCOUNTABLE = 'http://qudt.org/schema/qudt/CT_UNCOUNTABLE';\nexport const CharEncoding = 'http://qudt.org/schema/qudt/CharEncoding';\nexport const Verifiable = 'http://qudt.org/schema/qudt/Verifiable';\nexport const DoublePrecisionEncoding = 'http://qudt.org/schema/qudt/DoublePrecisionEncoding';\nexport const IEEE754_1985RealEncoding = 'http://qudt.org/schema/qudt/IEEE754_1985RealEncoding';\nexport const LittleEndian = 'http://qudt.org/schema/qudt/LittleEndian';\nexport const LongUnsignedIntegerEncoding = 'http://qudt.org/schema/qudt/LongUnsignedIntegerEncoding';\nexport const OctetEncoding = 'http://qudt.org/schema/qudt/OctetEncoding';\nexport const Unordered = 'http://qudt.org/schema/qudt/Unordered';\nexport const PartiallyOrdered = 'http://qudt.org/schema/qudt/PartiallyOrdered';\nexport const TotallyOrdered = 'http://qudt.org/schema/qudt/TotallyOrdered';\nexport const expression = 'http://qudt.org/schema/qudt/expression';\nexport const example = 'http://qudt.org/schema/qudt/example';\nexport const SIGNED = 'http://qudt.org/schema/qudt/SIGNED';\nexport const ShortSignedIntegerEncoding = 'http://qudt.org/schema/qudt/ShortSignedIntegerEncoding';\nexport const ShortUnsignedIntegerEncoding = 'http://qudt.org/schema/qudt/ShortUnsignedIntegerEncoding';\nexport const SignedIntegerEncoding = 'http://qudt.org/schema/qudt/SignedIntegerEncoding';\nexport const UNSIGNED = 'http://qudt.org/schema/qudt/UNSIGNED';\nexport const SinglePrecisionRealEncoding = 'http://qudt.org/schema/qudt/SinglePrecisionRealEncoding';\nexport const UnsignedIntegerEncoding = 'http://qudt.org/schema/qudt/UnsignedIntegerEncoding';\nexport const Wikipedia = 'http://qudt.org/schema/qudt/Wikipedia';\nexport const ucumCaseInsensitiveCode = 'http://qudt.org/schema/qudt/ucumCaseInsensitiveCode';\nexport const ucumCaseSensitiveCode = 'http://qudt.org/schema/qudt/ucumCaseSensitiveCode';\n//# sourceMappingURL=qudt.js.map","export const FeatureOfInterest = 'http://www.w3.org/ns/sosa/FeatureOfInterest';\nexport const ObservableProperty = 'http://www.w3.org/ns/sosa/ObservableProperty';\nexport const ActuatableProperty = 'http://www.w3.org/ns/sosa/ActuatableProperty';\nexport const Sample = 'http://www.w3.org/ns/sosa/Sample';\nexport const Platform = 'http://www.w3.org/ns/sosa/Platform';\nexport const Actuator = 'http://www.w3.org/ns/sosa/Actuator';\nexport const Sensor = 'http://www.w3.org/ns/sosa/Sensor';\nexport const Sampler = 'http://www.w3.org/ns/sosa/Sampler';\nexport const Procedure = 'http://www.w3.org/ns/sosa/Procedure';\nexport const Actuation = 'http://www.w3.org/ns/sosa/Actuation';\nexport const Observation = 'http://www.w3.org/ns/sosa/Observation';\nexport const Sampling = 'http://www.w3.org/ns/sosa/Sampling';\nexport const Result = 'http://www.w3.org/ns/sosa/Result';\nexport const hasSample = 'http://www.w3.org/ns/sosa/hasSample';\nexport const isSampleOf = 'http://www.w3.org/ns/sosa/isSampleOf';\nexport const hosts = 'http://www.w3.org/ns/sosa/hosts';\nexport const isHostedBy = 'http://www.w3.org/ns/sosa/isHostedBy';\nexport const observes = 'http://www.w3.org/ns/sosa/observes';\nexport const isObservedBy = 'http://www.w3.org/ns/sosa/isObservedBy';\nexport const usedProcedure = 'http://www.w3.org/ns/sosa/usedProcedure';\nexport const hasFeatureOfInterest = 'http://www.w3.org/ns/sosa/hasFeatureOfInterest';\nexport const isFeatureOfInterestOf = 'http://www.w3.org/ns/sosa/isFeatureOfInterestOf';\nexport const madeObservation = 'http://www.w3.org/ns/sosa/madeObservation';\nexport const madeBySensor = 'http://www.w3.org/ns/sosa/madeBySensor';\nexport const observedProperty = 'http://www.w3.org/ns/sosa/observedProperty';\nexport const madeActuation = 'http://www.w3.org/ns/sosa/madeActuation';\nexport const madeByActuator = 'http://www.w3.org/ns/sosa/madeByActuator';\nexport const actsOnProperty = 'http://www.w3.org/ns/sosa/actsOnProperty';\nexport const isActedOnBy = 'http://www.w3.org/ns/sosa/isActedOnBy';\nexport const madeSampling = 'http://www.w3.org/ns/sosa/madeSampling';\nexport const madeBySampler = 'http://www.w3.org/ns/sosa/madeBySampler';\nexport const hasResult = 'http://www.w3.org/ns/sosa/hasResult';\nexport const isResultOf = 'http://www.w3.org/ns/sosa/isResultOf';\nexport const phenomenonTime = 'http://www.w3.org/ns/sosa/phenomenonTime';\nexport const hasSimpleResult = 'http://www.w3.org/ns/sosa/hasSimpleResult';\nexport const resultTime = 'http://www.w3.org/ns/sosa/resultTime';\n//# sourceMappingURL=sosa.js.map","export const Property = 'http://www.w3.org/ns/ssn/Property';\nexport const Stimulus = 'http://www.w3.org/ns/ssn/Stimulus';\nexport const System = 'http://www.w3.org/ns/ssn/System';\nexport const Deployment = 'http://www.w3.org/ns/ssn/Deployment';\nexport const Input = 'http://www.w3.org/ns/ssn/Input';\nexport const Output = 'http://www.w3.org/ns/ssn/Output';\nexport const hasProperty = 'http://www.w3.org/ns/ssn/hasProperty';\nexport const isPropertyOf = 'http://www.w3.org/ns/ssn/isPropertyOf';\nexport const isProxyFor = 'http://www.w3.org/ns/ssn/isProxyFor';\nexport const inDeployment = 'http://www.w3.org/ns/ssn/inDeployment';\nexport const deployedSystem = 'http://www.w3.org/ns/ssn/deployedSystem';\nexport const hasInput = 'http://www.w3.org/ns/ssn/hasInput';\nexport const hasOutput = 'http://www.w3.org/ns/ssn/hasOutput';\nexport const implementedBy = 'http://www.w3.org/ns/ssn/implementedBy';\nexport const _implements = 'http://www.w3.org/ns/ssn/implements';\nexport const detects = 'http://www.w3.org/ns/ssn/detects';\nexport const forProperty = 'http://www.w3.org/ns/ssn/forProperty';\nexport const wasOriginatedBy = 'http://www.w3.org/ns/ssn/wasOriginatedBy';\nexport const hasSubSystem = 'http://www.w3.org/ns/ssn/hasSubSystem';\nexport const hasDeployment = 'http://www.w3.org/ns/ssn/hasDeployment';\nexport const deployedOnPlatform = 'http://www.w3.org/ns/ssn/deployedOnPlatform';\n//# sourceMappingURL=ssn.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 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 __metadata = (this && this.__metadata) || function (k, v) {\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { SerializableMember, SerializableObject } from '@openhps/core';\nimport { sosa, rdfs } from '../vocab';\nlet ObservableProperty = class ObservableProperty {\n};\n__decorate([\n    SerializableMember({\n        rdf: {\n            predicate: rdfs.label,\n            language: 'en',\n        },\n    }),\n    __metadata(\"design:type\", String)\n], ObservableProperty.prototype, \"label\", void 0);\nObservableProperty = __decorate([\n    SerializableObject({\n        rdf: {\n            type: sosa.ObservableProperty,\n        },\n    })\n], ObservableProperty);\nexport { ObservableProperty };\n//# sourceMappingURL=ObservableProperty.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 __metadata = (this && this.__metadata) || function (k, v) {\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { SerializableArrayMember, SerializableMember, SerializableObject } from '@openhps/core';\nimport { ObservableProperty } from './ObservableProperty';\nimport { sosa } from '../vocab';\nlet Observation = class Observation {\n};\n__decorate([\n    SerializableMember({\n        rdf: {\n            predicate: sosa.phenomenonTime,\n        },\n    }),\n    __metadata(\"design:type\", Date)\n], Observation.prototype, \"phenomenonTime\", void 0);\n__decorate([\n    SerializableMember({\n        rdf: {\n            predicate: sosa.resultTime,\n        },\n    }),\n    __metadata(\"design:type\", Date)\n], Observation.prototype, \"resultTime\", void 0);\n__decorate([\n    SerializableArrayMember(ObservableProperty, {\n        rdf: {\n            predicate: sosa.observedProperty,\n        },\n    }),\n    __metadata(\"design:type\", Array)\n], Observation.prototype, \"observedProperties\", void 0);\nObservation = __decorate([\n    SerializableObject({\n        rdf: {\n            type: sosa.Observation,\n            serializer: (object) => {\n                return {\n                    value: `${object.observedProperties[0]}/${object.phenomenonTime.getTime()}`,\n                };\n            },\n        },\n    })\n], Observation);\nexport { Observation };\n//# sourceMappingURL=Observation.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 __metadata = (this && this.__metadata) || function (k, v) {\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { SerializableArrayMember, SerializableMember, SerializableObject } from '@openhps/core';\nimport { ObservableProperty } from './ObservableProperty';\nimport { sosa, ssn, rdfs } from '../vocab';\nlet FeatureOfInterest = class FeatureOfInterest {\n};\n__decorate([\n    SerializableMember({\n        rdf: {\n            predicate: rdfs.label,\n            language: 'en',\n        },\n    }),\n    __metadata(\"design:type\", String)\n], FeatureOfInterest.prototype, \"label\", void 0);\n__decorate([\n    SerializableArrayMember(ObservableProperty, {\n        rdf: {\n            predicate: ssn.hasProperty,\n        },\n    }),\n    __metadata(\"design:type\", Array)\n], FeatureOfInterest.prototype, \"properties\", void 0);\nFeatureOfInterest = __decorate([\n    SerializableObject({\n        rdf: {\n            type: sosa.FeatureOfInterest,\n        },\n    })\n], FeatureOfInterest);\nexport { FeatureOfInterest };\n//# sourceMappingURL=FeatureOfInterest.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 __metadata = (this && this.__metadata) || function (k, v) {\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { SerializableMember, SerializableObject, Unit } from '@openhps/core';\nimport { xsd } from '../decorators';\nimport { qudt } from '../vocab';\nlet QuantityValue = class QuantityValue {\n};\n__decorate([\n    SerializableMember({\n        rdf: {\n            predicate: qudt.numericValue,\n            datatype: xsd.double,\n        },\n    }),\n    __metadata(\"design:type\", Number)\n], QuantityValue.prototype, \"value\", void 0);\n__decorate([\n    SerializableMember({\n        rdf: {\n            predicate: qudt.unit,\n        },\n    }),\n    __metadata(\"design:type\", Unit)\n], QuantityValue.prototype, \"unit\", void 0);\nQuantityValue = __decorate([\n    SerializableObject({\n        rdf: {\n            type: qudt.QuantityValue,\n        },\n    })\n], QuantityValue);\nexport { QuantityValue };\n//# sourceMappingURL=QuantityValue.js.map"],"names":["exports","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","this","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","module","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","self","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","__WEBPACK_EXTERNAL_MODULE__openhps_core_es_min_js_27733f5f__","DataSerializer","Deserializer","SerializableArrayMember","SerializableMember","SerializableObject","Serializer","Unit","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","factory","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","serializationStrategy","Map","serializeLiteral","Boolean","Date","serializeDate","serializeArray","serializeMap","Set","serializeSet","convertSingleValue","sourceObject","typeDescriptor","memberName","memberOptions","serializerOptions","retrievePreserveNull","serializer","serializeObject","hasFriendlyName","errorHandler","metadata","rootMetadata","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","isDefinedBy","label","comment","subClassOf","domain","subPropertyOf","seeAlso","ContainerMembershipProperty","Resource","Class","Container","Datatype","cardinality","basis","orderedType","ansiSQLName","bounded","cName","oracleSQLName","protocolBuffersName","pythonName","vbName","allowedPattern","bits","rdfsDatatype","minExclusive","AspectClass","LatexString","UCUMci","UCUMcs","floatPercentage","integerPercentage","valueUnion","AbstractQuantityKind","Concept","QuantityKind","BaseDimensionMagnitude","EndianType","BinaryPrefix","Prefix","BitEncodingType","Encoding","BooleanEncodingType","ByteEncodingType","CardinalityType","EnumeratedValue","CharEncodingType","Citation","Comment","Rule","ConstantValue","QuantityValue","CountingUnit","DimensionlessUnit","CurrencyUnit","DataEncoding","OrderedType","DateTimeStringEncodingType","StringEncodingType","DecimalPrefix","DerivedUnit","Discipline","FloatingPointEncodingType","Enumeration","EnumerationScale","Scale","Figure","IntegerEncodingType","IntervalScale","NominalScale","OrdinalScale","RatioScale","LogarithmicUnit","MathFunctionType","NIST_SP811_Comment","Organization","PhysicalConstant","Quantity","Quantifiable","QuantityKindDimensionVector","QuantityKindDimensionVector_SI","SystemOfQuantityKinds","QuantityKindDimensionVector_CGS","QuantityKindDimensionVector_ISO","QuantityKindDimensionVector_Imperial","QuantityType","RuleType","SignednessType","ScalarDatatype","ScaleType","StructuredDatatype","Symbol__workaround","SystemOfUnits","UserQuantityKind","hasBaseQuantityKind","hasRule","bitOrder","byteOrder","default__workaround","dataEncoding","dataType","unit","quantityValue","hasQuantityKind","generalization","hasDimensionVector","dimensionVectorForSI","isQuantityKindOf","qkdvDenominator","qkdvNumerator","applicableCGSUnit","applicableISOUnit","applicableImperialUnit","applicableSIUnit","applicableUSCustomaryUnit","applicableUnit","ruleType","permissibleMaths","scaleType","permissibleTransformation","baseDimensionEnumeration","hasUnitSystem","applicablePhysicalConstant","hasAllowedUnit","hasBaseUnit","hasCoherentUnit","hasDefinedUnit","hasDerivedCoherentUnit","hasDerivedUnit","hasUnit","unitOfSystem","allowedUnitOfSystem","applicablePlanckUnit","baseUnitOfSystem","coherentUnitOfSystem","belongsToSystemOfQuantities","categorizedAs","definedUnitOfSystem","coherentUnitSystem","denominatorDimensionVector","derivedCoherentUnitOfSystem","derivedUnitOfSystem","derivedNonCoherentUnitOfSystem","hasDerivedNonCoherentUnit","derivedQuantityKindOfSystem","systemDerivedQuantityKind","dimensionInverse","elementKind","exactMatch","figure","specialization","isBaseQuantityKindOfSystem","hasDenominatorPart","hasDimension","hasDimensionExpression","hasNonCoherentUnit","hasNumeratorPart","hasPrefixUnit","hasQuantity","hasReferenceQuantityKind","hasVocabulary","isDimensionInSystem","isScalingOf","numeratorDimensionVector","omUnit","quantity","reference","referenceUnit","relevantQuantityKind","relevantUnit","systemDefinition","systemDimension","unitFor","valueQuantity","latexSymbol","symbol","informativeReference","vectorMagnitude","plainTextDescription","description","url","rationale","abbreviation","exactConstant","javaName","jsName","matlabName","microsoftSQLServerName","mySQLName","odbcName","oleDBName","dbpediaMatch","imageLocation","figureCaption","figureLabel","height","landscape","width","order","latexDefinition","mathMLdefinition","ucumCode","prefixMultiplier","relativeStandardUncertainty","standardUncertainty","isDeltaQuantity","baseCGSUnitDimensions","baseISOUnitDimensions","baseImperialUnitDimensions","baseSIUnitDimensions","baseUSCustomaryUnitDimensions","baseUnitDimensions","dimensionExponentForAmountOfSubstance","dimensionExponentForElectricCurrent","dimensionExponentForLength","dimensionExponentForLuminousIntensity","dimensionExponentForMass","dimensionExponentForThermodynamicTemperature","dimensionExponentForTime","dimensionlessExponent","maxExclusive","maxInclusive","minInclusive","dataStructure","iec61360Code","conversionMultiplier","conversionOffset","siUnitsExpression","isoNormativeReference","normativeReference","acronym","citation","conversionCoefficient","currencyExponent","dimensionExponent","fieldCode","guidance","isMetricUnit","lowerBound","mathDefinition","upperBound","negativeDeltaLimit","numericValue","onlineReference","outOfScope","positiveDeltaLimit","uneceCommonCode","Aspect","BigEndian","BooleanEncoding","CT_FINITE","CT_UNCOUNTABLE","CharEncoding","Verifiable","DoublePrecisionEncoding","IEEE754_1985RealEncoding","LittleEndian","LongUnsignedIntegerEncoding","OctetEncoding","Unordered","PartiallyOrdered","TotallyOrdered","expression","example","SIGNED","ShortSignedIntegerEncoding","ShortUnsignedIntegerEncoding","SignedIntegerEncoding","UNSIGNED","SinglePrecisionRealEncoding","UnsignedIntegerEncoding","Wikipedia","ucumCaseInsensitiveCode","ucumCaseSensitiveCode","FeatureOfInterest","ObservableProperty","ActuatableProperty","Sample","Platform","Actuator","Sensor","Sampler","Procedure","Actuation","Observation","Sampling","Result","hasSample","isSampleOf","hosts","isHostedBy","observes","isObservedBy","usedProcedure","hasFeatureOfInterest","isFeatureOfInterestOf","madeObservation","madeBySensor","observedProperty","madeActuation","madeByActuator","actsOnProperty","isActedOnBy","madeSampling","madeBySampler","hasResult","isResultOf","phenomenonTime","hasSimpleResult","resultTime","Stimulus","System","Deployment","Input","Output","hasProperty","isPropertyOf","isProxyFor","inDeployment","deployedSystem","hasInput","hasOutput","implementedBy","_implements","detects","forProperty","wasOriginatedBy","hasSubSystem","hasDeployment","deployedOnPlatform","rdfs","qudt","sosa","ssn","InternalRDFDeserializer","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","vcard","dcterms","dcmi","dqm","foaf","qudt_unit","quantitykind","ssns","openhps","ogc","__awaiter","thisArg","_arguments","P","generator","fulfilled","step","rejected","adopt","RDFSerializer","static","meta","getMetadata","typeIri","_b","serialize","store","quadsToThing","deserialize","serializeToQuads","ns","filteredPrefixes","namespace","writer","prettyPrint","writeBlankNode","blankNodePredicates","serializedData","ensureTypeDescriptor","getUriMetadata","eventEmitter","types","registerRDFType","__decorate","decorators","desc","decorate","__metadata","observedProperties"],"sourceRoot":""}
+{"version":3,"file":"web/openhps-rdf.serialization.es.min.js","mappings":"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","sources":["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/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/external module \"./openhps-core.es.min.js\"","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":["'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","// 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};","var x = y => { var x = {}; __webpack_require__.d(x, y); return x; }\nvar y = x => () => x\nconst __WEBPACK_NAMESPACE_OBJECT__ = x({ [\"DataSerializer\"]: () => __WEBPACK_EXTERNAL_MODULE__openhps_core_es_min_js_27733f5f__.DataSerializer, [\"Deserializer\"]: () => __WEBPACK_EXTERNAL_MODULE__openhps_core_es_min_js_27733f5f__.Deserializer, [\"SerializableObject\"]: () => __WEBPACK_EXTERNAL_MODULE__openhps_core_es_min_js_27733f5f__.SerializableObject, [\"Serializer\"]: () => __WEBPACK_EXTERNAL_MODULE__openhps_core_es_min_js_27733f5f__.Serializer });","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 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 __metadata = (this && this.__metadata) || function (k, v) {\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nvar SerializableNamedNode_1;\nimport { SerializableObject } from '@openhps/core';\nimport * as N3 from 'n3';\nlet SerializableNamedNode = SerializableNamedNode_1 = class SerializableNamedNode extends N3.NamedNode {\n    constructor(uri) {\n        super(uri);\n    }\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    __metadata(\"design:paramtypes\", [String])\n], SerializableNamedNode);\nexport { SerializableNamedNode };\n//# sourceMappingURL=SerializableNamedNode.js.map"],"names":["exports","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","this","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","module","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","self","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","__WEBPACK_EXTERNAL_MODULE__openhps_core_es_min_js_27733f5f__","DataSerializer","Deserializer","SerializableObject","Serializer","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","factory","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","serializationStrategy","Map","serializeLiteral","Boolean","Date","serializeDate","serializeArray","serializeMap","Set","serializeSet","convertSingleValue","sourceObject","typeDescriptor","memberName","memberOptions","serializerOptions","retrievePreserveNull","serializer","serializeObject","hasFriendlyName","errorHandler","metadata","rootMetadata","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","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","ns","filteredPrefixes","namespace","writer","prettyPrint","writeBlankNode","blankNodePredicates","serializedData","dataType","ensureTypeDescriptor","getUriMetadata","eventEmitter","types","registerRDFType","SerializableNamedNode_1","__decorate","decorators","desc","decorate","__metadata","SerializableNamedNode"],"sourceRoot":""}