{"version":3,"file":"js/vendor/readable-stream.a6015678.js","mappings":"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","sources":["webpack://NX/./node_modules/readable-stream/lib/_stream_duplex.js","webpack://NX/./node_modules/readable-stream/lib/_stream_passthrough.js","webpack://NX/./node_modules/readable-stream/lib/_stream_readable.js","webpack://NX/./node_modules/readable-stream/lib/_stream_transform.js","webpack://NX/./node_modules/readable-stream/lib/_stream_writable.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/add-abort-signal.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/buffer_list.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/compose.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/destroy.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/duplex.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/duplexify.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/end-of-stream.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/from.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/legacy.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/operators.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/passthrough.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/pipeline.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/readable.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/state.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/transform.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/utils.js","webpack://NX/./node_modules/readable-stream/lib/internal/streams/writable.js","webpack://NX/./node_modules/readable-stream/lib/internal/validators.js","webpack://NX/./node_modules/readable-stream/lib/ours/browser.js","webpack://NX/./node_modules/readable-stream/lib/ours/errors.js","webpack://NX/./node_modules/readable-stream/lib/ours/primordials.js","webpack://NX/./node_modules/readable-stream/lib/ours/util.js","webpack://NX/./node_modules/readable-stream/lib/stream.js","webpack://NX/./node_modules/readable-stream/lib/stream/promises.js"],"sourcesContent":["'use strict'\n\n// Keep this file as an alias for the full stream module.\nmodule.exports = require('./stream').Duplex\n","'use strict'\n\n// Keep this file as an alias for the full stream module.\nmodule.exports = require('./stream').PassThrough\n","'use strict'\n\n// Keep this file as an alias for the full stream module.\nmodule.exports = require('./stream').Readable\n","'use strict'\n\n// Keep this file as an alias for the full stream module.\nmodule.exports = require('./stream').Transform\n","'use strict'\n\n// Keep this file as an alias for the full stream module.\nmodule.exports = require('./stream').Writable\n","'use strict'\n\nconst { AbortError, codes } = require('../../ours/errors')\nconst eos = require('./end-of-stream')\nconst { ERR_INVALID_ARG_TYPE } = codes\n\n// This method is inlined here for readable-stream\n// It also does not allow for signal to not exist on the stream\n// https://github.com/nodejs/node/pull/36061#discussion_r533718029\nconst validateAbortSignal = (signal, name) => {\n  if (typeof signal !== 'object' || !('aborted' in signal)) {\n    throw new ERR_INVALID_ARG_TYPE(name, 'AbortSignal', signal)\n  }\n}\nfunction isNodeStream(obj) {\n  return !!(obj && typeof obj.pipe === 'function')\n}\nmodule.exports.addAbortSignal = function addAbortSignal(signal, stream) {\n  validateAbortSignal(signal, 'signal')\n  if (!isNodeStream(stream)) {\n    throw new ERR_INVALID_ARG_TYPE('stream', 'stream.Stream', stream)\n  }\n  return module.exports.addAbortSignalNoValidate(signal, stream)\n}\nmodule.exports.addAbortSignalNoValidate = function (signal, stream) {\n  if (typeof signal !== 'object' || !('aborted' in signal)) {\n    return stream\n  }\n  const onAbort = () => {\n    stream.destroy(\n      new AbortError(undefined, {\n        cause: signal.reason\n      })\n    )\n  }\n  if (signal.aborted) {\n    onAbort()\n  } else {\n    signal.addEventListener('abort', onAbort)\n    eos(stream, () => signal.removeEventListener('abort', onAbort))\n  }\n  return stream\n}\n","'use strict'\n\nconst { StringPrototypeSlice, SymbolIterator, TypedArrayPrototypeSet, Uint8Array } = require('../../ours/primordials')\nconst { Buffer } = require('buffer')\nconst { inspect } = require('../../ours/util')\nmodule.exports = class BufferList {\n  constructor() {\n    this.head = null\n    this.tail = null\n    this.length = 0\n  }\n  push(v) {\n    const entry = {\n      data: v,\n      next: null\n    }\n    if (this.length > 0) this.tail.next = entry\n    else this.head = entry\n    this.tail = entry\n    ++this.length\n  }\n  unshift(v) {\n    const 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  shift() {\n    if (this.length === 0) return\n    const ret = this.head.data\n    if (this.length === 1) this.head = this.tail = null\n    else this.head = this.head.next\n    --this.length\n    return ret\n  }\n  clear() {\n    this.head = this.tail = null\n    this.length = 0\n  }\n  join(s) {\n    if (this.length === 0) return ''\n    let p = this.head\n    let ret = '' + p.data\n    while ((p = p.next) !== null) ret += s + p.data\n    return ret\n  }\n  concat(n) {\n    if (this.length === 0) return Buffer.alloc(0)\n    const ret = Buffer.allocUnsafe(n >>> 0)\n    let p = this.head\n    let i = 0\n    while (p) {\n      TypedArrayPrototypeSet(ret, p.data, i)\n      i += p.data.length\n      p = p.next\n    }\n    return ret\n  }\n\n  // Consumes a specified amount of bytes or characters from the buffered data.\n  consume(n, hasStrings) {\n    const data = this.head.data\n    if (n < data.length) {\n      // `slice` is the same for buffers and strings.\n      const slice = data.slice(0, n)\n      this.head.data = data.slice(n)\n      return slice\n    }\n    if (n === data.length) {\n      // First chunk is a perfect match.\n      return this.shift()\n    }\n    // Result spans more than one buffer.\n    return hasStrings ? this._getString(n) : this._getBuffer(n)\n  }\n  first() {\n    return this.head.data\n  }\n  *[SymbolIterator]() {\n    for (let p = this.head; p; p = p.next) {\n      yield p.data\n    }\n  }\n\n  // Consumes a specified amount of characters from the buffered data.\n  _getString(n) {\n    let ret = ''\n    let p = this.head\n    let c = 0\n    do {\n      const str = p.data\n      if (n > str.length) {\n        ret += str\n        n -= str.length\n      } else {\n        if (n === str.length) {\n          ret += str\n          ++c\n          if (p.next) this.head = p.next\n          else this.head = this.tail = null\n        } else {\n          ret += StringPrototypeSlice(str, 0, n)\n          this.head = p\n          p.data = StringPrototypeSlice(str, n)\n        }\n        break\n      }\n      ++c\n    } while ((p = p.next) !== null)\n    this.length -= c\n    return ret\n  }\n\n  // Consumes a specified amount of bytes from the buffered data.\n  _getBuffer(n) {\n    const ret = Buffer.allocUnsafe(n)\n    const retLen = n\n    let p = this.head\n    let c = 0\n    do {\n      const buf = p.data\n      if (n > buf.length) {\n        TypedArrayPrototypeSet(ret, buf, retLen - n)\n        n -= buf.length\n      } else {\n        if (n === buf.length) {\n          TypedArrayPrototypeSet(ret, buf, retLen - n)\n          ++c\n          if (p.next) this.head = p.next\n          else this.head = this.tail = null\n        } else {\n          TypedArrayPrototypeSet(ret, new Uint8Array(buf.buffer, buf.byteOffset, n), retLen - n)\n          this.head = p\n          p.data = buf.slice(n)\n        }\n        break\n      }\n      ++c\n    } while ((p = p.next) !== null)\n    this.length -= c\n    return ret\n  }\n\n  // Make sure the linked list only shows the minimal necessary information.\n  [Symbol.for('nodejs.util.inspect.custom')](_, options) {\n    return inspect(this, {\n      ...options,\n      // Only inspect one level.\n      depth: 0,\n      // It should not recurse.\n      customInspect: false\n    })\n  }\n}\n","'use strict'\n\nconst { pipeline } = require('./pipeline')\nconst Duplex = require('./duplex')\nconst { destroyer } = require('./destroy')\nconst { isNodeStream, isReadable, isWritable } = require('./utils')\nconst {\n  AbortError,\n  codes: { ERR_INVALID_ARG_VALUE, ERR_MISSING_ARGS }\n} = require('../../ours/errors')\nmodule.exports = function compose(...streams) {\n  if (streams.length === 0) {\n    throw new ERR_MISSING_ARGS('streams')\n  }\n  if (streams.length === 1) {\n    return Duplex.from(streams[0])\n  }\n  const orgStreams = [...streams]\n  if (typeof streams[0] === 'function') {\n    streams[0] = Duplex.from(streams[0])\n  }\n  if (typeof streams[streams.length - 1] === 'function') {\n    const idx = streams.length - 1\n    streams[idx] = Duplex.from(streams[idx])\n  }\n  for (let n = 0; n < streams.length; ++n) {\n    if (!isNodeStream(streams[n])) {\n      // TODO(ronag): Add checks for non streams.\n      continue\n    }\n    if (n < streams.length - 1 && !isReadable(streams[n])) {\n      throw new ERR_INVALID_ARG_VALUE(`streams[${n}]`, orgStreams[n], 'must be readable')\n    }\n    if (n > 0 && !isWritable(streams[n])) {\n      throw new ERR_INVALID_ARG_VALUE(`streams[${n}]`, orgStreams[n], 'must be writable')\n    }\n  }\n  let ondrain\n  let onfinish\n  let onreadable\n  let onclose\n  let d\n  function onfinished(err) {\n    const cb = onclose\n    onclose = null\n    if (cb) {\n      cb(err)\n    } else if (err) {\n      d.destroy(err)\n    } else if (!readable && !writable) {\n      d.destroy()\n    }\n  }\n  const head = streams[0]\n  const tail = pipeline(streams, onfinished)\n  const writable = !!isWritable(head)\n  const readable = !!isReadable(tail)\n\n  // TODO(ronag): Avoid double buffering.\n  // Implement Writable/Readable/Duplex traits.\n  // See, https://github.com/nodejs/node/pull/33515.\n  d = new Duplex({\n    // TODO (ronag): highWaterMark?\n    writableObjectMode: !!(head !== null && head !== undefined && head.writableObjectMode),\n    readableObjectMode: !!(tail !== null && tail !== undefined && tail.writableObjectMode),\n    writable,\n    readable\n  })\n  if (writable) {\n    d._write = function (chunk, encoding, callback) {\n      if (head.write(chunk, encoding)) {\n        callback()\n      } else {\n        ondrain = callback\n      }\n    }\n    d._final = function (callback) {\n      head.end()\n      onfinish = callback\n    }\n    head.on('drain', function () {\n      if (ondrain) {\n        const cb = ondrain\n        ondrain = null\n        cb()\n      }\n    })\n    tail.on('finish', function () {\n      if (onfinish) {\n        const cb = onfinish\n        onfinish = null\n        cb()\n      }\n    })\n  }\n  if (readable) {\n    tail.on('readable', function () {\n      if (onreadable) {\n        const cb = onreadable\n        onreadable = null\n        cb()\n      }\n    })\n    tail.on('end', function () {\n      d.push(null)\n    })\n    d._read = function () {\n      while (true) {\n        const buf = tail.read()\n        if (buf === null) {\n          onreadable = d._read\n          return\n        }\n        if (!d.push(buf)) {\n          return\n        }\n      }\n    }\n  }\n  d._destroy = function (err, callback) {\n    if (!err && onclose !== null) {\n      err = new AbortError()\n    }\n    onreadable = null\n    ondrain = null\n    onfinish = null\n    if (onclose === null) {\n      callback(err)\n    } else {\n      onclose = callback\n      destroyer(tail, err)\n    }\n  }\n  return d\n}\n","'use strict'\n\n/* replacement start */\n\nconst process = require('process/')\n\n/* replacement end */\n\nconst {\n  aggregateTwoErrors,\n  codes: { ERR_MULTIPLE_CALLBACK },\n  AbortError\n} = require('../../ours/errors')\nconst { Symbol } = require('../../ours/primordials')\nconst { kDestroyed, isDestroyed, isFinished, isServerRequest } = require('./utils')\nconst kDestroy = Symbol('kDestroy')\nconst kConstruct = Symbol('kConstruct')\nfunction checkError(err, w, r) {\n  if (err) {\n    // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364\n    err.stack // eslint-disable-line no-unused-expressions\n\n    if (w && !w.errored) {\n      w.errored = err\n    }\n    if (r && !r.errored) {\n      r.errored = err\n    }\n  }\n}\n\n// Backwards compat. cb() is undocumented and unused in core but\n// unfortunately might be used by modules.\nfunction destroy(err, cb) {\n  const r = this._readableState\n  const w = this._writableState\n  // With duplex streams we use the writable side for state.\n  const s = w || r\n  if ((w && w.destroyed) || (r && r.destroyed)) {\n    if (typeof cb === 'function') {\n      cb()\n    }\n    return this\n  }\n\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  checkError(err, w, r)\n  if (w) {\n    w.destroyed = true\n  }\n  if (r) {\n    r.destroyed = true\n  }\n\n  // If still constructing then defer calling _destroy.\n  if (!s.constructed) {\n    this.once(kDestroy, function (er) {\n      _destroy(this, aggregateTwoErrors(er, err), cb)\n    })\n  } else {\n    _destroy(this, err, cb)\n  }\n  return this\n}\nfunction _destroy(self, err, cb) {\n  let called = false\n  function onDestroy(err) {\n    if (called) {\n      return\n    }\n    called = true\n    const r = self._readableState\n    const w = self._writableState\n    checkError(err, w, r)\n    if (w) {\n      w.closed = true\n    }\n    if (r) {\n      r.closed = true\n    }\n    if (typeof cb === 'function') {\n      cb(err)\n    }\n    if (err) {\n      process.nextTick(emitErrorCloseNT, self, err)\n    } else {\n      process.nextTick(emitCloseNT, self)\n    }\n  }\n  try {\n    self._destroy(err || null, onDestroy)\n  } catch (err) {\n    onDestroy(err)\n  }\n}\nfunction emitErrorCloseNT(self, err) {\n  emitErrorNT(self, err)\n  emitCloseNT(self)\n}\nfunction emitCloseNT(self) {\n  const r = self._readableState\n  const w = self._writableState\n  if (w) {\n    w.closeEmitted = true\n  }\n  if (r) {\n    r.closeEmitted = true\n  }\n  if ((w && w.emitClose) || (r && r.emitClose)) {\n    self.emit('close')\n  }\n}\nfunction emitErrorNT(self, err) {\n  const r = self._readableState\n  const w = self._writableState\n  if ((w && w.errorEmitted) || (r && r.errorEmitted)) {\n    return\n  }\n  if (w) {\n    w.errorEmitted = true\n  }\n  if (r) {\n    r.errorEmitted = true\n  }\n  self.emit('error', err)\n}\nfunction undestroy() {\n  const r = this._readableState\n  const w = this._writableState\n  if (r) {\n    r.constructed = true\n    r.closed = false\n    r.closeEmitted = false\n    r.destroyed = false\n    r.errored = null\n    r.errorEmitted = false\n    r.reading = false\n    r.ended = r.readable === false\n    r.endEmitted = r.readable === false\n  }\n  if (w) {\n    w.constructed = true\n    w.destroyed = false\n    w.closed = false\n    w.closeEmitted = false\n    w.errored = null\n    w.errorEmitted = false\n    w.finalCalled = false\n    w.prefinished = false\n    w.ended = w.writable === false\n    w.ending = w.writable === false\n    w.finished = w.writable === false\n  }\n}\nfunction errorOrDestroy(stream, err, sync) {\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\n  const r = stream._readableState\n  const w = stream._writableState\n  if ((w && w.destroyed) || (r && r.destroyed)) {\n    return this\n  }\n  if ((r && r.autoDestroy) || (w && w.autoDestroy)) stream.destroy(err)\n  else if (err) {\n    // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364\n    err.stack // eslint-disable-line no-unused-expressions\n\n    if (w && !w.errored) {\n      w.errored = err\n    }\n    if (r && !r.errored) {\n      r.errored = err\n    }\n    if (sync) {\n      process.nextTick(emitErrorNT, stream, err)\n    } else {\n      emitErrorNT(stream, err)\n    }\n  }\n}\nfunction construct(stream, cb) {\n  if (typeof stream._construct !== 'function') {\n    return\n  }\n  const r = stream._readableState\n  const w = stream._writableState\n  if (r) {\n    r.constructed = false\n  }\n  if (w) {\n    w.constructed = false\n  }\n  stream.once(kConstruct, cb)\n  if (stream.listenerCount(kConstruct) > 1) {\n    // Duplex\n    return\n  }\n  process.nextTick(constructNT, stream)\n}\nfunction constructNT(stream) {\n  let called = false\n  function onConstruct(err) {\n    if (called) {\n      errorOrDestroy(stream, err !== null && err !== undefined ? err : new ERR_MULTIPLE_CALLBACK())\n      return\n    }\n    called = true\n    const r = stream._readableState\n    const w = stream._writableState\n    const s = w || r\n    if (r) {\n      r.constructed = true\n    }\n    if (w) {\n      w.constructed = true\n    }\n    if (s.destroyed) {\n      stream.emit(kDestroy, err)\n    } else if (err) {\n      errorOrDestroy(stream, err, true)\n    } else {\n      process.nextTick(emitConstructNT, stream)\n    }\n  }\n  try {\n    stream._construct(onConstruct)\n  } catch (err) {\n    onConstruct(err)\n  }\n}\nfunction emitConstructNT(stream) {\n  stream.emit(kConstruct)\n}\nfunction isRequest(stream) {\n  return stream && stream.setHeader && typeof stream.abort === 'function'\n}\nfunction emitCloseLegacy(stream) {\n  stream.emit('close')\n}\nfunction emitErrorCloseLegacy(stream, err) {\n  stream.emit('error', err)\n  process.nextTick(emitCloseLegacy, stream)\n}\n\n// Normalize destroy for legacy.\nfunction destroyer(stream, err) {\n  if (!stream || isDestroyed(stream)) {\n    return\n  }\n  if (!err && !isFinished(stream)) {\n    err = new AbortError()\n  }\n\n  // TODO: Remove isRequest branches.\n  if (isServerRequest(stream)) {\n    stream.socket = null\n    stream.destroy(err)\n  } else if (isRequest(stream)) {\n    stream.abort()\n  } else if (isRequest(stream.req)) {\n    stream.req.abort()\n  } else if (typeof stream.destroy === 'function') {\n    stream.destroy(err)\n  } else if (typeof stream.close === 'function') {\n    // TODO: Don't lose err?\n    stream.close()\n  } else if (err) {\n    process.nextTick(emitErrorCloseLegacy, stream, err)\n  } else {\n    process.nextTick(emitCloseLegacy, stream)\n  }\n  if (!stream.destroyed) {\n    stream[kDestroyed] = true\n  }\n}\nmodule.exports = {\n  construct,\n  destroyer,\n  destroy,\n  undestroy,\n  errorOrDestroy\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// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototype inheritance, this class\n// prototypically inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict'\n\nconst {\n  ObjectDefineProperties,\n  ObjectGetOwnPropertyDescriptor,\n  ObjectKeys,\n  ObjectSetPrototypeOf\n} = require('../../ours/primordials')\nmodule.exports = Duplex\nconst Readable = require('./readable')\nconst Writable = require('./writable')\nObjectSetPrototypeOf(Duplex.prototype, Readable.prototype)\nObjectSetPrototypeOf(Duplex, Readable)\n{\n  const keys = ObjectKeys(Writable.prototype)\n  // Allow the keys array to be GC'ed.\n  for (let i = 0; i < keys.length; i++) {\n    const method = keys[i]\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]\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  if (options) {\n    this.allowHalfOpen = options.allowHalfOpen !== false\n    if (options.readable === false) {\n      this._readableState.readable = false\n      this._readableState.ended = true\n      this._readableState.endEmitted = true\n    }\n    if (options.writable === false) {\n      this._writableState.writable = false\n      this._writableState.ending = true\n      this._writableState.ended = true\n      this._writableState.finished = true\n    }\n  } else {\n    this.allowHalfOpen = true\n  }\n}\nObjectDefineProperties(Duplex.prototype, {\n  writable: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writable')\n  },\n  writableHighWaterMark: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableHighWaterMark')\n  },\n  writableObjectMode: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableObjectMode')\n  },\n  writableBuffer: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableBuffer')\n  },\n  writableLength: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableLength')\n  },\n  writableFinished: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableFinished')\n  },\n  writableCorked: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableCorked')\n  },\n  writableEnded: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableEnded')\n  },\n  writableNeedDrain: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableNeedDrain')\n  },\n  destroyed: {\n    __proto__: null,\n    get() {\n      if (this._readableState === undefined || this._writableState === undefined) {\n        return false\n      }\n      return this._readableState.destroyed && this._writableState.destroyed\n    },\n    set(value) {\n      // Backward compatibility, the user is explicitly\n      // managing destroyed.\n      if (this._readableState && this._writableState) {\n        this._readableState.destroyed = value\n        this._writableState.destroyed = value\n      }\n    }\n  }\n})\nlet webStreamsAdapters\n\n// Lazy to avoid circular references\nfunction lazyWebStreams() {\n  if (webStreamsAdapters === undefined) webStreamsAdapters = {}\n  return webStreamsAdapters\n}\nDuplex.fromWeb = function (pair, options) {\n  return lazyWebStreams().newStreamDuplexFromReadableWritablePair(pair, options)\n}\nDuplex.toWeb = function (duplex) {\n  return lazyWebStreams().newReadableWritablePairFromDuplex(duplex)\n}\nlet duplexify\nDuplex.from = function (body) {\n  if (!duplexify) {\n    duplexify = require('./duplexify')\n  }\n  return duplexify(body, 'body')\n}\n","/* replacement start */\n\nconst process = require('process/')\n\n/* replacement end */\n\n;('use strict')\nconst bufferModule = require('buffer')\nconst {\n  isReadable,\n  isWritable,\n  isIterable,\n  isNodeStream,\n  isReadableNodeStream,\n  isWritableNodeStream,\n  isDuplexNodeStream\n} = require('./utils')\nconst eos = require('./end-of-stream')\nconst {\n  AbortError,\n  codes: { ERR_INVALID_ARG_TYPE, ERR_INVALID_RETURN_VALUE }\n} = require('../../ours/errors')\nconst { destroyer } = require('./destroy')\nconst Duplex = require('./duplex')\nconst Readable = require('./readable')\nconst { createDeferredPromise } = require('../../ours/util')\nconst from = require('./from')\nconst Blob = globalThis.Blob || bufferModule.Blob\nconst isBlob =\n  typeof Blob !== 'undefined'\n    ? function isBlob(b) {\n        return b instanceof Blob\n      }\n    : function isBlob(b) {\n        return false\n      }\nconst AbortController = globalThis.AbortController || require('abort-controller').AbortController\nconst { FunctionPrototypeCall } = require('../../ours/primordials')\n\n// This is needed for pre node 17.\nclass Duplexify extends Duplex {\n  constructor(options) {\n    super(options)\n\n    // https://github.com/nodejs/node/pull/34385\n\n    if ((options === null || options === undefined ? undefined : options.readable) === false) {\n      this._readableState.readable = false\n      this._readableState.ended = true\n      this._readableState.endEmitted = true\n    }\n    if ((options === null || options === undefined ? undefined : options.writable) === false) {\n      this._writableState.writable = false\n      this._writableState.ending = true\n      this._writableState.ended = true\n      this._writableState.finished = true\n    }\n  }\n}\nmodule.exports = function duplexify(body, name) {\n  if (isDuplexNodeStream(body)) {\n    return body\n  }\n  if (isReadableNodeStream(body)) {\n    return _duplexify({\n      readable: body\n    })\n  }\n  if (isWritableNodeStream(body)) {\n    return _duplexify({\n      writable: body\n    })\n  }\n  if (isNodeStream(body)) {\n    return _duplexify({\n      writable: false,\n      readable: false\n    })\n  }\n\n  // TODO: Webstreams\n  // if (isReadableStream(body)) {\n  //   return _duplexify({ readable: Readable.fromWeb(body) });\n  // }\n\n  // TODO: Webstreams\n  // if (isWritableStream(body)) {\n  //   return _duplexify({ writable: Writable.fromWeb(body) });\n  // }\n\n  if (typeof body === 'function') {\n    const { value, write, final, destroy } = fromAsyncGen(body)\n    if (isIterable(value)) {\n      return from(Duplexify, value, {\n        // TODO (ronag): highWaterMark?\n        objectMode: true,\n        write,\n        final,\n        destroy\n      })\n    }\n    const then = value === null || value === undefined ? undefined : value.then\n    if (typeof then === 'function') {\n      let d\n      const promise = FunctionPrototypeCall(\n        then,\n        value,\n        (val) => {\n          if (val != null) {\n            throw new ERR_INVALID_RETURN_VALUE('nully', 'body', val)\n          }\n        },\n        (err) => {\n          destroyer(d, err)\n        }\n      )\n      return (d = new Duplexify({\n        // TODO (ronag): highWaterMark?\n        objectMode: true,\n        readable: false,\n        write,\n        final(cb) {\n          final(async () => {\n            try {\n              await promise\n              process.nextTick(cb, null)\n            } catch (err) {\n              process.nextTick(cb, err)\n            }\n          })\n        },\n        destroy\n      }))\n    }\n    throw new ERR_INVALID_RETURN_VALUE('Iterable, AsyncIterable or AsyncFunction', name, value)\n  }\n  if (isBlob(body)) {\n    return duplexify(body.arrayBuffer())\n  }\n  if (isIterable(body)) {\n    return from(Duplexify, body, {\n      // TODO (ronag): highWaterMark?\n      objectMode: true,\n      writable: false\n    })\n  }\n\n  // TODO: Webstreams.\n  // if (\n  //   isReadableStream(body?.readable) &&\n  //   isWritableStream(body?.writable)\n  // ) {\n  //   return Duplexify.fromWeb(body);\n  // }\n\n  if (\n    typeof (body === null || body === undefined ? undefined : body.writable) === 'object' ||\n    typeof (body === null || body === undefined ? undefined : body.readable) === 'object'\n  ) {\n    const readable =\n      body !== null && body !== undefined && body.readable\n        ? isReadableNodeStream(body === null || body === undefined ? undefined : body.readable)\n          ? body === null || body === undefined\n            ? undefined\n            : body.readable\n          : duplexify(body.readable)\n        : undefined\n    const writable =\n      body !== null && body !== undefined && body.writable\n        ? isWritableNodeStream(body === null || body === undefined ? undefined : body.writable)\n          ? body === null || body === undefined\n            ? undefined\n            : body.writable\n          : duplexify(body.writable)\n        : undefined\n    return _duplexify({\n      readable,\n      writable\n    })\n  }\n  const then = body === null || body === undefined ? undefined : body.then\n  if (typeof then === 'function') {\n    let d\n    FunctionPrototypeCall(\n      then,\n      body,\n      (val) => {\n        if (val != null) {\n          d.push(val)\n        }\n        d.push(null)\n      },\n      (err) => {\n        destroyer(d, err)\n      }\n    )\n    return (d = new Duplexify({\n      objectMode: true,\n      writable: false,\n      read() {}\n    }))\n  }\n  throw new ERR_INVALID_ARG_TYPE(\n    name,\n    [\n      'Blob',\n      'ReadableStream',\n      'WritableStream',\n      'Stream',\n      'Iterable',\n      'AsyncIterable',\n      'Function',\n      '{ readable, writable } pair',\n      'Promise'\n    ],\n    body\n  )\n}\nfunction fromAsyncGen(fn) {\n  let { promise, resolve } = createDeferredPromise()\n  const ac = new AbortController()\n  const signal = ac.signal\n  const value = fn(\n    (async function* () {\n      while (true) {\n        const _promise = promise\n        promise = null\n        const { chunk, done, cb } = await _promise\n        process.nextTick(cb)\n        if (done) return\n        if (signal.aborted)\n          throw new AbortError(undefined, {\n            cause: signal.reason\n          })\n        ;({ promise, resolve } = createDeferredPromise())\n        yield chunk\n      }\n    })(),\n    {\n      signal\n    }\n  )\n  return {\n    value,\n    write(chunk, encoding, cb) {\n      const _resolve = resolve\n      resolve = null\n      _resolve({\n        chunk,\n        done: false,\n        cb\n      })\n    },\n    final(cb) {\n      const _resolve = resolve\n      resolve = null\n      _resolve({\n        done: true,\n        cb\n      })\n    },\n    destroy(err, cb) {\n      ac.abort()\n      cb(err)\n    }\n  }\n}\nfunction _duplexify(pair) {\n  const r = pair.readable && typeof pair.readable.read !== 'function' ? Readable.wrap(pair.readable) : pair.readable\n  const w = pair.writable\n  let readable = !!isReadable(r)\n  let writable = !!isWritable(w)\n  let ondrain\n  let onfinish\n  let onreadable\n  let onclose\n  let d\n  function onfinished(err) {\n    const cb = onclose\n    onclose = null\n    if (cb) {\n      cb(err)\n    } else if (err) {\n      d.destroy(err)\n    } else if (!readable && !writable) {\n      d.destroy()\n    }\n  }\n\n  // TODO(ronag): Avoid double buffering.\n  // Implement Writable/Readable/Duplex traits.\n  // See, https://github.com/nodejs/node/pull/33515.\n  d = new Duplexify({\n    // TODO (ronag): highWaterMark?\n    readableObjectMode: !!(r !== null && r !== undefined && r.readableObjectMode),\n    writableObjectMode: !!(w !== null && w !== undefined && w.writableObjectMode),\n    readable,\n    writable\n  })\n  if (writable) {\n    eos(w, (err) => {\n      writable = false\n      if (err) {\n        destroyer(r, err)\n      }\n      onfinished(err)\n    })\n    d._write = function (chunk, encoding, callback) {\n      if (w.write(chunk, encoding)) {\n        callback()\n      } else {\n        ondrain = callback\n      }\n    }\n    d._final = function (callback) {\n      w.end()\n      onfinish = callback\n    }\n    w.on('drain', function () {\n      if (ondrain) {\n        const cb = ondrain\n        ondrain = null\n        cb()\n      }\n    })\n    w.on('finish', function () {\n      if (onfinish) {\n        const cb = onfinish\n        onfinish = null\n        cb()\n      }\n    })\n  }\n  if (readable) {\n    eos(r, (err) => {\n      readable = false\n      if (err) {\n        destroyer(r, err)\n      }\n      onfinished(err)\n    })\n    r.on('readable', function () {\n      if (onreadable) {\n        const cb = onreadable\n        onreadable = null\n        cb()\n      }\n    })\n    r.on('end', function () {\n      d.push(null)\n    })\n    d._read = function () {\n      while (true) {\n        const buf = r.read()\n        if (buf === null) {\n          onreadable = d._read\n          return\n        }\n        if (!d.push(buf)) {\n          return\n        }\n      }\n    }\n  }\n  d._destroy = function (err, callback) {\n    if (!err && onclose !== null) {\n      err = new AbortError()\n    }\n    onreadable = null\n    ondrain = null\n    onfinish = null\n    if (onclose === null) {\n      callback(err)\n    } else {\n      onclose = callback\n      destroyer(w, err)\n      destroyer(r, err)\n    }\n  }\n  return d\n}\n","/* replacement start */\n\nconst process = require('process/')\n\n/* replacement end */\n// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n\n;('use strict')\nconst { AbortError, codes } = require('../../ours/errors')\nconst { ERR_INVALID_ARG_TYPE, ERR_STREAM_PREMATURE_CLOSE } = codes\nconst { kEmptyObject, once } = require('../../ours/util')\nconst { validateAbortSignal, validateFunction, validateObject } = require('../validators')\nconst { Promise } = require('../../ours/primordials')\nconst {\n  isClosed,\n  isReadable,\n  isReadableNodeStream,\n  isReadableFinished,\n  isReadableErrored,\n  isWritable,\n  isWritableNodeStream,\n  isWritableFinished,\n  isWritableErrored,\n  isNodeStream,\n  willEmitClose: _willEmitClose\n} = require('./utils')\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function'\n}\nconst nop = () => {}\nfunction eos(stream, options, callback) {\n  var _options$readable, _options$writable\n  if (arguments.length === 2) {\n    callback = options\n    options = kEmptyObject\n  } else if (options == null) {\n    options = kEmptyObject\n  } else {\n    validateObject(options, 'options')\n  }\n  validateFunction(callback, 'callback')\n  validateAbortSignal(options.signal, 'options.signal')\n  callback = once(callback)\n  const readable =\n    (_options$readable = options.readable) !== null && _options$readable !== undefined\n      ? _options$readable\n      : isReadableNodeStream(stream)\n  const writable =\n    (_options$writable = options.writable) !== null && _options$writable !== undefined\n      ? _options$writable\n      : isWritableNodeStream(stream)\n  if (!isNodeStream(stream)) {\n    // TODO: Webstreams.\n    throw new ERR_INVALID_ARG_TYPE('stream', 'Stream', stream)\n  }\n  const wState = stream._writableState\n  const rState = stream._readableState\n  const onlegacyfinish = () => {\n    if (!stream.writable) {\n      onfinish()\n    }\n  }\n\n  // TODO (ronag): Improve soft detection to include core modules and\n  // common ecosystem modules that do properly emit 'close' but fail\n  // this generic check.\n  let willEmitClose =\n    _willEmitClose(stream) && isReadableNodeStream(stream) === readable && isWritableNodeStream(stream) === writable\n  let writableFinished = isWritableFinished(stream, false)\n  const onfinish = () => {\n    writableFinished = true\n    // Stream should not be destroyed here. If it is that\n    // means that user space is doing something differently and\n    // we cannot trust willEmitClose.\n    if (stream.destroyed) {\n      willEmitClose = false\n    }\n    if (willEmitClose && (!stream.readable || readable)) {\n      return\n    }\n    if (!readable || readableFinished) {\n      callback.call(stream)\n    }\n  }\n  let readableFinished = isReadableFinished(stream, false)\n  const onend = () => {\n    readableFinished = true\n    // Stream should not be destroyed here. If it is that\n    // means that user space is doing something differently and\n    // we cannot trust willEmitClose.\n    if (stream.destroyed) {\n      willEmitClose = false\n    }\n    if (willEmitClose && (!stream.writable || writable)) {\n      return\n    }\n    if (!writable || writableFinished) {\n      callback.call(stream)\n    }\n  }\n  const onerror = (err) => {\n    callback.call(stream, err)\n  }\n  let closed = isClosed(stream)\n  const onclose = () => {\n    closed = true\n    const errored = isWritableErrored(stream) || isReadableErrored(stream)\n    if (errored && typeof errored !== 'boolean') {\n      return callback.call(stream, errored)\n    }\n    if (readable && !readableFinished && isReadableNodeStream(stream, true)) {\n      if (!isReadableFinished(stream, false)) return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE())\n    }\n    if (writable && !writableFinished) {\n      if (!isWritableFinished(stream, false)) return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE())\n    }\n    callback.call(stream)\n  }\n  const onrequest = () => {\n    stream.req.on('finish', onfinish)\n  }\n  if (isRequest(stream)) {\n    stream.on('complete', onfinish)\n    if (!willEmitClose) {\n      stream.on('abort', onclose)\n    }\n    if (stream.req) {\n      onrequest()\n    } else {\n      stream.on('request', onrequest)\n    }\n  } else if (writable && !wState) {\n    // legacy streams\n    stream.on('end', onlegacyfinish)\n    stream.on('close', onlegacyfinish)\n  }\n\n  // Not all streams will emit 'close' after 'aborted'.\n  if (!willEmitClose && typeof stream.aborted === 'boolean') {\n    stream.on('aborted', onclose)\n  }\n  stream.on('end', onend)\n  stream.on('finish', onfinish)\n  if (options.error !== false) {\n    stream.on('error', onerror)\n  }\n  stream.on('close', onclose)\n  if (closed) {\n    process.nextTick(onclose)\n  } else if (\n    (wState !== null && wState !== undefined && wState.errorEmitted) ||\n    (rState !== null && rState !== undefined && rState.errorEmitted)\n  ) {\n    if (!willEmitClose) {\n      process.nextTick(onclose)\n    }\n  } else if (\n    !readable &&\n    (!willEmitClose || isReadable(stream)) &&\n    (writableFinished || isWritable(stream) === false)\n  ) {\n    process.nextTick(onclose)\n  } else if (\n    !writable &&\n    (!willEmitClose || isWritable(stream)) &&\n    (readableFinished || isReadable(stream) === false)\n  ) {\n    process.nextTick(onclose)\n  } else if (rState && stream.req && stream.aborted) {\n    process.nextTick(onclose)\n  }\n  const cleanup = () => {\n    callback = nop\n    stream.removeListener('aborted', onclose)\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  if (options.signal && !closed) {\n    const abort = () => {\n      // Keep it because cleanup removes it.\n      const endCallback = callback\n      cleanup()\n      endCallback.call(\n        stream,\n        new AbortError(undefined, {\n          cause: options.signal.reason\n        })\n      )\n    }\n    if (options.signal.aborted) {\n      process.nextTick(abort)\n    } else {\n      const originalCallback = callback\n      callback = once((...args) => {\n        options.signal.removeEventListener('abort', abort)\n        originalCallback.apply(stream, args)\n      })\n      options.signal.addEventListener('abort', abort)\n    }\n  }\n  return cleanup\n}\nfunction finished(stream, opts) {\n  return new Promise((resolve, reject) => {\n    eos(stream, opts, (err) => {\n      if (err) {\n        reject(err)\n      } else {\n        resolve()\n      }\n    })\n  })\n}\nmodule.exports = eos\nmodule.exports.finished = finished\n","'use strict'\n\n/* replacement start */\n\nconst process = require('process/')\n\n/* replacement end */\n\nconst { PromisePrototypeThen, SymbolAsyncIterator, SymbolIterator } = require('../../ours/primordials')\nconst { Buffer } = require('buffer')\nconst { ERR_INVALID_ARG_TYPE, ERR_STREAM_NULL_VALUES } = require('../../ours/errors').codes\nfunction from(Readable, iterable, opts) {\n  let iterator\n  if (typeof iterable === 'string' || iterable instanceof Buffer) {\n    return new Readable({\n      objectMode: true,\n      ...opts,\n      read() {\n        this.push(iterable)\n        this.push(null)\n      }\n    })\n  }\n  let isAsync\n  if (iterable && iterable[SymbolAsyncIterator]) {\n    isAsync = true\n    iterator = iterable[SymbolAsyncIterator]()\n  } else if (iterable && iterable[SymbolIterator]) {\n    isAsync = false\n    iterator = iterable[SymbolIterator]()\n  } else {\n    throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable)\n  }\n  const readable = new Readable({\n    objectMode: true,\n    highWaterMark: 1,\n    // TODO(ronag): What options should be allowed?\n    ...opts\n  })\n\n  // Flag to protect against _read\n  // being called before last iteration completion.\n  let reading = false\n  readable._read = function () {\n    if (!reading) {\n      reading = true\n      next()\n    }\n  }\n  readable._destroy = function (error, cb) {\n    PromisePrototypeThen(\n      close(error),\n      () => process.nextTick(cb, error),\n      // nextTick is here in case cb throws\n      (e) => process.nextTick(cb, e || error)\n    )\n  }\n  async function close(error) {\n    const hadError = error !== undefined && error !== null\n    const hasThrow = typeof iterator.throw === 'function'\n    if (hadError && hasThrow) {\n      const { value, done } = await iterator.throw(error)\n      await value\n      if (done) {\n        return\n      }\n    }\n    if (typeof iterator.return === 'function') {\n      const { value } = await iterator.return()\n      await value\n    }\n  }\n  async function next() {\n    for (;;) {\n      try {\n        const { value, done } = isAsync ? await iterator.next() : iterator.next()\n        if (done) {\n          readable.push(null)\n        } else {\n          const res = value && typeof value.then === 'function' ? await value : value\n          if (res === null) {\n            reading = false\n            throw new ERR_STREAM_NULL_VALUES()\n          } else if (readable.push(res)) {\n            continue\n          } else {\n            reading = false\n          }\n        }\n      } catch (err) {\n        readable.destroy(err)\n      }\n      break\n    }\n  }\n  return readable\n}\nmodule.exports = from\n","'use strict'\n\nconst { ArrayIsArray, ObjectSetPrototypeOf } = require('../../ours/primordials')\nconst { EventEmitter: EE } = require('events')\nfunction Stream(opts) {\n  EE.call(this, opts)\n}\nObjectSetPrototypeOf(Stream.prototype, EE.prototype)\nObjectSetPrototypeOf(Stream, EE)\nStream.prototype.pipe = function (dest, options) {\n  const source = this\n  function ondata(chunk) {\n    if (dest.writable && dest.write(chunk) === false && source.pause) {\n      source.pause()\n    }\n  }\n  source.on('data', ondata)\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume()\n    }\n  }\n  dest.on('drain', ondrain)\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend)\n    source.on('close', onclose)\n  }\n  let didOnEnd = false\n  function onend() {\n    if (didOnEnd) return\n    didOnEnd = true\n    dest.end()\n  }\n  function onclose() {\n    if (didOnEnd) return\n    didOnEnd = true\n    if (typeof dest.destroy === 'function') dest.destroy()\n  }\n\n  // Don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup()\n    if (EE.listenerCount(this, 'error') === 0) {\n      this.emit('error', er)\n    }\n  }\n  prependListener(source, 'error', onerror)\n  prependListener(dest, 'error', onerror)\n\n  // Remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata)\n    dest.removeListener('drain', ondrain)\n    source.removeListener('end', onend)\n    source.removeListener('close', onclose)\n    source.removeListener('error', onerror)\n    dest.removeListener('error', onerror)\n    source.removeListener('end', cleanup)\n    source.removeListener('close', cleanup)\n    dest.removeListener('close', cleanup)\n  }\n  source.on('end', cleanup)\n  source.on('close', cleanup)\n  dest.on('close', cleanup)\n  dest.emit('pipe', source)\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest\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)\n\n  // 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  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn)\n  else if (ArrayIsArray(emitter._events[event])) emitter._events[event].unshift(fn)\n  else emitter._events[event] = [fn, emitter._events[event]]\n}\nmodule.exports = {\n  Stream,\n  prependListener\n}\n","'use strict'\n\nconst AbortController = globalThis.AbortController || require('abort-controller').AbortController\nconst {\n  codes: { ERR_INVALID_ARG_TYPE, ERR_MISSING_ARGS, ERR_OUT_OF_RANGE },\n  AbortError\n} = require('../../ours/errors')\nconst { validateAbortSignal, validateInteger, validateObject } = require('../validators')\nconst kWeakHandler = require('../../ours/primordials').Symbol('kWeak')\nconst { finished } = require('./end-of-stream')\nconst {\n  ArrayPrototypePush,\n  MathFloor,\n  Number,\n  NumberIsNaN,\n  Promise,\n  PromiseReject,\n  PromisePrototypeThen,\n  Symbol\n} = require('../../ours/primordials')\nconst kEmpty = Symbol('kEmpty')\nconst kEof = Symbol('kEof')\nfunction map(fn, options) {\n  if (typeof fn !== 'function') {\n    throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn)\n  }\n  if (options != null) {\n    validateObject(options, 'options')\n  }\n  if ((options === null || options === undefined ? undefined : options.signal) != null) {\n    validateAbortSignal(options.signal, 'options.signal')\n  }\n  let concurrency = 1\n  if ((options === null || options === undefined ? undefined : options.concurrency) != null) {\n    concurrency = MathFloor(options.concurrency)\n  }\n  validateInteger(concurrency, 'concurrency', 1)\n  return async function* map() {\n    var _options$signal, _options$signal2\n    const ac = new AbortController()\n    const stream = this\n    const queue = []\n    const signal = ac.signal\n    const signalOpt = {\n      signal\n    }\n    const abort = () => ac.abort()\n    if (\n      options !== null &&\n      options !== undefined &&\n      (_options$signal = options.signal) !== null &&\n      _options$signal !== undefined &&\n      _options$signal.aborted\n    ) {\n      abort()\n    }\n    options === null || options === undefined\n      ? undefined\n      : (_options$signal2 = options.signal) === null || _options$signal2 === undefined\n      ? undefined\n      : _options$signal2.addEventListener('abort', abort)\n    let next\n    let resume\n    let done = false\n    function onDone() {\n      done = true\n    }\n    async function pump() {\n      try {\n        for await (let val of stream) {\n          var _val\n          if (done) {\n            return\n          }\n          if (signal.aborted) {\n            throw new AbortError()\n          }\n          try {\n            val = fn(val, signalOpt)\n          } catch (err) {\n            val = PromiseReject(err)\n          }\n          if (val === kEmpty) {\n            continue\n          }\n          if (typeof ((_val = val) === null || _val === undefined ? undefined : _val.catch) === 'function') {\n            val.catch(onDone)\n          }\n          queue.push(val)\n          if (next) {\n            next()\n            next = null\n          }\n          if (!done && queue.length && queue.length >= concurrency) {\n            await new Promise((resolve) => {\n              resume = resolve\n            })\n          }\n        }\n        queue.push(kEof)\n      } catch (err) {\n        const val = PromiseReject(err)\n        PromisePrototypeThen(val, undefined, onDone)\n        queue.push(val)\n      } finally {\n        var _options$signal3\n        done = true\n        if (next) {\n          next()\n          next = null\n        }\n        options === null || options === undefined\n          ? undefined\n          : (_options$signal3 = options.signal) === null || _options$signal3 === undefined\n          ? undefined\n          : _options$signal3.removeEventListener('abort', abort)\n      }\n    }\n    pump()\n    try {\n      while (true) {\n        while (queue.length > 0) {\n          const val = await queue[0]\n          if (val === kEof) {\n            return\n          }\n          if (signal.aborted) {\n            throw new AbortError()\n          }\n          if (val !== kEmpty) {\n            yield val\n          }\n          queue.shift()\n          if (resume) {\n            resume()\n            resume = null\n          }\n        }\n        await new Promise((resolve) => {\n          next = resolve\n        })\n      }\n    } finally {\n      ac.abort()\n      done = true\n      if (resume) {\n        resume()\n        resume = null\n      }\n    }\n  }.call(this)\n}\nfunction asIndexedPairs(options = undefined) {\n  if (options != null) {\n    validateObject(options, 'options')\n  }\n  if ((options === null || options === undefined ? undefined : options.signal) != null) {\n    validateAbortSignal(options.signal, 'options.signal')\n  }\n  return async function* asIndexedPairs() {\n    let index = 0\n    for await (const val of this) {\n      var _options$signal4\n      if (\n        options !== null &&\n        options !== undefined &&\n        (_options$signal4 = options.signal) !== null &&\n        _options$signal4 !== undefined &&\n        _options$signal4.aborted\n      ) {\n        throw new AbortError({\n          cause: options.signal.reason\n        })\n      }\n      yield [index++, val]\n    }\n  }.call(this)\n}\nasync function some(fn, options = undefined) {\n  for await (const unused of filter.call(this, fn, options)) {\n    return true\n  }\n  return false\n}\nasync function every(fn, options = undefined) {\n  if (typeof fn !== 'function') {\n    throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn)\n  }\n  // https://en.wikipedia.org/wiki/De_Morgan%27s_laws\n  return !(await some.call(\n    this,\n    async (...args) => {\n      return !(await fn(...args))\n    },\n    options\n  ))\n}\nasync function find(fn, options) {\n  for await (const result of filter.call(this, fn, options)) {\n    return result\n  }\n  return undefined\n}\nasync function forEach(fn, options) {\n  if (typeof fn !== 'function') {\n    throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn)\n  }\n  async function forEachFn(value, options) {\n    await fn(value, options)\n    return kEmpty\n  }\n  // eslint-disable-next-line no-unused-vars\n  for await (const unused of map.call(this, forEachFn, options));\n}\nfunction filter(fn, options) {\n  if (typeof fn !== 'function') {\n    throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn)\n  }\n  async function filterFn(value, options) {\n    if (await fn(value, options)) {\n      return value\n    }\n    return kEmpty\n  }\n  return map.call(this, filterFn, options)\n}\n\n// Specific to provide better error to reduce since the argument is only\n// missing if the stream has no items in it - but the code is still appropriate\nclass ReduceAwareErrMissingArgs extends ERR_MISSING_ARGS {\n  constructor() {\n    super('reduce')\n    this.message = 'Reduce of an empty stream requires an initial value'\n  }\n}\nasync function reduce(reducer, initialValue, options) {\n  var _options$signal5\n  if (typeof reducer !== 'function') {\n    throw new ERR_INVALID_ARG_TYPE('reducer', ['Function', 'AsyncFunction'], reducer)\n  }\n  if (options != null) {\n    validateObject(options, 'options')\n  }\n  if ((options === null || options === undefined ? undefined : options.signal) != null) {\n    validateAbortSignal(options.signal, 'options.signal')\n  }\n  let hasInitialValue = arguments.length > 1\n  if (\n    options !== null &&\n    options !== undefined &&\n    (_options$signal5 = options.signal) !== null &&\n    _options$signal5 !== undefined &&\n    _options$signal5.aborted\n  ) {\n    const err = new AbortError(undefined, {\n      cause: options.signal.reason\n    })\n    this.once('error', () => {}) // The error is already propagated\n    await finished(this.destroy(err))\n    throw err\n  }\n  const ac = new AbortController()\n  const signal = ac.signal\n  if (options !== null && options !== undefined && options.signal) {\n    const opts = {\n      once: true,\n      [kWeakHandler]: this\n    }\n    options.signal.addEventListener('abort', () => ac.abort(), opts)\n  }\n  let gotAnyItemFromStream = false\n  try {\n    for await (const value of this) {\n      var _options$signal6\n      gotAnyItemFromStream = true\n      if (\n        options !== null &&\n        options !== undefined &&\n        (_options$signal6 = options.signal) !== null &&\n        _options$signal6 !== undefined &&\n        _options$signal6.aborted\n      ) {\n        throw new AbortError()\n      }\n      if (!hasInitialValue) {\n        initialValue = value\n        hasInitialValue = true\n      } else {\n        initialValue = await reducer(initialValue, value, {\n          signal\n        })\n      }\n    }\n    if (!gotAnyItemFromStream && !hasInitialValue) {\n      throw new ReduceAwareErrMissingArgs()\n    }\n  } finally {\n    ac.abort()\n  }\n  return initialValue\n}\nasync function toArray(options) {\n  if (options != null) {\n    validateObject(options, 'options')\n  }\n  if ((options === null || options === undefined ? undefined : options.signal) != null) {\n    validateAbortSignal(options.signal, 'options.signal')\n  }\n  const result = []\n  for await (const val of this) {\n    var _options$signal7\n    if (\n      options !== null &&\n      options !== undefined &&\n      (_options$signal7 = options.signal) !== null &&\n      _options$signal7 !== undefined &&\n      _options$signal7.aborted\n    ) {\n      throw new AbortError(undefined, {\n        cause: options.signal.reason\n      })\n    }\n    ArrayPrototypePush(result, val)\n  }\n  return result\n}\nfunction flatMap(fn, options) {\n  const values = map.call(this, fn, options)\n  return async function* flatMap() {\n    for await (const val of values) {\n      yield* val\n    }\n  }.call(this)\n}\nfunction toIntegerOrInfinity(number) {\n  // We coerce here to align with the spec\n  // https://github.com/tc39/proposal-iterator-helpers/issues/169\n  number = Number(number)\n  if (NumberIsNaN(number)) {\n    return 0\n  }\n  if (number < 0) {\n    throw new ERR_OUT_OF_RANGE('number', '>= 0', number)\n  }\n  return number\n}\nfunction drop(number, options = undefined) {\n  if (options != null) {\n    validateObject(options, 'options')\n  }\n  if ((options === null || options === undefined ? undefined : options.signal) != null) {\n    validateAbortSignal(options.signal, 'options.signal')\n  }\n  number = toIntegerOrInfinity(number)\n  return async function* drop() {\n    var _options$signal8\n    if (\n      options !== null &&\n      options !== undefined &&\n      (_options$signal8 = options.signal) !== null &&\n      _options$signal8 !== undefined &&\n      _options$signal8.aborted\n    ) {\n      throw new AbortError()\n    }\n    for await (const val of this) {\n      var _options$signal9\n      if (\n        options !== null &&\n        options !== undefined &&\n        (_options$signal9 = options.signal) !== null &&\n        _options$signal9 !== undefined &&\n        _options$signal9.aborted\n      ) {\n        throw new AbortError()\n      }\n      if (number-- <= 0) {\n        yield val\n      }\n    }\n  }.call(this)\n}\nfunction take(number, options = undefined) {\n  if (options != null) {\n    validateObject(options, 'options')\n  }\n  if ((options === null || options === undefined ? undefined : options.signal) != null) {\n    validateAbortSignal(options.signal, 'options.signal')\n  }\n  number = toIntegerOrInfinity(number)\n  return async function* take() {\n    var _options$signal10\n    if (\n      options !== null &&\n      options !== undefined &&\n      (_options$signal10 = options.signal) !== null &&\n      _options$signal10 !== undefined &&\n      _options$signal10.aborted\n    ) {\n      throw new AbortError()\n    }\n    for await (const val of this) {\n      var _options$signal11\n      if (\n        options !== null &&\n        options !== undefined &&\n        (_options$signal11 = options.signal) !== null &&\n        _options$signal11 !== undefined &&\n        _options$signal11.aborted\n      ) {\n        throw new AbortError()\n      }\n      if (number-- > 0) {\n        yield val\n      } else {\n        return\n      }\n    }\n  }.call(this)\n}\nmodule.exports.streamReturningOperators = {\n  asIndexedPairs,\n  drop,\n  filter,\n  flatMap,\n  map,\n  take\n}\nmodule.exports.promiseReturningOperators = {\n  every,\n  forEach,\n  reduce,\n  toArray,\n  some,\n  find\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// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict'\n\nconst { ObjectSetPrototypeOf } = require('../../ours/primordials')\nmodule.exports = PassThrough\nconst Transform = require('./transform')\nObjectSetPrototypeOf(PassThrough.prototype, Transform.prototype)\nObjectSetPrototypeOf(PassThrough, Transform)\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options)\n  Transform.call(this, options)\n}\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk)\n}\n","/* replacement start */\n\nconst process = require('process/')\n\n/* replacement end */\n// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n\n;('use strict')\nconst { ArrayIsArray, Promise, SymbolAsyncIterator } = require('../../ours/primordials')\nconst eos = require('./end-of-stream')\nconst { once } = require('../../ours/util')\nconst destroyImpl = require('./destroy')\nconst Duplex = require('./duplex')\nconst {\n  aggregateTwoErrors,\n  codes: {\n    ERR_INVALID_ARG_TYPE,\n    ERR_INVALID_RETURN_VALUE,\n    ERR_MISSING_ARGS,\n    ERR_STREAM_DESTROYED,\n    ERR_STREAM_PREMATURE_CLOSE\n  },\n  AbortError\n} = require('../../ours/errors')\nconst { validateFunction, validateAbortSignal } = require('../validators')\nconst { isIterable, isReadable, isReadableNodeStream, isNodeStream } = require('./utils')\nconst AbortController = globalThis.AbortController || require('abort-controller').AbortController\nlet PassThrough\nlet Readable\nfunction destroyer(stream, reading, writing) {\n  let finished = false\n  stream.on('close', () => {\n    finished = true\n  })\n  const cleanup = eos(\n    stream,\n    {\n      readable: reading,\n      writable: writing\n    },\n    (err) => {\n      finished = !err\n    }\n  )\n  return {\n    destroy: (err) => {\n      if (finished) return\n      finished = true\n      destroyImpl.destroyer(stream, err || new ERR_STREAM_DESTROYED('pipe'))\n    },\n    cleanup\n  }\n}\nfunction popCallback(streams) {\n  // Streams should never be an empty array. It should always contain at least\n  // a single stream. Therefore optimize for the average case instead of\n  // checking for length === 0 as well.\n  validateFunction(streams[streams.length - 1], 'streams[stream.length - 1]')\n  return streams.pop()\n}\nfunction makeAsyncIterable(val) {\n  if (isIterable(val)) {\n    return val\n  } else if (isReadableNodeStream(val)) {\n    // Legacy streams are not Iterable.\n    return fromReadable(val)\n  }\n  throw new ERR_INVALID_ARG_TYPE('val', ['Readable', 'Iterable', 'AsyncIterable'], val)\n}\nasync function* fromReadable(val) {\n  if (!Readable) {\n    Readable = require('./readable')\n  }\n  yield* Readable.prototype[SymbolAsyncIterator].call(val)\n}\nasync function pump(iterable, writable, finish, { end }) {\n  let error\n  let onresolve = null\n  const resume = (err) => {\n    if (err) {\n      error = err\n    }\n    if (onresolve) {\n      const callback = onresolve\n      onresolve = null\n      callback()\n    }\n  }\n  const wait = () =>\n    new Promise((resolve, reject) => {\n      if (error) {\n        reject(error)\n      } else {\n        onresolve = () => {\n          if (error) {\n            reject(error)\n          } else {\n            resolve()\n          }\n        }\n      }\n    })\n  writable.on('drain', resume)\n  const cleanup = eos(\n    writable,\n    {\n      readable: false\n    },\n    resume\n  )\n  try {\n    if (writable.writableNeedDrain) {\n      await wait()\n    }\n    for await (const chunk of iterable) {\n      if (!writable.write(chunk)) {\n        await wait()\n      }\n    }\n    if (end) {\n      writable.end()\n    }\n    await wait()\n    finish()\n  } catch (err) {\n    finish(error !== err ? aggregateTwoErrors(error, err) : err)\n  } finally {\n    cleanup()\n    writable.off('drain', resume)\n  }\n}\nfunction pipeline(...streams) {\n  return pipelineImpl(streams, once(popCallback(streams)))\n}\nfunction pipelineImpl(streams, callback, opts) {\n  if (streams.length === 1 && ArrayIsArray(streams[0])) {\n    streams = streams[0]\n  }\n  if (streams.length < 2) {\n    throw new ERR_MISSING_ARGS('streams')\n  }\n  const ac = new AbortController()\n  const signal = ac.signal\n  const outerSignal = opts === null || opts === undefined ? undefined : opts.signal\n\n  // Need to cleanup event listeners if last stream is readable\n  // https://github.com/nodejs/node/issues/35452\n  const lastStreamCleanup = []\n  validateAbortSignal(outerSignal, 'options.signal')\n  function abort() {\n    finishImpl(new AbortError())\n  }\n  outerSignal === null || outerSignal === undefined ? undefined : outerSignal.addEventListener('abort', abort)\n  let error\n  let value\n  const destroys = []\n  let finishCount = 0\n  function finish(err) {\n    finishImpl(err, --finishCount === 0)\n  }\n  function finishImpl(err, final) {\n    if (err && (!error || error.code === 'ERR_STREAM_PREMATURE_CLOSE')) {\n      error = err\n    }\n    if (!error && !final) {\n      return\n    }\n    while (destroys.length) {\n      destroys.shift()(error)\n    }\n    outerSignal === null || outerSignal === undefined ? undefined : outerSignal.removeEventListener('abort', abort)\n    ac.abort()\n    if (final) {\n      if (!error) {\n        lastStreamCleanup.forEach((fn) => fn())\n      }\n      process.nextTick(callback, error, value)\n    }\n  }\n  let ret\n  for (let i = 0; i < streams.length; i++) {\n    const stream = streams[i]\n    const reading = i < streams.length - 1\n    const writing = i > 0\n    const end = reading || (opts === null || opts === undefined ? undefined : opts.end) !== false\n    const isLastStream = i === streams.length - 1\n    if (isNodeStream(stream)) {\n      if (end) {\n        const { destroy, cleanup } = destroyer(stream, reading, writing)\n        destroys.push(destroy)\n        if (isReadable(stream) && isLastStream) {\n          lastStreamCleanup.push(cleanup)\n        }\n      }\n\n      // Catch stream errors that occur after pipe/pump has completed.\n      function onError(err) {\n        if (err && err.name !== 'AbortError' && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {\n          finish(err)\n        }\n      }\n      stream.on('error', onError)\n      if (isReadable(stream) && isLastStream) {\n        lastStreamCleanup.push(() => {\n          stream.removeListener('error', onError)\n        })\n      }\n    }\n    if (i === 0) {\n      if (typeof stream === 'function') {\n        ret = stream({\n          signal\n        })\n        if (!isIterable(ret)) {\n          throw new ERR_INVALID_RETURN_VALUE('Iterable, AsyncIterable or Stream', 'source', ret)\n        }\n      } else if (isIterable(stream) || isReadableNodeStream(stream)) {\n        ret = stream\n      } else {\n        ret = Duplex.from(stream)\n      }\n    } else if (typeof stream === 'function') {\n      ret = makeAsyncIterable(ret)\n      ret = stream(ret, {\n        signal\n      })\n      if (reading) {\n        if (!isIterable(ret, true)) {\n          throw new ERR_INVALID_RETURN_VALUE('AsyncIterable', `transform[${i - 1}]`, ret)\n        }\n      } else {\n        var _ret\n        if (!PassThrough) {\n          PassThrough = require('./passthrough')\n        }\n\n        // If the last argument to pipeline is not a stream\n        // we must create a proxy stream so that pipeline(...)\n        // always returns a stream which can be further\n        // composed through `.pipe(stream)`.\n\n        const pt = new PassThrough({\n          objectMode: true\n        })\n\n        // Handle Promises/A+ spec, `then` could be a getter that throws on\n        // second use.\n        const then = (_ret = ret) === null || _ret === undefined ? undefined : _ret.then\n        if (typeof then === 'function') {\n          finishCount++\n          then.call(\n            ret,\n            (val) => {\n              value = val\n              if (val != null) {\n                pt.write(val)\n              }\n              if (end) {\n                pt.end()\n              }\n              process.nextTick(finish)\n            },\n            (err) => {\n              pt.destroy(err)\n              process.nextTick(finish, err)\n            }\n          )\n        } else if (isIterable(ret, true)) {\n          finishCount++\n          pump(ret, pt, finish, {\n            end\n          })\n        } else {\n          throw new ERR_INVALID_RETURN_VALUE('AsyncIterable or Promise', 'destination', ret)\n        }\n        ret = pt\n        const { destroy, cleanup } = destroyer(ret, false, true)\n        destroys.push(destroy)\n        if (isLastStream) {\n          lastStreamCleanup.push(cleanup)\n        }\n      }\n    } else if (isNodeStream(stream)) {\n      if (isReadableNodeStream(ret)) {\n        finishCount += 2\n        const cleanup = pipe(ret, stream, finish, {\n          end\n        })\n        if (isReadable(stream) && isLastStream) {\n          lastStreamCleanup.push(cleanup)\n        }\n      } else if (isIterable(ret)) {\n        finishCount++\n        pump(ret, stream, finish, {\n          end\n        })\n      } else {\n        throw new ERR_INVALID_ARG_TYPE('val', ['Readable', 'Iterable', 'AsyncIterable'], ret)\n      }\n      ret = stream\n    } else {\n      ret = Duplex.from(stream)\n    }\n  }\n  if (\n    (signal !== null && signal !== undefined && signal.aborted) ||\n    (outerSignal !== null && outerSignal !== undefined && outerSignal.aborted)\n  ) {\n    process.nextTick(abort)\n  }\n  return ret\n}\nfunction pipe(src, dst, finish, { end }) {\n  let ended = false\n  dst.on('close', () => {\n    if (!ended) {\n      // Finish if the destination closes before the source has completed.\n      finish(new ERR_STREAM_PREMATURE_CLOSE())\n    }\n  })\n  src.pipe(dst, {\n    end\n  })\n  if (end) {\n    // Compat. Before node v10.12.0 stdio used to throw an error so\n    // pipe() did/does not end() stdio destinations.\n    // Now they allow it but \"secretly\" don't close the underlying fd.\n    src.once('end', () => {\n      ended = true\n      dst.end()\n    })\n  } else {\n    finish()\n  }\n  eos(\n    src,\n    {\n      readable: true,\n      writable: false\n    },\n    (err) => {\n      const rState = src._readableState\n      if (\n        err &&\n        err.code === 'ERR_STREAM_PREMATURE_CLOSE' &&\n        rState &&\n        rState.ended &&\n        !rState.errored &&\n        !rState.errorEmitted\n      ) {\n        // Some readable streams will emit 'close' before 'end'. However, since\n        // this is on the readable side 'end' should still be emitted if the\n        // stream has been ended and no error emitted. This should be allowed in\n        // favor of backwards compatibility. Since the stream is piped to a\n        // destination this should not result in any observable difference.\n        // We don't need to check if this is a writable premature close since\n        // eos will only fail with premature close on the reading side for\n        // duplex streams.\n        src.once('end', finish).once('error', finish)\n      } else {\n        finish(err)\n      }\n    }\n  )\n  return eos(\n    dst,\n    {\n      readable: false,\n      writable: true\n    },\n    finish\n  )\n}\nmodule.exports = {\n  pipelineImpl,\n  pipeline\n}\n","/* replacement start */\n\nconst process = require('process/')\n\n/* replacement end */\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')\nconst {\n  ArrayPrototypeIndexOf,\n  NumberIsInteger,\n  NumberIsNaN,\n  NumberParseInt,\n  ObjectDefineProperties,\n  ObjectKeys,\n  ObjectSetPrototypeOf,\n  Promise,\n  SafeSet,\n  SymbolAsyncIterator,\n  Symbol\n} = require('../../ours/primordials')\nmodule.exports = Readable\nReadable.ReadableState = ReadableState\nconst { EventEmitter: EE } = require('events')\nconst { Stream, prependListener } = require('./legacy')\nconst { Buffer } = require('buffer')\nconst { addAbortSignal } = require('./add-abort-signal')\nconst eos = require('./end-of-stream')\nlet debug = require('../../ours/util').debuglog('stream', (fn) => {\n  debug = fn\n})\nconst BufferList = require('./buffer_list')\nconst destroyImpl = require('./destroy')\nconst { getHighWaterMark, getDefaultHighWaterMark } = require('./state')\nconst {\n  aggregateTwoErrors,\n  codes: {\n    ERR_INVALID_ARG_TYPE,\n    ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_OUT_OF_RANGE,\n    ERR_STREAM_PUSH_AFTER_EOF,\n    ERR_STREAM_UNSHIFT_AFTER_END_EVENT\n  }\n} = require('../../ours/errors')\nconst { validateObject } = require('../validators')\nconst kPaused = Symbol('kPaused')\nconst { StringDecoder } = require('string_decoder')\nconst from = require('./from')\nObjectSetPrototypeOf(Readable.prototype, Stream.prototype)\nObjectSetPrototypeOf(Readable, Stream)\nconst nop = () => {}\nconst { errorOrDestroy } = destroyImpl\nfunction ReadableState(options, stream, isDuplex) {\n  // 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  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof require('./duplex')\n\n  // Object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away.\n  this.objectMode = !!(options && options.objectMode)\n  if (isDuplex) this.objectMode = this.objectMode || !!(options && options.readableObjectMode)\n\n  // 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  this.highWaterMark = options\n    ? getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex)\n    : getDefaultHighWaterMark(false)\n\n  // 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  this.buffer = new BufferList()\n  this.length = 0\n  this.pipes = []\n  this.flowing = null\n  this.ended = false\n  this.endEmitted = false\n  this.reading = false\n\n  // Stream is still being constructed and cannot be\n  // destroyed until construction finished or failed.\n  // Async construction is opt in, therefore we start as\n  // constructed.\n  this.constructed = true\n\n  // 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  this.sync = true\n\n  // Whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false\n  this.emittedReadable = false\n  this.readableListening = false\n  this.resumeScheduled = false\n  this[kPaused] = null\n\n  // True if the error was already emitted and should not be thrown again.\n  this.errorEmitted = false\n\n  // Should close be emitted on destroy. Defaults to true.\n  this.emitClose = !options || options.emitClose !== false\n\n  // Should .destroy() be called after 'end' (and potentially 'finish').\n  this.autoDestroy = !options || options.autoDestroy !== false\n\n  // Has it been destroyed.\n  this.destroyed = false\n\n  // Indicates whether the stream has errored. When true no further\n  // _read calls, 'data' or 'readable' events should occur. This is needed\n  // since when autoDestroy is disabled we need a way to tell whether the\n  // stream has failed.\n  this.errored = null\n\n  // Indicates whether the stream has finished destroying.\n  this.closed = false\n\n  // True if close has been emitted or would have been emitted\n  // depending on emitClose.\n  this.closeEmitted = false\n\n  // 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  this.defaultEncoding = (options && options.defaultEncoding) || 'utf8'\n\n  // Ref the piped dest which we need a drain event on it\n  // type: null | Writable | Set<Writable>.\n  this.awaitDrainWriters = null\n  this.multiAwaitDrain = false\n\n  // If true, a maybeReadMore has been scheduled.\n  this.readingMore = false\n  this.dataEmitted = false\n  this.decoder = null\n  this.encoding = null\n  if (options && options.encoding) {\n    this.decoder = new StringDecoder(options.encoding)\n    this.encoding = options.encoding\n  }\n}\nfunction Readable(options) {\n  if (!(this instanceof Readable)) return new Readable(options)\n\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the ReadableState constructor, at least with V8 6.5.\n  const isDuplex = this instanceof require('./duplex')\n  this._readableState = new ReadableState(options, this, isDuplex)\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read\n    if (typeof options.destroy === 'function') this._destroy = options.destroy\n    if (typeof options.construct === 'function') this._construct = options.construct\n    if (options.signal && !isDuplex) addAbortSignal(options.signal, this)\n  }\n  Stream.call(this, options)\n  destroyImpl.construct(this, () => {\n    if (this._readableState.needReadable) {\n      maybeReadMore(this, this._readableState)\n    }\n  })\n}\nReadable.prototype.destroy = destroyImpl.destroy\nReadable.prototype._undestroy = destroyImpl.undestroy\nReadable.prototype._destroy = function (err, cb) {\n  cb(err)\n}\nReadable.prototype[EE.captureRejectionSymbol] = function (err) {\n  this.destroy(err)\n}\n\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.\nReadable.prototype.push = function (chunk, encoding) {\n  return readableAddChunk(this, chunk, encoding, false)\n}\n\n// Unshift should *always* be something directly out of read().\nReadable.prototype.unshift = function (chunk, encoding) {\n  return readableAddChunk(this, chunk, encoding, true)\n}\nfunction readableAddChunk(stream, chunk, encoding, addToFront) {\n  debug('readableAddChunk', chunk)\n  const state = stream._readableState\n  let err\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding\n      if (state.encoding !== encoding) {\n        if (addToFront && state.encoding) {\n          // When unshifting, if state.encoding is set, we have to save\n          // the string in the BufferList with the state encoding.\n          chunk = Buffer.from(chunk, encoding).toString(state.encoding)\n        } else {\n          chunk = Buffer.from(chunk, encoding)\n          encoding = ''\n        }\n      }\n    } else if (chunk instanceof Buffer) {\n      encoding = ''\n    } else if (Stream._isUint8Array(chunk)) {\n      chunk = Stream._uint8ArrayToBuffer(chunk)\n      encoding = ''\n    } else if (chunk != null) {\n      err = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk)\n    }\n  }\n  if (err) {\n    errorOrDestroy(stream, err)\n  } else if (chunk === null) {\n    state.reading = false\n    onEofChunk(stream, state)\n  } else if (state.objectMode || (chunk && chunk.length > 0)) {\n    if (addToFront) {\n      if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT())\n      else if (state.destroyed || state.errored) return false\n      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 || state.errored) {\n      return false\n    } else {\n      state.reading = false\n      if (state.decoder && !encoding) {\n        chunk = state.decoder.write(chunk)\n        if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false)\n        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\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  return !state.ended && (state.length < state.highWaterMark || state.length === 0)\n}\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync && stream.listenerCount('data') > 0) {\n    // Use the guard to avoid creating `Set()` repeatedly\n    // when we have multiple pipes.\n    if (state.multiAwaitDrain) {\n      state.awaitDrainWriters.clear()\n    } else {\n      state.awaitDrainWriters = null\n    }\n    state.dataEmitted = true\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)\n    else state.buffer.push(chunk)\n    if (state.needReadable) emitReadable(stream)\n  }\n  maybeReadMore(stream, state)\n}\nReadable.prototype.isPaused = function () {\n  const state = this._readableState\n  return state[kPaused] === true || state.flowing === false\n}\n\n// Backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  const decoder = new StringDecoder(enc)\n  this._readableState.decoder = decoder\n  // If setEncoding(null), decoder.encoding equals utf8.\n  this._readableState.encoding = this._readableState.decoder.encoding\n  const buffer = this._readableState.buffer\n  // Iterate over current buffer to convert already stored Buffers:\n  let content = ''\n  for (const data of buffer) {\n    content += decoder.write(data)\n  }\n  buffer.clear()\n  if (content !== '') buffer.push(content)\n  this._readableState.length = content.length\n  return this\n}\n\n// Don't raise the hwm > 1GB.\nconst MAX_HWM = 0x40000000\nfunction computeNewHighWaterMark(n) {\n  if (n > MAX_HWM) {\n    throw new ERR_OUT_OF_RANGE('size', '<= 1GiB', n)\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  return n\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || (state.length === 0 && state.ended)) return 0\n  if (state.objectMode) return 1\n  if (NumberIsNaN(n)) {\n    // Only flow one buffer at a time.\n    if (state.flowing && state.length) return state.buffer.first().length\n    return state.length\n  }\n  if (n <= state.length) return n\n  return state.ended ? state.length : 0\n}\n\n// You can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n)\n  // Same as parseInt(undefined, 10), however V8 7.3 performance regressed\n  // in this scenario, so we are doing it manually.\n  if (n === undefined) {\n    n = NaN\n  } else if (!NumberIsInteger(n)) {\n    n = NumberParseInt(n, 10)\n  }\n  const state = this._readableState\n  const nOrig = n\n\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n)\n  if (n !== 0) state.emittedReadable = false\n\n  // 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  if (\n    n === 0 &&\n    state.needReadable &&\n    ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)\n  ) {\n    debug('read: emitReadable', state.length, state.ended)\n    if (state.length === 0 && state.ended) endReadable(this)\n    else emitReadable(this)\n    return null\n  }\n  n = howMuchToRead(n, state)\n\n  // If we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this)\n    return null\n  }\n\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\n  // if we need a readable event, then we need to do some reading.\n  let doRead = state.needReadable\n  debug('need readable', doRead)\n\n  // If we currently have less than the highWaterMark, then also read some.\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true\n    debug('length less than watermark', doRead)\n  }\n\n  // However, if we've ended, then there's no point, if we're already\n  // reading, then it's unnecessary, if we're constructing we have to wait,\n  // and if we're destroyed or errored, then it's not allowed,\n  if (state.ended || state.reading || state.destroyed || state.errored || !state.constructed) {\n    doRead = false\n    debug('reading, ended or constructing', doRead)\n  } else if (doRead) {\n    debug('do read')\n    state.reading = true\n    state.sync = true\n    // If the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true\n\n    // Call internal read method\n    try {\n      this._read(state.highWaterMark)\n    } catch (err) {\n      errorOrDestroy(this, err)\n    }\n    state.sync = false\n    // 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    if (!state.reading) n = howMuchToRead(nOrig, state)\n  }\n  let ret\n  if (n > 0) ret = fromList(n, state)\n  else ret = null\n  if (ret === null) {\n    state.needReadable = state.length <= state.highWaterMark\n    n = 0\n  } else {\n    state.length -= n\n    if (state.multiAwaitDrain) {\n      state.awaitDrainWriters.clear()\n    } else {\n      state.awaitDrainWriters = null\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\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this)\n  }\n  if (ret !== null && !state.errorEmitted && !state.closeEmitted) {\n    state.dataEmitted = true\n    this.emit('data', ret)\n  }\n  return ret\n}\nfunction onEofChunk(stream, state) {\n  debug('onEofChunk')\n  if (state.ended) return\n  if (state.decoder) {\n    const chunk = state.decoder.end()\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk)\n      state.length += state.objectMode ? 1 : chunk.length\n    }\n  }\n  state.ended = true\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    state.emittedReadable = true\n    // We have to emit readable now that we are EOF. Modules\n    // in the ecosystem (e.g. dicer) rely on this event being sync.\n    emitReadable_(stream)\n  }\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.\nfunction emitReadable(stream) {\n  const state = stream._readableState\n  debug('emitReadable', state.needReadable, state.emittedReadable)\n  state.needReadable = false\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing)\n    state.emittedReadable = true\n    process.nextTick(emitReadable_, stream)\n  }\n}\nfunction emitReadable_(stream) {\n  const state = stream._readableState\n  debug('emitReadable_', state.destroyed, state.length, state.ended)\n  if (!state.destroyed && !state.errored && (state.length || state.ended)) {\n    stream.emit('readable')\n    state.emittedReadable = false\n  }\n\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  state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark\n  flow(stream)\n}\n\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.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore && state.constructed) {\n    state.readingMore = true\n    process.nextTick(maybeReadMore_, stream, state)\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 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 (\n    !state.reading &&\n    !state.ended &&\n    (state.length < state.highWaterMark || (state.flowing && state.length === 0))\n  ) {\n    const len = state.length\n    debug('maybeReadMore read 0')\n    stream.read(0)\n    if (len === state.length)\n      // Didn't get any data, stop spinning.\n      break\n  }\n  state.readingMore = false\n}\n\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.\nReadable.prototype._read = function (n) {\n  throw new ERR_METHOD_NOT_IMPLEMENTED('_read()')\n}\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  const src = this\n  const state = this._readableState\n  if (state.pipes.length === 1) {\n    if (!state.multiAwaitDrain) {\n      state.multiAwaitDrain = true\n      state.awaitDrainWriters = new SafeSet(state.awaitDrainWriters ? [state.awaitDrainWriters] : [])\n    }\n  }\n  state.pipes.push(dest)\n  debug('pipe count=%d opts=%j', state.pipes.length, pipeOpts)\n  const doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr\n  const endFn = doEnd ? onend : unpipe\n  if (state.endEmitted) process.nextTick(endFn)\n  else src.once('end', endFn)\n  dest.on('unpipe', onunpipe)\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe')\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true\n        cleanup()\n      }\n    }\n  }\n  function onend() {\n    debug('onend')\n    dest.end()\n  }\n  let ondrain\n  let cleanedUp = false\n  function cleanup() {\n    debug('cleanup')\n    // Cleanup event handlers once the pipe is broken.\n    dest.removeListener('close', onclose)\n    dest.removeListener('finish', onfinish)\n    if (ondrain) {\n      dest.removeListener('drain', ondrain)\n    }\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\n\n    // 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    if (ondrain && state.awaitDrainWriters && (!dest._writableState || dest._writableState.needDrain)) ondrain()\n  }\n  function pause() {\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 (!cleanedUp) {\n      if (state.pipes.length === 1 && state.pipes[0] === dest) {\n        debug('false write response, pause', 0)\n        state.awaitDrainWriters = dest\n        state.multiAwaitDrain = false\n      } else if (state.pipes.length > 1 && state.pipes.includes(dest)) {\n        debug('false write response, pause', state.awaitDrainWriters.size)\n        state.awaitDrainWriters.add(dest)\n      }\n      src.pause()\n    }\n    if (!ondrain) {\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      ondrain = pipeOnDrain(src, dest)\n      dest.on('drain', ondrain)\n    }\n  }\n  src.on('data', ondata)\n  function ondata(chunk) {\n    debug('ondata')\n    const ret = dest.write(chunk)\n    debug('dest.write', ret)\n    if (ret === false) {\n      pause()\n    }\n  }\n\n  // If the dest has an error, then stop piping into it.\n  // However, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er)\n    unpipe()\n    dest.removeListener('error', onerror)\n    if (dest.listenerCount('error') === 0) {\n      const s = dest._writableState || dest._readableState\n      if (s && !s.errorEmitted) {\n        // User incorrectly emitted 'error' directly on the stream.\n        errorOrDestroy(dest, er)\n      } else {\n        dest.emit('error', er)\n      }\n    }\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror)\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish)\n    unpipe()\n  }\n  dest.once('close', onclose)\n  function onfinish() {\n    debug('onfinish')\n    dest.removeListener('close', onclose)\n    unpipe()\n  }\n  dest.once('finish', onfinish)\n  function unpipe() {\n    debug('unpipe')\n    src.unpipe(dest)\n  }\n\n  // Tell the dest that it's being piped to.\n  dest.emit('pipe', src)\n\n  // Start the flow if it hasn't been started already.\n\n  if (dest.writableNeedDrain === true) {\n    if (state.flowing) {\n      pause()\n    }\n  } else if (!state.flowing) {\n    debug('pipe resume')\n    src.resume()\n  }\n  return dest\n}\nfunction pipeOnDrain(src, dest) {\n  return function pipeOnDrainFunctionResult() {\n    const state = src._readableState\n\n    // `ondrain` will call directly,\n    // `this` maybe not a reference to dest,\n    // so we use the real dest here.\n    if (state.awaitDrainWriters === dest) {\n      debug('pipeOnDrain', 1)\n      state.awaitDrainWriters = null\n    } else if (state.multiAwaitDrain) {\n      debug('pipeOnDrain', state.awaitDrainWriters.size)\n      state.awaitDrainWriters.delete(dest)\n    }\n    if ((!state.awaitDrainWriters || state.awaitDrainWriters.size === 0) && src.listenerCount('data')) {\n      src.resume()\n    }\n  }\n}\nReadable.prototype.unpipe = function (dest) {\n  const state = this._readableState\n  const unpipeInfo = {\n    hasUnpiped: false\n  }\n\n  // If we're not piping anywhere, then do nothing.\n  if (state.pipes.length === 0) return this\n  if (!dest) {\n    // remove all.\n    const dests = state.pipes\n    state.pipes = []\n    this.pause()\n    for (let i = 0; i < dests.length; i++)\n      dests[i].emit('unpipe', this, {\n        hasUnpiped: false\n      })\n    return this\n  }\n\n  // Try to find the right one.\n  const index = ArrayPrototypeIndexOf(state.pipes, dest)\n  if (index === -1) return this\n  state.pipes.splice(index, 1)\n  if (state.pipes.length === 0) this.pause()\n  dest.emit('unpipe', this, unpipeInfo)\n  return this\n}\n\n// Set up data events if they are asked for\n// Ensure readable listeners eventually get something.\nReadable.prototype.on = function (ev, fn) {\n  const res = Stream.prototype.on.call(this, ev, fn)\n  const state = this._readableState\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\n\n    // Try start flowing on next tick if stream isn't explicitly paused.\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      if (state.length) {\n        emitReadable(this)\n      } else if (!state.reading) {\n        process.nextTick(nReadingNextTick, this)\n      }\n    }\n  }\n  return res\n}\nReadable.prototype.addListener = Readable.prototype.on\nReadable.prototype.removeListener = function (ev, fn) {\n  const res = Stream.prototype.removeListener.call(this, ev, fn)\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  return res\n}\nReadable.prototype.off = Readable.prototype.removeListener\nReadable.prototype.removeAllListeners = function (ev) {\n  const res = Stream.prototype.removeAllListeners.apply(this, arguments)\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  return res\n}\nfunction updateReadableListening(self) {\n  const state = self._readableState\n  state.readableListening = self.listenerCount('readable') > 0\n  if (state.resumeScheduled && state[kPaused] === false) {\n    // Flowing needs to be set to true now, otherwise\n    // the upcoming resume will not flow.\n    state.flowing = true\n\n    // Crude way to check if we should resume.\n  } else if (self.listenerCount('data') > 0) {\n    self.resume()\n  } else if (!state.readableListening) {\n    state.flowing = null\n  }\n}\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0')\n  self.read(0)\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  const state = this._readableState\n  if (!state.flowing) {\n    debug('resume')\n    // We flow only if there is no one listening\n    // for readable, but we still have to call\n    // resume().\n    state.flowing = !state.readableListening\n    resume(this, state)\n  }\n  state[kPaused] = false\n  return this\n}\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true\n    process.nextTick(resume_, stream, state)\n  }\n}\nfunction resume_(stream, state) {\n  debug('resume', state.reading)\n  if (!state.reading) {\n    stream.read(0)\n  }\n  state.resumeScheduled = false\n  stream.emit('resume')\n  flow(stream)\n  if (state.flowing && !state.reading) stream.read(0)\n}\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing)\n  if (this._readableState.flowing !== false) {\n    debug('pause')\n    this._readableState.flowing = false\n    this.emit('pause')\n  }\n  this._readableState[kPaused] = true\n  return this\n}\nfunction flow(stream) {\n  const state = stream._readableState\n  debug('flow', state.flowing)\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.\nReadable.prototype.wrap = function (stream) {\n  let paused = false\n\n  // TODO (ronag): Should this.destroy(err) emit\n  // 'error' on the wrapped stream? Would require\n  // a static factory method, e.g. Readable.wrap(stream).\n\n  stream.on('data', (chunk) => {\n    if (!this.push(chunk) && stream.pause) {\n      paused = true\n      stream.pause()\n    }\n  })\n  stream.on('end', () => {\n    this.push(null)\n  })\n  stream.on('error', (err) => {\n    errorOrDestroy(this, err)\n  })\n  stream.on('close', () => {\n    this.destroy()\n  })\n  stream.on('destroy', () => {\n    this.destroy()\n  })\n  this._read = () => {\n    if (paused && stream.resume) {\n      paused = false\n      stream.resume()\n    }\n  }\n\n  // Proxy all the other methods. Important when wrapping filters and duplexes.\n  const streamKeys = ObjectKeys(stream)\n  for (let j = 1; j < streamKeys.length; j++) {\n    const i = streamKeys[j]\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = stream[i].bind(stream)\n    }\n  }\n  return this\n}\nReadable.prototype[SymbolAsyncIterator] = function () {\n  return streamToAsyncIterator(this)\n}\nReadable.prototype.iterator = function (options) {\n  if (options !== undefined) {\n    validateObject(options, 'options')\n  }\n  return streamToAsyncIterator(this, options)\n}\nfunction streamToAsyncIterator(stream, options) {\n  if (typeof stream.read !== 'function') {\n    stream = Readable.wrap(stream, {\n      objectMode: true\n    })\n  }\n  const iter = createAsyncIterator(stream, options)\n  iter.stream = stream\n  return iter\n}\nasync function* createAsyncIterator(stream, options) {\n  let callback = nop\n  function next(resolve) {\n    if (this === stream) {\n      callback()\n      callback = nop\n    } else {\n      callback = resolve\n    }\n  }\n  stream.on('readable', next)\n  let error\n  const cleanup = eos(\n    stream,\n    {\n      writable: false\n    },\n    (err) => {\n      error = err ? aggregateTwoErrors(error, err) : null\n      callback()\n      callback = nop\n    }\n  )\n  try {\n    while (true) {\n      const chunk = stream.destroyed ? null : stream.read()\n      if (chunk !== null) {\n        yield chunk\n      } else if (error) {\n        throw error\n      } else if (error === null) {\n        return\n      } else {\n        await new Promise(next)\n      }\n    }\n  } catch (err) {\n    error = aggregateTwoErrors(error, err)\n    throw error\n  } finally {\n    if (\n      (error || (options === null || options === undefined ? undefined : options.destroyOnReturn) !== false) &&\n      (error === undefined || stream._readableState.autoDestroy)\n    ) {\n      destroyImpl.destroyer(stream, null)\n    } else {\n      stream.off('readable', next)\n      cleanup()\n    }\n  }\n}\n\n// Making it explicit these properties are not enumerable\n// because otherwise some prototype manipulation in\n// userland will fail.\nObjectDefineProperties(Readable.prototype, {\n  readable: {\n    __proto__: null,\n    get() {\n      const r = this._readableState\n      // r.readable === false means that this is part of a Duplex stream\n      // where the readable side was disabled upon construction.\n      // Compat. The user might manually disable readable side through\n      // deprecated setter.\n      return !!r && r.readable !== false && !r.destroyed && !r.errorEmitted && !r.endEmitted\n    },\n    set(val) {\n      // Backwards compat.\n      if (this._readableState) {\n        this._readableState.readable = !!val\n      }\n    }\n  },\n  readableDidRead: {\n    __proto__: null,\n    enumerable: false,\n    get: function () {\n      return this._readableState.dataEmitted\n    }\n  },\n  readableAborted: {\n    __proto__: null,\n    enumerable: false,\n    get: function () {\n      return !!(\n        this._readableState.readable !== false &&\n        (this._readableState.destroyed || this._readableState.errored) &&\n        !this._readableState.endEmitted\n      )\n    }\n  },\n  readableHighWaterMark: {\n    __proto__: null,\n    enumerable: false,\n    get: function () {\n      return this._readableState.highWaterMark\n    }\n  },\n  readableBuffer: {\n    __proto__: null,\n    enumerable: false,\n    get: function () {\n      return this._readableState && this._readableState.buffer\n    }\n  },\n  readableFlowing: {\n    __proto__: null,\n    enumerable: false,\n    get: function () {\n      return this._readableState.flowing\n    },\n    set: function (state) {\n      if (this._readableState) {\n        this._readableState.flowing = state\n      }\n    }\n  },\n  readableLength: {\n    __proto__: null,\n    enumerable: false,\n    get() {\n      return this._readableState.length\n    }\n  },\n  readableObjectMode: {\n    __proto__: null,\n    enumerable: false,\n    get() {\n      return this._readableState ? this._readableState.objectMode : false\n    }\n  },\n  readableEncoding: {\n    __proto__: null,\n    enumerable: false,\n    get() {\n      return this._readableState ? this._readableState.encoding : null\n    }\n  },\n  errored: {\n    __proto__: null,\n    enumerable: false,\n    get() {\n      return this._readableState ? this._readableState.errored : null\n    }\n  },\n  closed: {\n    __proto__: null,\n    get() {\n      return this._readableState ? this._readableState.closed : false\n    }\n  },\n  destroyed: {\n    __proto__: null,\n    enumerable: false,\n    get() {\n      return this._readableState ? this._readableState.destroyed : false\n    },\n    set(value) {\n      // We ignore the value if the stream\n      // has not been initialized yet.\n      if (!this._readableState) {\n        return\n      }\n\n      // Backward compatibility, the user is explicitly\n      // managing destroyed.\n      this._readableState.destroyed = value\n    }\n  },\n  readableEnded: {\n    __proto__: null,\n    enumerable: false,\n    get() {\n      return this._readableState ? this._readableState.endEmitted : false\n    }\n  }\n})\nObjectDefineProperties(ReadableState.prototype, {\n  // Legacy getter for `pipesCount`.\n  pipesCount: {\n    __proto__: null,\n    get() {\n      return this.pipes.length\n    }\n  },\n  // Legacy property for `paused`.\n  paused: {\n    __proto__: null,\n    get() {\n      return this[kPaused] !== false\n    },\n    set(value) {\n      this[kPaused] = !!value\n    }\n  }\n})\n\n// Exposed for testing purposes only.\nReadable._fromList = fromList\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.\nfunction fromList(n, state) {\n  // nothing buffered.\n  if (state.length === 0) return null\n  let ret\n  if (state.objectMode) ret = state.buffer.shift()\n  else if (!n || n >= state.length) {\n    // Read it all, truncate the list.\n    if (state.decoder) ret = state.buffer.join('')\n    else if (state.buffer.length === 1) ret = state.buffer.first()\n    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}\nfunction endReadable(stream) {\n  const state = stream._readableState\n  debug('endReadable', state.endEmitted)\n  if (!state.endEmitted) {\n    state.ended = true\n    process.nextTick(endReadableNT, state, stream)\n  }\n}\nfunction endReadableNT(state, stream) {\n  debug('endReadableNT', state.endEmitted, state.length)\n\n  // Check that we didn't get one last unshift.\n  if (!state.errored && !state.closeEmitted && !state.endEmitted && state.length === 0) {\n    state.endEmitted = true\n    stream.emit('end')\n    if (stream.writable && stream.allowHalfOpen === false) {\n      process.nextTick(endWritableNT, stream)\n    } else 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      const wState = stream._writableState\n      const autoDestroy =\n        !wState ||\n        (wState.autoDestroy &&\n          // We don't expect the writable to ever 'finish'\n          // if writable is explicitly set to false.\n          (wState.finished || wState.writable === false))\n      if (autoDestroy) {\n        stream.destroy()\n      }\n    }\n  }\n}\nfunction endWritableNT(stream) {\n  const writable = stream.writable && !stream.writableEnded && !stream.destroyed\n  if (writable) {\n    stream.end()\n  }\n}\nReadable.from = function (iterable, opts) {\n  return from(Readable, iterable, opts)\n}\nlet webStreamsAdapters\n\n// Lazy to avoid circular references\nfunction lazyWebStreams() {\n  if (webStreamsAdapters === undefined) webStreamsAdapters = {}\n  return webStreamsAdapters\n}\nReadable.fromWeb = function (readableStream, options) {\n  return lazyWebStreams().newStreamReadableFromReadableStream(readableStream, options)\n}\nReadable.toWeb = function (streamReadable, options) {\n  return lazyWebStreams().newReadableStreamFromStreamReadable(streamReadable, options)\n}\nReadable.wrap = function (src, options) {\n  var _ref, _src$readableObjectMo\n  return new Readable({\n    objectMode:\n      (_ref =\n        (_src$readableObjectMo = src.readableObjectMode) !== null && _src$readableObjectMo !== undefined\n          ? _src$readableObjectMo\n          : src.objectMode) !== null && _ref !== undefined\n        ? _ref\n        : true,\n    ...options,\n    destroy(err, callback) {\n      destroyImpl.destroyer(src, err)\n      callback(err)\n    }\n  }).wrap(src)\n}\n","'use strict'\n\nconst { MathFloor, NumberIsInteger } = require('../../ours/primordials')\nconst { ERR_INVALID_ARG_VALUE } = require('../../ours/errors').codes\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null\n}\nfunction getDefaultHighWaterMark(objectMode) {\n  return objectMode ? 16 : 16 * 1024\n}\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n  const hwm = highWaterMarkFrom(options, isDuplex, duplexKey)\n  if (hwm != null) {\n    if (!NumberIsInteger(hwm) || hwm < 0) {\n      const name = isDuplex ? `options.${duplexKey}` : 'options.highWaterMark'\n      throw new ERR_INVALID_ARG_VALUE(name, hwm)\n    }\n    return MathFloor(hwm)\n  }\n\n  // Default value\n  return getDefaultHighWaterMark(state.objectMode)\n}\nmodule.exports = {\n  getHighWaterMark,\n  getDefaultHighWaterMark\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// 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\n'use strict'\n\nconst { ObjectSetPrototypeOf, Symbol } = require('../../ours/primordials')\nmodule.exports = Transform\nconst { ERR_METHOD_NOT_IMPLEMENTED } = require('../../ours/errors').codes\nconst Duplex = require('./duplex')\nconst { getHighWaterMark } = require('./state')\nObjectSetPrototypeOf(Transform.prototype, Duplex.prototype)\nObjectSetPrototypeOf(Transform, Duplex)\nconst kCallback = Symbol('kCallback')\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options)\n\n  // TODO (ronag): This should preferably always be\n  // applied but would be semver-major. Or even better;\n  // make Transform a Readable with the Writable interface.\n  const readableHighWaterMark = options ? getHighWaterMark(this, options, 'readableHighWaterMark', true) : null\n  if (readableHighWaterMark === 0) {\n    // A Duplex will buffer both on the writable and readable side while\n    // a Transform just wants to buffer hwm number of elements. To avoid\n    // buffering twice we disable buffering on the writable side.\n    options = {\n      ...options,\n      highWaterMark: null,\n      readableHighWaterMark,\n      // TODO (ronag): 0 is not optimal since we have\n      // a \"bug\" where we check needDrain before calling _write and not after.\n      // Refs: https://github.com/nodejs/node/pull/32887\n      // Refs: https://github.com/nodejs/node/pull/35941\n      writableHighWaterMark: options.writableHighWaterMark || 0\n    }\n  }\n  Duplex.call(this, options)\n\n  // 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  this._readableState.sync = false\n  this[kCallback] = null\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform\n    if (typeof options.flush === 'function') this._flush = options.flush\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  // Backwards compat. Some Transform streams incorrectly implement _final\n  // instead of or in addition to _flush. By using 'prefinish' instead of\n  // implementing _final we continue supporting this unfortunate use case.\n  this.on('prefinish', prefinish)\n}\nfunction final(cb) {\n  if (typeof this._flush === 'function' && !this.destroyed) {\n    this._flush((er, data) => {\n      if (er) {\n        if (cb) {\n          cb(er)\n        } else {\n          this.destroy(er)\n        }\n        return\n      }\n      if (data != null) {\n        this.push(data)\n      }\n      this.push(null)\n      if (cb) {\n        cb()\n      }\n    })\n  } else {\n    this.push(null)\n    if (cb) {\n      cb()\n    }\n  }\n}\nfunction prefinish() {\n  if (this._final !== final) {\n    final.call(this)\n  }\n}\nTransform.prototype._final = final\nTransform.prototype._transform = function (chunk, encoding, callback) {\n  throw new ERR_METHOD_NOT_IMPLEMENTED('_transform()')\n}\nTransform.prototype._write = function (chunk, encoding, callback) {\n  const rState = this._readableState\n  const wState = this._writableState\n  const length = rState.length\n  this._transform(chunk, encoding, (err, val) => {\n    if (err) {\n      callback(err)\n      return\n    }\n    if (val != null) {\n      this.push(val)\n    }\n    if (\n      wState.ended ||\n      // Backwards compat.\n      length === rState.length ||\n      // Backwards compat.\n      rState.length < rState.highWaterMark\n    ) {\n      callback()\n    } else {\n      this[kCallback] = callback\n    }\n  })\n}\nTransform.prototype._read = function () {\n  if (this[kCallback]) {\n    const callback = this[kCallback]\n    this[kCallback] = null\n    callback()\n  }\n}\n","'use strict'\n\nconst { Symbol, SymbolAsyncIterator, SymbolIterator } = require('../../ours/primordials')\nconst kDestroyed = Symbol('kDestroyed')\nconst kIsErrored = Symbol('kIsErrored')\nconst kIsReadable = Symbol('kIsReadable')\nconst kIsDisturbed = Symbol('kIsDisturbed')\nfunction isReadableNodeStream(obj, strict = false) {\n  var _obj$_readableState\n  return !!(\n    (\n      obj &&\n      typeof obj.pipe === 'function' &&\n      typeof obj.on === 'function' &&\n      (!strict || (typeof obj.pause === 'function' && typeof obj.resume === 'function')) &&\n      (!obj._writableState ||\n        ((_obj$_readableState = obj._readableState) === null || _obj$_readableState === undefined\n          ? undefined\n          : _obj$_readableState.readable) !== false) &&\n      // Duplex\n      (!obj._writableState || obj._readableState)\n    ) // Writable has .pipe.\n  )\n}\n\nfunction isWritableNodeStream(obj) {\n  var _obj$_writableState\n  return !!(\n    (\n      obj &&\n      typeof obj.write === 'function' &&\n      typeof obj.on === 'function' &&\n      (!obj._readableState ||\n        ((_obj$_writableState = obj._writableState) === null || _obj$_writableState === undefined\n          ? undefined\n          : _obj$_writableState.writable) !== false)\n    ) // Duplex\n  )\n}\n\nfunction isDuplexNodeStream(obj) {\n  return !!(\n    obj &&\n    typeof obj.pipe === 'function' &&\n    obj._readableState &&\n    typeof obj.on === 'function' &&\n    typeof obj.write === 'function'\n  )\n}\nfunction isNodeStream(obj) {\n  return (\n    obj &&\n    (obj._readableState ||\n      obj._writableState ||\n      (typeof obj.write === 'function' && typeof obj.on === 'function') ||\n      (typeof obj.pipe === 'function' && typeof obj.on === 'function'))\n  )\n}\nfunction isIterable(obj, isAsync) {\n  if (obj == null) return false\n  if (isAsync === true) return typeof obj[SymbolAsyncIterator] === 'function'\n  if (isAsync === false) return typeof obj[SymbolIterator] === 'function'\n  return typeof obj[SymbolAsyncIterator] === 'function' || typeof obj[SymbolIterator] === 'function'\n}\nfunction isDestroyed(stream) {\n  if (!isNodeStream(stream)) return null\n  const wState = stream._writableState\n  const rState = stream._readableState\n  const state = wState || rState\n  return !!(stream.destroyed || stream[kDestroyed] || (state !== null && state !== undefined && state.destroyed))\n}\n\n// Have been end():d.\nfunction isWritableEnded(stream) {\n  if (!isWritableNodeStream(stream)) return null\n  if (stream.writableEnded === true) return true\n  const wState = stream._writableState\n  if (wState !== null && wState !== undefined && wState.errored) return false\n  if (typeof (wState === null || wState === undefined ? undefined : wState.ended) !== 'boolean') return null\n  return wState.ended\n}\n\n// Have emitted 'finish'.\nfunction isWritableFinished(stream, strict) {\n  if (!isWritableNodeStream(stream)) return null\n  if (stream.writableFinished === true) return true\n  const wState = stream._writableState\n  if (wState !== null && wState !== undefined && wState.errored) return false\n  if (typeof (wState === null || wState === undefined ? undefined : wState.finished) !== 'boolean') return null\n  return !!(wState.finished || (strict === false && wState.ended === true && wState.length === 0))\n}\n\n// Have been push(null):d.\nfunction isReadableEnded(stream) {\n  if (!isReadableNodeStream(stream)) return null\n  if (stream.readableEnded === true) return true\n  const rState = stream._readableState\n  if (!rState || rState.errored) return false\n  if (typeof (rState === null || rState === undefined ? undefined : rState.ended) !== 'boolean') return null\n  return rState.ended\n}\n\n// Have emitted 'end'.\nfunction isReadableFinished(stream, strict) {\n  if (!isReadableNodeStream(stream)) return null\n  const rState = stream._readableState\n  if (rState !== null && rState !== undefined && rState.errored) return false\n  if (typeof (rState === null || rState === undefined ? undefined : rState.endEmitted) !== 'boolean') return null\n  return !!(rState.endEmitted || (strict === false && rState.ended === true && rState.length === 0))\n}\nfunction isReadable(stream) {\n  if (stream && stream[kIsReadable] != null) return stream[kIsReadable]\n  if (typeof (stream === null || stream === undefined ? undefined : stream.readable) !== 'boolean') return null\n  if (isDestroyed(stream)) return false\n  return isReadableNodeStream(stream) && stream.readable && !isReadableFinished(stream)\n}\nfunction isWritable(stream) {\n  if (typeof (stream === null || stream === undefined ? undefined : stream.writable) !== 'boolean') return null\n  if (isDestroyed(stream)) return false\n  return isWritableNodeStream(stream) && stream.writable && !isWritableEnded(stream)\n}\nfunction isFinished(stream, opts) {\n  if (!isNodeStream(stream)) {\n    return null\n  }\n  if (isDestroyed(stream)) {\n    return true\n  }\n  if ((opts === null || opts === undefined ? undefined : opts.readable) !== false && isReadable(stream)) {\n    return false\n  }\n  if ((opts === null || opts === undefined ? undefined : opts.writable) !== false && isWritable(stream)) {\n    return false\n  }\n  return true\n}\nfunction isWritableErrored(stream) {\n  var _stream$_writableStat, _stream$_writableStat2\n  if (!isNodeStream(stream)) {\n    return null\n  }\n  if (stream.writableErrored) {\n    return stream.writableErrored\n  }\n  return (_stream$_writableStat =\n    (_stream$_writableStat2 = stream._writableState) === null || _stream$_writableStat2 === undefined\n      ? undefined\n      : _stream$_writableStat2.errored) !== null && _stream$_writableStat !== undefined\n    ? _stream$_writableStat\n    : null\n}\nfunction isReadableErrored(stream) {\n  var _stream$_readableStat, _stream$_readableStat2\n  if (!isNodeStream(stream)) {\n    return null\n  }\n  if (stream.readableErrored) {\n    return stream.readableErrored\n  }\n  return (_stream$_readableStat =\n    (_stream$_readableStat2 = stream._readableState) === null || _stream$_readableStat2 === undefined\n      ? undefined\n      : _stream$_readableStat2.errored) !== null && _stream$_readableStat !== undefined\n    ? _stream$_readableStat\n    : null\n}\nfunction isClosed(stream) {\n  if (!isNodeStream(stream)) {\n    return null\n  }\n  if (typeof stream.closed === 'boolean') {\n    return stream.closed\n  }\n  const wState = stream._writableState\n  const rState = stream._readableState\n  if (\n    typeof (wState === null || wState === undefined ? undefined : wState.closed) === 'boolean' ||\n    typeof (rState === null || rState === undefined ? undefined : rState.closed) === 'boolean'\n  ) {\n    return (\n      (wState === null || wState === undefined ? undefined : wState.closed) ||\n      (rState === null || rState === undefined ? undefined : rState.closed)\n    )\n  }\n  if (typeof stream._closed === 'boolean' && isOutgoingMessage(stream)) {\n    return stream._closed\n  }\n  return null\n}\nfunction isOutgoingMessage(stream) {\n  return (\n    typeof stream._closed === 'boolean' &&\n    typeof stream._defaultKeepAlive === 'boolean' &&\n    typeof stream._removedConnection === 'boolean' &&\n    typeof stream._removedContLen === 'boolean'\n  )\n}\nfunction isServerResponse(stream) {\n  return typeof stream._sent100 === 'boolean' && isOutgoingMessage(stream)\n}\nfunction isServerRequest(stream) {\n  var _stream$req\n  return (\n    typeof stream._consuming === 'boolean' &&\n    typeof stream._dumped === 'boolean' &&\n    ((_stream$req = stream.req) === null || _stream$req === undefined ? undefined : _stream$req.upgradeOrConnect) ===\n      undefined\n  )\n}\nfunction willEmitClose(stream) {\n  if (!isNodeStream(stream)) return null\n  const wState = stream._writableState\n  const rState = stream._readableState\n  const state = wState || rState\n  return (\n    (!state && isServerResponse(stream)) || !!(state && state.autoDestroy && state.emitClose && state.closed === false)\n  )\n}\nfunction isDisturbed(stream) {\n  var _stream$kIsDisturbed\n  return !!(\n    stream &&\n    ((_stream$kIsDisturbed = stream[kIsDisturbed]) !== null && _stream$kIsDisturbed !== undefined\n      ? _stream$kIsDisturbed\n      : stream.readableDidRead || stream.readableAborted)\n  )\n}\nfunction isErrored(stream) {\n  var _ref,\n    _ref2,\n    _ref3,\n    _ref4,\n    _ref5,\n    _stream$kIsErrored,\n    _stream$_readableStat3,\n    _stream$_writableStat3,\n    _stream$_readableStat4,\n    _stream$_writableStat4\n  return !!(\n    stream &&\n    ((_ref =\n      (_ref2 =\n        (_ref3 =\n          (_ref4 =\n            (_ref5 =\n              (_stream$kIsErrored = stream[kIsErrored]) !== null && _stream$kIsErrored !== undefined\n                ? _stream$kIsErrored\n                : stream.readableErrored) !== null && _ref5 !== undefined\n              ? _ref5\n              : stream.writableErrored) !== null && _ref4 !== undefined\n            ? _ref4\n            : (_stream$_readableStat3 = stream._readableState) === null || _stream$_readableStat3 === undefined\n            ? undefined\n            : _stream$_readableStat3.errorEmitted) !== null && _ref3 !== undefined\n          ? _ref3\n          : (_stream$_writableStat3 = stream._writableState) === null || _stream$_writableStat3 === undefined\n          ? undefined\n          : _stream$_writableStat3.errorEmitted) !== null && _ref2 !== undefined\n        ? _ref2\n        : (_stream$_readableStat4 = stream._readableState) === null || _stream$_readableStat4 === undefined\n        ? undefined\n        : _stream$_readableStat4.errored) !== null && _ref !== undefined\n      ? _ref\n      : (_stream$_writableStat4 = stream._writableState) === null || _stream$_writableStat4 === undefined\n      ? undefined\n      : _stream$_writableStat4.errored)\n  )\n}\nmodule.exports = {\n  kDestroyed,\n  isDisturbed,\n  kIsDisturbed,\n  isErrored,\n  kIsErrored,\n  isReadable,\n  kIsReadable,\n  isClosed,\n  isDestroyed,\n  isDuplexNodeStream,\n  isFinished,\n  isIterable,\n  isReadableNodeStream,\n  isReadableEnded,\n  isReadableFinished,\n  isReadableErrored,\n  isNodeStream,\n  isWritable,\n  isWritableNodeStream,\n  isWritableEnded,\n  isWritableFinished,\n  isWritableErrored,\n  isServerRequest,\n  isServerResponse,\n  willEmitClose\n}\n","/* replacement start */\n\nconst process = require('process/')\n\n/* replacement end */\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// 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\n;('use strict')\nconst {\n  ArrayPrototypeSlice,\n  Error,\n  FunctionPrototypeSymbolHasInstance,\n  ObjectDefineProperty,\n  ObjectDefineProperties,\n  ObjectSetPrototypeOf,\n  StringPrototypeToLowerCase,\n  Symbol,\n  SymbolHasInstance\n} = require('../../ours/primordials')\nmodule.exports = Writable\nWritable.WritableState = WritableState\nconst { EventEmitter: EE } = require('events')\nconst Stream = require('./legacy').Stream\nconst { Buffer } = require('buffer')\nconst destroyImpl = require('./destroy')\nconst { addAbortSignal } = require('./add-abort-signal')\nconst { getHighWaterMark, getDefaultHighWaterMark } = require('./state')\nconst {\n  ERR_INVALID_ARG_TYPE,\n  ERR_METHOD_NOT_IMPLEMENTED,\n  ERR_MULTIPLE_CALLBACK,\n  ERR_STREAM_CANNOT_PIPE,\n  ERR_STREAM_DESTROYED,\n  ERR_STREAM_ALREADY_FINISHED,\n  ERR_STREAM_NULL_VALUES,\n  ERR_STREAM_WRITE_AFTER_END,\n  ERR_UNKNOWN_ENCODING\n} = require('../../ours/errors').codes\nconst { errorOrDestroy } = destroyImpl\nObjectSetPrototypeOf(Writable.prototype, Stream.prototype)\nObjectSetPrototypeOf(Writable, Stream)\nfunction nop() {}\nconst kOnFinished = Symbol('kOnFinished')\nfunction WritableState(options, stream, isDuplex) {\n  // 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  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof require('./duplex')\n\n  // Object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!(options && options.objectMode)\n  if (isDuplex) this.objectMode = this.objectMode || !!(options && options.writableObjectMode)\n\n  // 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  this.highWaterMark = options\n    ? getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex)\n    : getDefaultHighWaterMark(false)\n\n  // if _final has been called.\n  this.finalCalled = false\n\n  // drain event flag.\n  this.needDrain = false\n  // At the start of calling end()\n  this.ending = false\n  // When end() has been called, and returned.\n  this.ended = false\n  // When 'finish' is emitted.\n  this.finished = false\n\n  // Has it been destroyed\n  this.destroyed = false\n\n  // 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  const noDecode = !!(options && options.decodeStrings === false)\n  this.decodeStrings = !noDecode\n\n  // 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  this.defaultEncoding = (options && options.defaultEncoding) || 'utf8'\n\n  // 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  this.length = 0\n\n  // A flag to see when we're in the middle of a write.\n  this.writing = false\n\n  // When true all writes will be buffered until .uncork() call.\n  this.corked = 0\n\n  // 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  this.sync = true\n\n  // 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  this.bufferProcessing = false\n\n  // The callback that's passed to _write(chunk, cb).\n  this.onwrite = onwrite.bind(undefined, stream)\n\n  // The callback that the user supplies to write(chunk, encoding, cb).\n  this.writecb = null\n\n  // The amount that is being written when _write is called.\n  this.writelen = 0\n\n  // Storage for data passed to the afterWrite() callback in case of\n  // synchronous _write() completion.\n  this.afterWriteTickInfo = null\n  resetBuffer(this)\n\n  // Number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted.\n  this.pendingcb = 0\n\n  // Stream is still being constructed and cannot be\n  // destroyed until construction finished or failed.\n  // Async construction is opt in, therefore we start as\n  // constructed.\n  this.constructed = true\n\n  // Emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams.\n  this.prefinished = false\n\n  // True if the error was already emitted and should not be thrown again.\n  this.errorEmitted = false\n\n  // Should close be emitted on destroy. Defaults to true.\n  this.emitClose = !options || options.emitClose !== false\n\n  // Should .destroy() be called after 'finish' (and potentially 'end').\n  this.autoDestroy = !options || options.autoDestroy !== false\n\n  // Indicates whether the stream has errored. When true all write() calls\n  // should return false. This is needed since when autoDestroy\n  // is disabled we need a way to tell whether the stream has failed.\n  this.errored = null\n\n  // Indicates whether the stream has finished destroying.\n  this.closed = false\n\n  // True if close has been emitted or would have been emitted\n  // depending on emitClose.\n  this.closeEmitted = false\n  this[kOnFinished] = []\n}\nfunction resetBuffer(state) {\n  state.buffered = []\n  state.bufferedIndex = 0\n  state.allBuffers = true\n  state.allNoop = true\n}\nWritableState.prototype.getBuffer = function getBuffer() {\n  return ArrayPrototypeSlice(this.buffered, this.bufferedIndex)\n}\nObjectDefineProperty(WritableState.prototype, 'bufferedRequestCount', {\n  __proto__: null,\n  get() {\n    return this.buffered.length - this.bufferedIndex\n  }\n})\nfunction Writable(options) {\n  // 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\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\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the WritableState constructor, at least with V8 6.5.\n  const isDuplex = this instanceof require('./duplex')\n  if (!isDuplex && !FunctionPrototypeSymbolHasInstance(Writable, this)) return new Writable(options)\n  this._writableState = new WritableState(options, this, isDuplex)\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    if (typeof options.construct === 'function') this._construct = options.construct\n    if (options.signal) addAbortSignal(options.signal, this)\n  }\n  Stream.call(this, options)\n  destroyImpl.construct(this, () => {\n    const state = this._writableState\n    if (!state.writing) {\n      clearBuffer(this, state)\n    }\n    finishMaybe(this, state)\n  })\n}\nObjectDefineProperty(Writable, SymbolHasInstance, {\n  __proto__: null,\n  value: function (object) {\n    if (FunctionPrototypeSymbolHasInstance(this, object)) return true\n    if (this !== Writable) return false\n    return object && object._writableState instanceof WritableState\n  }\n})\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE())\n}\nfunction _write(stream, chunk, encoding, cb) {\n  const state = stream._writableState\n  if (typeof encoding === 'function') {\n    cb = encoding\n    encoding = state.defaultEncoding\n  } else {\n    if (!encoding) encoding = state.defaultEncoding\n    else if (encoding !== 'buffer' && !Buffer.isEncoding(encoding)) throw new ERR_UNKNOWN_ENCODING(encoding)\n    if (typeof cb !== 'function') cb = nop\n  }\n  if (chunk === null) {\n    throw new ERR_STREAM_NULL_VALUES()\n  } else if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      if (state.decodeStrings !== false) {\n        chunk = Buffer.from(chunk, encoding)\n        encoding = 'buffer'\n      }\n    } else if (chunk instanceof Buffer) {\n      encoding = 'buffer'\n    } else if (Stream._isUint8Array(chunk)) {\n      chunk = Stream._uint8ArrayToBuffer(chunk)\n      encoding = 'buffer'\n    } else {\n      throw new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk)\n    }\n  }\n  let err\n  if (state.ending) {\n    err = new ERR_STREAM_WRITE_AFTER_END()\n  } else if (state.destroyed) {\n    err = new ERR_STREAM_DESTROYED('write')\n  }\n  if (err) {\n    process.nextTick(cb, err)\n    errorOrDestroy(stream, err, true)\n    return err\n  }\n  state.pendingcb++\n  return writeOrBuffer(stream, state, chunk, encoding, cb)\n}\nWritable.prototype.write = function (chunk, encoding, cb) {\n  return _write(this, chunk, encoding, cb) === true\n}\nWritable.prototype.cork = function () {\n  this._writableState.corked++\n}\nWritable.prototype.uncork = function () {\n  const state = this._writableState\n  if (state.corked) {\n    state.corked--\n    if (!state.writing) clearBuffer(this, state)\n  }\n}\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = StringPrototypeToLowerCase(encoding)\n  if (!Buffer.isEncoding(encoding)) throw new ERR_UNKNOWN_ENCODING(encoding)\n  this._writableState.defaultEncoding = encoding\n  return this\n}\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.\nfunction writeOrBuffer(stream, state, chunk, encoding, callback) {\n  const len = state.objectMode ? 1 : chunk.length\n  state.length += len\n\n  // stream._write resets state.length\n  const ret = state.length < state.highWaterMark\n  // We must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true\n  if (state.writing || state.corked || state.errored || !state.constructed) {\n    state.buffered.push({\n      chunk,\n      encoding,\n      callback\n    })\n    if (state.allBuffers && encoding !== 'buffer') {\n      state.allBuffers = false\n    }\n    if (state.allNoop && callback !== nop) {\n      state.allNoop = false\n    }\n  } else {\n    state.writelen = len\n    state.writecb = callback\n    state.writing = true\n    state.sync = true\n    stream._write(chunk, encoding, state.onwrite)\n    state.sync = false\n  }\n\n  // Return false if errored or destroyed in order to break\n  // any synchronous while(stream.write(data)) loops.\n  return ret && !state.errored && !state.destroyed\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'))\n  else if (writev) stream._writev(chunk, state.onwrite)\n  else stream._write(chunk, encoding, state.onwrite)\n  state.sync = false\n}\nfunction onwriteError(stream, state, er, cb) {\n  --state.pendingcb\n  cb(er)\n  // Ensure callbacks are invoked even when autoDestroy is\n  // not enabled. Passing `er` here doesn't make sense since\n  // it's related to one specific write, not to the buffered\n  // writes.\n  errorBuffer(state)\n  // This can emit error, but error must always follow cb.\n  errorOrDestroy(stream, er)\n}\nfunction onwrite(stream, er) {\n  const state = stream._writableState\n  const sync = state.sync\n  const cb = state.writecb\n  if (typeof cb !== 'function') {\n    errorOrDestroy(stream, new ERR_MULTIPLE_CALLBACK())\n    return\n  }\n  state.writing = false\n  state.writecb = null\n  state.length -= state.writelen\n  state.writelen = 0\n  if (er) {\n    // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364\n    er.stack // eslint-disable-line no-unused-expressions\n\n    if (!state.errored) {\n      state.errored = er\n    }\n\n    // In case of duplex streams we need to notify the readable side of the\n    // error.\n    if (stream._readableState && !stream._readableState.errored) {\n      stream._readableState.errored = er\n    }\n    if (sync) {\n      process.nextTick(onwriteError, stream, state, er, cb)\n    } else {\n      onwriteError(stream, state, er, cb)\n    }\n  } else {\n    if (state.buffered.length > state.bufferedIndex) {\n      clearBuffer(stream, state)\n    }\n    if (sync) {\n      // It is a common case that the callback passed to .write() is always\n      // the same. In that case, we do not schedule a new nextTick(), but\n      // rather just increase a counter, to improve performance and avoid\n      // memory allocations.\n      if (state.afterWriteTickInfo !== null && state.afterWriteTickInfo.cb === cb) {\n        state.afterWriteTickInfo.count++\n      } else {\n        state.afterWriteTickInfo = {\n          count: 1,\n          cb,\n          stream,\n          state\n        }\n        process.nextTick(afterWriteTick, state.afterWriteTickInfo)\n      }\n    } else {\n      afterWrite(stream, state, 1, cb)\n    }\n  }\n}\nfunction afterWriteTick({ stream, state, count, cb }) {\n  state.afterWriteTickInfo = null\n  return afterWrite(stream, state, count, cb)\n}\nfunction afterWrite(stream, state, count, cb) {\n  const needDrain = !state.ending && !stream.destroyed && state.length === 0 && state.needDrain\n  if (needDrain) {\n    state.needDrain = false\n    stream.emit('drain')\n  }\n  while (count-- > 0) {\n    state.pendingcb--\n    cb()\n  }\n  if (state.destroyed) {\n    errorBuffer(state)\n  }\n  finishMaybe(stream, state)\n}\n\n// If there's something in the buffer waiting, then invoke callbacks.\nfunction errorBuffer(state) {\n  if (state.writing) {\n    return\n  }\n  for (let n = state.bufferedIndex; n < state.buffered.length; ++n) {\n    var _state$errored\n    const { chunk, callback } = state.buffered[n]\n    const len = state.objectMode ? 1 : chunk.length\n    state.length -= len\n    callback(\n      (_state$errored = state.errored) !== null && _state$errored !== undefined\n        ? _state$errored\n        : new ERR_STREAM_DESTROYED('write')\n    )\n  }\n  const onfinishCallbacks = state[kOnFinished].splice(0)\n  for (let i = 0; i < onfinishCallbacks.length; i++) {\n    var _state$errored2\n    onfinishCallbacks[i](\n      (_state$errored2 = state.errored) !== null && _state$errored2 !== undefined\n        ? _state$errored2\n        : new ERR_STREAM_DESTROYED('end')\n    )\n  }\n  resetBuffer(state)\n}\n\n// If there's something in the buffer waiting, then process it.\nfunction clearBuffer(stream, state) {\n  if (state.corked || state.bufferProcessing || state.destroyed || !state.constructed) {\n    return\n  }\n  const { buffered, bufferedIndex, objectMode } = state\n  const bufferedLength = buffered.length - bufferedIndex\n  if (!bufferedLength) {\n    return\n  }\n  let i = bufferedIndex\n  state.bufferProcessing = true\n  if (bufferedLength > 1 && stream._writev) {\n    state.pendingcb -= bufferedLength - 1\n    const callback = state.allNoop\n      ? nop\n      : (err) => {\n          for (let n = i; n < buffered.length; ++n) {\n            buffered[n].callback(err)\n          }\n        }\n    // Make a copy of `buffered` if it's going to be used by `callback` above,\n    // since `doWrite` will mutate the array.\n    const chunks = state.allNoop && i === 0 ? buffered : ArrayPrototypeSlice(buffered, i)\n    chunks.allBuffers = state.allBuffers\n    doWrite(stream, state, true, state.length, chunks, '', callback)\n    resetBuffer(state)\n  } else {\n    do {\n      const { chunk, encoding, callback } = buffered[i]\n      buffered[i++] = null\n      const len = objectMode ? 1 : chunk.length\n      doWrite(stream, state, false, len, chunk, encoding, callback)\n    } while (i < buffered.length && !state.writing)\n    if (i === buffered.length) {\n      resetBuffer(state)\n    } else if (i > 256) {\n      buffered.splice(0, i)\n      state.bufferedIndex = 0\n    } else {\n      state.bufferedIndex = i\n    }\n  }\n  state.bufferProcessing = false\n}\nWritable.prototype._write = function (chunk, encoding, cb) {\n  if (this._writev) {\n    this._writev(\n      [\n        {\n          chunk,\n          encoding\n        }\n      ],\n      cb\n    )\n  } else {\n    throw new ERR_METHOD_NOT_IMPLEMENTED('_write()')\n  }\n}\nWritable.prototype._writev = null\nWritable.prototype.end = function (chunk, encoding, cb) {\n  const state = this._writableState\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  let err\n  if (chunk !== null && chunk !== undefined) {\n    const ret = _write(this, chunk, encoding)\n    if (ret instanceof Error) {\n      err = ret\n    }\n  }\n\n  // .end() fully uncorks.\n  if (state.corked) {\n    state.corked = 1\n    this.uncork()\n  }\n  if (err) {\n    // Do nothing...\n  } else if (!state.errored && !state.ending) {\n    // This is forgiving in terms of unnecessary calls to end() and can hide\n    // logic errors. However, usually such errors are harmless and causing a\n    // hard error can be disproportionately destructive. It is not always\n    // trivial for the user to determine whether end() needs to be called\n    // or not.\n\n    state.ending = true\n    finishMaybe(this, state, true)\n    state.ended = true\n  } else if (state.finished) {\n    err = new ERR_STREAM_ALREADY_FINISHED('end')\n  } else if (state.destroyed) {\n    err = new ERR_STREAM_DESTROYED('end')\n  }\n  if (typeof cb === 'function') {\n    if (err || state.finished) {\n      process.nextTick(cb, err)\n    } else {\n      state[kOnFinished].push(cb)\n    }\n  }\n  return this\n}\nfunction needFinish(state) {\n  return (\n    state.ending &&\n    !state.destroyed &&\n    state.constructed &&\n    state.length === 0 &&\n    !state.errored &&\n    state.buffered.length === 0 &&\n    !state.finished &&\n    !state.writing &&\n    !state.errorEmitted &&\n    !state.closeEmitted\n  )\n}\nfunction callFinal(stream, state) {\n  let called = false\n  function onFinish(err) {\n    if (called) {\n      errorOrDestroy(stream, err !== null && err !== undefined ? err : ERR_MULTIPLE_CALLBACK())\n      return\n    }\n    called = true\n    state.pendingcb--\n    if (err) {\n      const onfinishCallbacks = state[kOnFinished].splice(0)\n      for (let i = 0; i < onfinishCallbacks.length; i++) {\n        onfinishCallbacks[i](err)\n      }\n      errorOrDestroy(stream, err, state.sync)\n    } else if (needFinish(state)) {\n      state.prefinished = true\n      stream.emit('prefinish')\n      // Backwards compat. Don't check state.sync here.\n      // Some streams assume 'finish' will be emitted\n      // asynchronously relative to _final callback.\n      state.pendingcb++\n      process.nextTick(finish, stream, state)\n    }\n  }\n  state.sync = true\n  state.pendingcb++\n  try {\n    stream._final(onFinish)\n  } catch (err) {\n    onFinish(err)\n  }\n  state.sync = false\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function' && !state.destroyed) {\n      state.finalCalled = true\n      callFinal(stream, state)\n    } else {\n      state.prefinished = true\n      stream.emit('prefinish')\n    }\n  }\n}\nfunction finishMaybe(stream, state, sync) {\n  if (needFinish(state)) {\n    prefinish(stream, state)\n    if (state.pendingcb === 0) {\n      if (sync) {\n        state.pendingcb++\n        process.nextTick(\n          (stream, state) => {\n            if (needFinish(state)) {\n              finish(stream, state)\n            } else {\n              state.pendingcb--\n            }\n          },\n          stream,\n          state\n        )\n      } else if (needFinish(state)) {\n        state.pendingcb++\n        finish(stream, state)\n      }\n    }\n  }\n}\nfunction finish(stream, state) {\n  state.pendingcb--\n  state.finished = true\n  const onfinishCallbacks = state[kOnFinished].splice(0)\n  for (let i = 0; i < onfinishCallbacks.length; i++) {\n    onfinishCallbacks[i]()\n  }\n  stream.emit('finish')\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    const rState = stream._readableState\n    const autoDestroy =\n      !rState ||\n      (rState.autoDestroy &&\n        // We don't expect the readable to ever 'end'\n        // if readable is explicitly set to false.\n        (rState.endEmitted || rState.readable === false))\n    if (autoDestroy) {\n      stream.destroy()\n    }\n  }\n}\nObjectDefineProperties(Writable.prototype, {\n  closed: {\n    __proto__: null,\n    get() {\n      return this._writableState ? this._writableState.closed : false\n    }\n  },\n  destroyed: {\n    __proto__: null,\n    get() {\n      return this._writableState ? this._writableState.destroyed : false\n    },\n    set(value) {\n      // Backward compatibility, the user is explicitly managing destroyed.\n      if (this._writableState) {\n        this._writableState.destroyed = value\n      }\n    }\n  },\n  writable: {\n    __proto__: null,\n    get() {\n      const w = this._writableState\n      // w.writable === false means that this is part of a Duplex stream\n      // where the writable side was disabled upon construction.\n      // Compat. The user might manually disable writable side through\n      // deprecated setter.\n      return !!w && w.writable !== false && !w.destroyed && !w.errored && !w.ending && !w.ended\n    },\n    set(val) {\n      // Backwards compatible.\n      if (this._writableState) {\n        this._writableState.writable = !!val\n      }\n    }\n  },\n  writableFinished: {\n    __proto__: null,\n    get() {\n      return this._writableState ? this._writableState.finished : false\n    }\n  },\n  writableObjectMode: {\n    __proto__: null,\n    get() {\n      return this._writableState ? this._writableState.objectMode : false\n    }\n  },\n  writableBuffer: {\n    __proto__: null,\n    get() {\n      return this._writableState && this._writableState.getBuffer()\n    }\n  },\n  writableEnded: {\n    __proto__: null,\n    get() {\n      return this._writableState ? this._writableState.ending : false\n    }\n  },\n  writableNeedDrain: {\n    __proto__: null,\n    get() {\n      const wState = this._writableState\n      if (!wState) return false\n      return !wState.destroyed && !wState.ending && wState.needDrain\n    }\n  },\n  writableHighWaterMark: {\n    __proto__: null,\n    get() {\n      return this._writableState && this._writableState.highWaterMark\n    }\n  },\n  writableCorked: {\n    __proto__: null,\n    get() {\n      return this._writableState ? this._writableState.corked : 0\n    }\n  },\n  writableLength: {\n    __proto__: null,\n    get() {\n      return this._writableState && this._writableState.length\n    }\n  },\n  errored: {\n    __proto__: null,\n    enumerable: false,\n    get() {\n      return this._writableState ? this._writableState.errored : null\n    }\n  },\n  writableAborted: {\n    __proto__: null,\n    enumerable: false,\n    get: function () {\n      return !!(\n        this._writableState.writable !== false &&\n        (this._writableState.destroyed || this._writableState.errored) &&\n        !this._writableState.finished\n      )\n    }\n  }\n})\nconst destroy = destroyImpl.destroy\nWritable.prototype.destroy = function (err, cb) {\n  const state = this._writableState\n\n  // Invoke pending callbacks.\n  if (!state.destroyed && (state.bufferedIndex < state.buffered.length || state[kOnFinished].length)) {\n    process.nextTick(errorBuffer, state)\n  }\n  destroy.call(this, err, cb)\n  return this\n}\nWritable.prototype._undestroy = destroyImpl.undestroy\nWritable.prototype._destroy = function (err, cb) {\n  cb(err)\n}\nWritable.prototype[EE.captureRejectionSymbol] = function (err) {\n  this.destroy(err)\n}\nlet webStreamsAdapters\n\n// Lazy to avoid circular references\nfunction lazyWebStreams() {\n  if (webStreamsAdapters === undefined) webStreamsAdapters = {}\n  return webStreamsAdapters\n}\nWritable.fromWeb = function (writableStream, options) {\n  return lazyWebStreams().newStreamWritableFromWritableStream(writableStream, options)\n}\nWritable.toWeb = function (streamWritable) {\n  return lazyWebStreams().newWritableStreamFromStreamWritable(streamWritable)\n}\n","'use strict'\n\nconst {\n  ArrayIsArray,\n  ArrayPrototypeIncludes,\n  ArrayPrototypeJoin,\n  ArrayPrototypeMap,\n  NumberIsInteger,\n  NumberIsNaN,\n  NumberMAX_SAFE_INTEGER,\n  NumberMIN_SAFE_INTEGER,\n  NumberParseInt,\n  ObjectPrototypeHasOwnProperty,\n  RegExpPrototypeExec,\n  String,\n  StringPrototypeToUpperCase,\n  StringPrototypeTrim\n} = require('../ours/primordials')\nconst {\n  hideStackFrames,\n  codes: { ERR_SOCKET_BAD_PORT, ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, ERR_OUT_OF_RANGE, ERR_UNKNOWN_SIGNAL }\n} = require('../ours/errors')\nconst { normalizeEncoding } = require('../ours/util')\nconst { isAsyncFunction, isArrayBufferView } = require('../ours/util').types\nconst signals = {}\n\n/**\n * @param {*} value\n * @returns {boolean}\n */\nfunction isInt32(value) {\n  return value === (value | 0)\n}\n\n/**\n * @param {*} value\n * @returns {boolean}\n */\nfunction isUint32(value) {\n  return value === value >>> 0\n}\nconst octalReg = /^[0-7]+$/\nconst modeDesc = 'must be a 32-bit unsigned integer or an octal string'\n\n/**\n * Parse and validate values that will be converted into mode_t (the S_*\n * constants). Only valid numbers and octal strings are allowed. They could be\n * converted to 32-bit unsigned integers or non-negative signed integers in the\n * C++ land, but any value higher than 0o777 will result in platform-specific\n * behaviors.\n *\n * @param {*} value Values to be validated\n * @param {string} name Name of the argument\n * @param {number} [def] If specified, will be returned for invalid values\n * @returns {number}\n */\nfunction parseFileMode(value, name, def) {\n  if (typeof value === 'undefined') {\n    value = def\n  }\n  if (typeof value === 'string') {\n    if (RegExpPrototypeExec(octalReg, value) === null) {\n      throw new ERR_INVALID_ARG_VALUE(name, value, modeDesc)\n    }\n    value = NumberParseInt(value, 8)\n  }\n  validateUint32(value, name)\n  return value\n}\n\n/**\n * @callback validateInteger\n * @param {*} value\n * @param {string} name\n * @param {number} [min]\n * @param {number} [max]\n * @returns {asserts value is number}\n */\n\n/** @type {validateInteger} */\nconst validateInteger = hideStackFrames((value, name, min = NumberMIN_SAFE_INTEGER, max = NumberMAX_SAFE_INTEGER) => {\n  if (typeof value !== 'number') throw new ERR_INVALID_ARG_TYPE(name, 'number', value)\n  if (!NumberIsInteger(value)) throw new ERR_OUT_OF_RANGE(name, 'an integer', value)\n  if (value < min || value > max) throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value)\n})\n\n/**\n * @callback validateInt32\n * @param {*} value\n * @param {string} name\n * @param {number} [min]\n * @param {number} [max]\n * @returns {asserts value is number}\n */\n\n/** @type {validateInt32} */\nconst validateInt32 = hideStackFrames((value, name, min = -2147483648, max = 2147483647) => {\n  // The defaults for min and max correspond to the limits of 32-bit integers.\n  if (typeof value !== 'number') {\n    throw new ERR_INVALID_ARG_TYPE(name, 'number', value)\n  }\n  if (!NumberIsInteger(value)) {\n    throw new ERR_OUT_OF_RANGE(name, 'an integer', value)\n  }\n  if (value < min || value > max) {\n    throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value)\n  }\n})\n\n/**\n * @callback validateUint32\n * @param {*} value\n * @param {string} name\n * @param {number|boolean} [positive=false]\n * @returns {asserts value is number}\n */\n\n/** @type {validateUint32} */\nconst validateUint32 = hideStackFrames((value, name, positive = false) => {\n  if (typeof value !== 'number') {\n    throw new ERR_INVALID_ARG_TYPE(name, 'number', value)\n  }\n  if (!NumberIsInteger(value)) {\n    throw new ERR_OUT_OF_RANGE(name, 'an integer', value)\n  }\n  const min = positive ? 1 : 0\n  // 2 ** 32 === 4294967296\n  const max = 4294967295\n  if (value < min || value > max) {\n    throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value)\n  }\n})\n\n/**\n * @callback validateString\n * @param {*} value\n * @param {string} name\n * @returns {asserts value is string}\n */\n\n/** @type {validateString} */\nfunction validateString(value, name) {\n  if (typeof value !== 'string') throw new ERR_INVALID_ARG_TYPE(name, 'string', value)\n}\n\n/**\n * @callback validateNumber\n * @param {*} value\n * @param {string} name\n * @param {number} [min]\n * @param {number} [max]\n * @returns {asserts value is number}\n */\n\n/** @type {validateNumber} */\nfunction validateNumber(value, name, min = undefined, max) {\n  if (typeof value !== 'number') throw new ERR_INVALID_ARG_TYPE(name, 'number', value)\n  if (\n    (min != null && value < min) ||\n    (max != null && value > max) ||\n    ((min != null || max != null) && NumberIsNaN(value))\n  ) {\n    throw new ERR_OUT_OF_RANGE(\n      name,\n      `${min != null ? `>= ${min}` : ''}${min != null && max != null ? ' && ' : ''}${max != null ? `<= ${max}` : ''}`,\n      value\n    )\n  }\n}\n\n/**\n * @callback validateOneOf\n * @template T\n * @param {T} value\n * @param {string} name\n * @param {T[]} oneOf\n */\n\n/** @type {validateOneOf} */\nconst validateOneOf = hideStackFrames((value, name, oneOf) => {\n  if (!ArrayPrototypeIncludes(oneOf, value)) {\n    const allowed = ArrayPrototypeJoin(\n      ArrayPrototypeMap(oneOf, (v) => (typeof v === 'string' ? `'${v}'` : String(v))),\n      ', '\n    )\n    const reason = 'must be one of: ' + allowed\n    throw new ERR_INVALID_ARG_VALUE(name, value, reason)\n  }\n})\n\n/**\n * @callback validateBoolean\n * @param {*} value\n * @param {string} name\n * @returns {asserts value is boolean}\n */\n\n/** @type {validateBoolean} */\nfunction validateBoolean(value, name) {\n  if (typeof value !== 'boolean') throw new ERR_INVALID_ARG_TYPE(name, 'boolean', value)\n}\nfunction getOwnPropertyValueOrDefault(options, key, defaultValue) {\n  return options == null || !ObjectPrototypeHasOwnProperty(options, key) ? defaultValue : options[key]\n}\n\n/**\n * @callback validateObject\n * @param {*} value\n * @param {string} name\n * @param {{\n *   allowArray?: boolean,\n *   allowFunction?: boolean,\n *   nullable?: boolean\n * }} [options]\n */\n\n/** @type {validateObject} */\nconst validateObject = hideStackFrames((value, name, options = null) => {\n  const allowArray = getOwnPropertyValueOrDefault(options, 'allowArray', false)\n  const allowFunction = getOwnPropertyValueOrDefault(options, 'allowFunction', false)\n  const nullable = getOwnPropertyValueOrDefault(options, 'nullable', false)\n  if (\n    (!nullable && value === null) ||\n    (!allowArray && ArrayIsArray(value)) ||\n    (typeof value !== 'object' && (!allowFunction || typeof value !== 'function'))\n  ) {\n    throw new ERR_INVALID_ARG_TYPE(name, 'Object', value)\n  }\n})\n\n/**\n * @callback validateArray\n * @param {*} value\n * @param {string} name\n * @param {number} [minLength]\n * @returns {asserts value is any[]}\n */\n\n/** @type {validateArray} */\nconst validateArray = hideStackFrames((value, name, minLength = 0) => {\n  if (!ArrayIsArray(value)) {\n    throw new ERR_INVALID_ARG_TYPE(name, 'Array', value)\n  }\n  if (value.length < minLength) {\n    const reason = `must be longer than ${minLength}`\n    throw new ERR_INVALID_ARG_VALUE(name, value, reason)\n  }\n})\n\n// eslint-disable-next-line jsdoc/require-returns-check\n/**\n * @param {*} signal\n * @param {string} [name='signal']\n * @returns {asserts signal is keyof signals}\n */\nfunction validateSignalName(signal, name = 'signal') {\n  validateString(signal, name)\n  if (signals[signal] === undefined) {\n    if (signals[StringPrototypeToUpperCase(signal)] !== undefined) {\n      throw new ERR_UNKNOWN_SIGNAL(signal + ' (signals must use all capital letters)')\n    }\n    throw new ERR_UNKNOWN_SIGNAL(signal)\n  }\n}\n\n/**\n * @callback validateBuffer\n * @param {*} buffer\n * @param {string} [name='buffer']\n * @returns {asserts buffer is ArrayBufferView}\n */\n\n/** @type {validateBuffer} */\nconst validateBuffer = hideStackFrames((buffer, name = 'buffer') => {\n  if (!isArrayBufferView(buffer)) {\n    throw new ERR_INVALID_ARG_TYPE(name, ['Buffer', 'TypedArray', 'DataView'], buffer)\n  }\n})\n\n/**\n * @param {string} data\n * @param {string} encoding\n */\nfunction validateEncoding(data, encoding) {\n  const normalizedEncoding = normalizeEncoding(encoding)\n  const length = data.length\n  if (normalizedEncoding === 'hex' && length % 2 !== 0) {\n    throw new ERR_INVALID_ARG_VALUE('encoding', encoding, `is invalid for data of length ${length}`)\n  }\n}\n\n/**\n * Check that the port number is not NaN when coerced to a number,\n * is an integer and that it falls within the legal range of port numbers.\n * @param {*} port\n * @param {string} [name='Port']\n * @param {boolean} [allowZero=true]\n * @returns {number}\n */\nfunction validatePort(port, name = 'Port', allowZero = true) {\n  if (\n    (typeof port !== 'number' && typeof port !== 'string') ||\n    (typeof port === 'string' && StringPrototypeTrim(port).length === 0) ||\n    +port !== +port >>> 0 ||\n    port > 0xffff ||\n    (port === 0 && !allowZero)\n  ) {\n    throw new ERR_SOCKET_BAD_PORT(name, port, allowZero)\n  }\n  return port | 0\n}\n\n/**\n * @callback validateAbortSignal\n * @param {*} signal\n * @param {string} name\n */\n\n/** @type {validateAbortSignal} */\nconst validateAbortSignal = hideStackFrames((signal, name) => {\n  if (signal !== undefined && (signal === null || typeof signal !== 'object' || !('aborted' in signal))) {\n    throw new ERR_INVALID_ARG_TYPE(name, 'AbortSignal', signal)\n  }\n})\n\n/**\n * @callback validateFunction\n * @param {*} value\n * @param {string} name\n * @returns {asserts value is Function}\n */\n\n/** @type {validateFunction} */\nconst validateFunction = hideStackFrames((value, name) => {\n  if (typeof value !== 'function') throw new ERR_INVALID_ARG_TYPE(name, 'Function', value)\n})\n\n/**\n * @callback validatePlainFunction\n * @param {*} value\n * @param {string} name\n * @returns {asserts value is Function}\n */\n\n/** @type {validatePlainFunction} */\nconst validatePlainFunction = hideStackFrames((value, name) => {\n  if (typeof value !== 'function' || isAsyncFunction(value)) throw new ERR_INVALID_ARG_TYPE(name, 'Function', value)\n})\n\n/**\n * @callback validateUndefined\n * @param {*} value\n * @param {string} name\n * @returns {asserts value is undefined}\n */\n\n/** @type {validateUndefined} */\nconst validateUndefined = hideStackFrames((value, name) => {\n  if (value !== undefined) throw new ERR_INVALID_ARG_TYPE(name, 'undefined', value)\n})\n\n/**\n * @template T\n * @param {T} value\n * @param {string} name\n * @param {T[]} union\n */\nfunction validateUnion(value, name, union) {\n  if (!ArrayPrototypeIncludes(union, value)) {\n    throw new ERR_INVALID_ARG_TYPE(name, `('${ArrayPrototypeJoin(union, '|')}')`, value)\n  }\n}\nmodule.exports = {\n  isInt32,\n  isUint32,\n  parseFileMode,\n  validateArray,\n  validateBoolean,\n  validateBuffer,\n  validateEncoding,\n  validateFunction,\n  validateInt32,\n  validateInteger,\n  validateNumber,\n  validateObject,\n  validateOneOf,\n  validatePlainFunction,\n  validatePort,\n  validateSignalName,\n  validateString,\n  validateUint32,\n  validateUndefined,\n  validateUnion,\n  validateAbortSignal\n}\n","'use strict'\n\nconst CustomStream = require('../stream')\nconst promises = require('../stream/promises')\nconst originalDestroy = CustomStream.Readable.destroy\nmodule.exports = CustomStream.Readable\n\n// Explicit export naming is needed for ESM\nmodule.exports._uint8ArrayToBuffer = CustomStream._uint8ArrayToBuffer\nmodule.exports._isUint8Array = CustomStream._isUint8Array\nmodule.exports.isDisturbed = CustomStream.isDisturbed\nmodule.exports.isErrored = CustomStream.isErrored\nmodule.exports.isReadable = CustomStream.isReadable\nmodule.exports.Readable = CustomStream.Readable\nmodule.exports.Writable = CustomStream.Writable\nmodule.exports.Duplex = CustomStream.Duplex\nmodule.exports.Transform = CustomStream.Transform\nmodule.exports.PassThrough = CustomStream.PassThrough\nmodule.exports.addAbortSignal = CustomStream.addAbortSignal\nmodule.exports.finished = CustomStream.finished\nmodule.exports.destroy = CustomStream.destroy\nmodule.exports.destroy = originalDestroy\nmodule.exports.pipeline = CustomStream.pipeline\nmodule.exports.compose = CustomStream.compose\nObject.defineProperty(CustomStream, 'promises', {\n  configurable: true,\n  enumerable: true,\n  get() {\n    return promises\n  }\n})\nmodule.exports.Stream = CustomStream.Stream\n\n// Allow default importing\nmodule.exports.default = module.exports\n","'use strict'\n\nconst { format, inspect, AggregateError: CustomAggregateError } = require('./util')\n\n/*\n  This file is a reduced and adapted version of the main lib/internal/errors.js file defined at\n\n  https://github.com/nodejs/node/blob/master/lib/internal/errors.js\n\n  Don't try to replace with the original file and keep it up to date (starting from E(...) definitions)\n  with the upstream file.\n*/\n\nconst AggregateError = globalThis.AggregateError || CustomAggregateError\nconst kIsNodeError = Symbol('kIsNodeError')\nconst kTypes = [\n  'string',\n  'function',\n  'number',\n  'object',\n  // Accept 'Function' and 'Object' as alternative to the lower cased version.\n  'Function',\n  'Object',\n  'boolean',\n  'bigint',\n  'symbol'\n]\nconst classRegExp = /^([A-Z][a-z0-9]*)+$/\nconst nodeInternalPrefix = '__node_internal_'\nconst codes = {}\nfunction assert(value, message) {\n  if (!value) {\n    throw new codes.ERR_INTERNAL_ASSERTION(message)\n  }\n}\n\n// Only use this for integers! Decimal numbers do not work with this function.\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}\nfunction getMessage(key, msg, args) {\n  if (typeof msg === 'function') {\n    assert(\n      msg.length <= args.length,\n      // Default options do not count.\n      `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${msg.length}).`\n    )\n    return msg(...args)\n  }\n  const expectedLength = (msg.match(/%[dfijoOs]/g) || []).length\n  assert(\n    expectedLength === args.length,\n    `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`\n  )\n  if (args.length === 0) {\n    return msg\n  }\n  return format(msg, ...args)\n}\nfunction E(code, message, Base) {\n  if (!Base) {\n    Base = Error\n  }\n  class NodeError extends Base {\n    constructor(...args) {\n      super(getMessage(code, message, args))\n    }\n    toString() {\n      return `${this.name} [${code}]: ${this.message}`\n    }\n  }\n  Object.defineProperties(NodeError.prototype, {\n    name: {\n      value: Base.name,\n      writable: true,\n      enumerable: false,\n      configurable: true\n    },\n    toString: {\n      value() {\n        return `${this.name} [${code}]: ${this.message}`\n      },\n      writable: true,\n      enumerable: false,\n      configurable: true\n    }\n  })\n  NodeError.prototype.code = code\n  NodeError.prototype[kIsNodeError] = true\n  codes[code] = NodeError\n}\nfunction hideStackFrames(fn) {\n  // We rename the functions that will be hidden to cut off the stacktrace\n  // at the outermost one\n  const hidden = nodeInternalPrefix + fn.name\n  Object.defineProperty(fn, 'name', {\n    value: hidden\n  })\n  return fn\n}\nfunction aggregateTwoErrors(innerError, outerError) {\n  if (innerError && outerError && innerError !== outerError) {\n    if (Array.isArray(outerError.errors)) {\n      // If `outerError` is already an `AggregateError`.\n      outerError.errors.push(innerError)\n      return outerError\n    }\n    const err = new AggregateError([outerError, innerError], outerError.message)\n    err.code = outerError.code\n    return err\n  }\n  return innerError || outerError\n}\nclass AbortError extends Error {\n  constructor(message = 'The operation was aborted', options = undefined) {\n    if (options !== undefined && typeof options !== 'object') {\n      throw new codes.ERR_INVALID_ARG_TYPE('options', 'Object', options)\n    }\n    super(message, options)\n    this.code = 'ABORT_ERR'\n    this.name = 'AbortError'\n  }\n}\nE('ERR_ASSERTION', '%s', Error)\nE(\n  'ERR_INVALID_ARG_TYPE',\n  (name, expected, actual) => {\n    assert(typeof name === 'string', \"'name' must be a string\")\n    if (!Array.isArray(expected)) {\n      expected = [expected]\n    }\n    let msg = 'The '\n    if (name.endsWith(' argument')) {\n      // For cases like 'first argument'\n      msg += `${name} `\n    } else {\n      msg += `\"${name}\" ${name.includes('.') ? 'property' : 'argument'} `\n    }\n    msg += 'must be '\n    const types = []\n    const instances = []\n    const other = []\n    for (const value of expected) {\n      assert(typeof value === 'string', 'All expected entries have to be of type string')\n      if (kTypes.includes(value)) {\n        types.push(value.toLowerCase())\n      } else if (classRegExp.test(value)) {\n        instances.push(value)\n      } else {\n        assert(value !== 'object', 'The value \"object\" should be written as \"Object\"')\n        other.push(value)\n      }\n    }\n\n    // Special handle `object` in case other instances are allowed to outline\n    // the differences between each other.\n    if (instances.length > 0) {\n      const pos = types.indexOf('object')\n      if (pos !== -1) {\n        types.splice(types, pos, 1)\n        instances.push('Object')\n      }\n    }\n    if (types.length > 0) {\n      switch (types.length) {\n        case 1:\n          msg += `of type ${types[0]}`\n          break\n        case 2:\n          msg += `one of type ${types[0]} or ${types[1]}`\n          break\n        default: {\n          const last = types.pop()\n          msg += `one of type ${types.join(', ')}, or ${last}`\n        }\n      }\n      if (instances.length > 0 || other.length > 0) {\n        msg += ' or '\n      }\n    }\n    if (instances.length > 0) {\n      switch (instances.length) {\n        case 1:\n          msg += `an instance of ${instances[0]}`\n          break\n        case 2:\n          msg += `an instance of ${instances[0]} or ${instances[1]}`\n          break\n        default: {\n          const last = instances.pop()\n          msg += `an instance of ${instances.join(', ')}, or ${last}`\n        }\n      }\n      if (other.length > 0) {\n        msg += ' or '\n      }\n    }\n    switch (other.length) {\n      case 0:\n        break\n      case 1:\n        if (other[0].toLowerCase() !== other[0]) {\n          msg += 'an '\n        }\n        msg += `${other[0]}`\n        break\n      case 2:\n        msg += `one of ${other[0]} or ${other[1]}`\n        break\n      default: {\n        const last = other.pop()\n        msg += `one of ${other.join(', ')}, or ${last}`\n      }\n    }\n    if (actual == null) {\n      msg += `. Received ${actual}`\n    } else if (typeof actual === 'function' && actual.name) {\n      msg += `. Received function ${actual.name}`\n    } else if (typeof actual === 'object') {\n      var _actual$constructor\n      if (\n        (_actual$constructor = actual.constructor) !== null &&\n        _actual$constructor !== undefined &&\n        _actual$constructor.name\n      ) {\n        msg += `. Received an instance of ${actual.constructor.name}`\n      } else {\n        const inspected = inspect(actual, {\n          depth: -1\n        })\n        msg += `. Received ${inspected}`\n      }\n    } else {\n      let inspected = inspect(actual, {\n        colors: false\n      })\n      if (inspected.length > 25) {\n        inspected = `${inspected.slice(0, 25)}...`\n      }\n      msg += `. Received type ${typeof actual} (${inspected})`\n    }\n    return msg\n  },\n  TypeError\n)\nE(\n  'ERR_INVALID_ARG_VALUE',\n  (name, value, reason = 'is invalid') => {\n    let inspected = inspect(value)\n    if (inspected.length > 128) {\n      inspected = inspected.slice(0, 128) + '...'\n    }\n    const type = name.includes('.') ? 'property' : 'argument'\n    return `The ${type} '${name}' ${reason}. Received ${inspected}`\n  },\n  TypeError\n)\nE(\n  'ERR_INVALID_RETURN_VALUE',\n  (input, name, value) => {\n    var _value$constructor\n    const type =\n      value !== null &&\n      value !== undefined &&\n      (_value$constructor = value.constructor) !== null &&\n      _value$constructor !== undefined &&\n      _value$constructor.name\n        ? `instance of ${value.constructor.name}`\n        : `type ${typeof value}`\n    return `Expected ${input} to be returned from the \"${name}\"` + ` function but got ${type}.`\n  },\n  TypeError\n)\nE(\n  'ERR_MISSING_ARGS',\n  (...args) => {\n    assert(args.length > 0, 'At least one arg needs to be specified')\n    let msg\n    const len = args.length\n    args = (Array.isArray(args) ? args : [args]).map((a) => `\"${a}\"`).join(' or ')\n    switch (len) {\n      case 1:\n        msg += `The ${args[0]} argument`\n        break\n      case 2:\n        msg += `The ${args[0]} and ${args[1]} arguments`\n        break\n      default:\n        {\n          const last = args.pop()\n          msg += `The ${args.join(', ')}, and ${last} arguments`\n        }\n        break\n    }\n    return `${msg} must be specified`\n  },\n  TypeError\n)\nE(\n  'ERR_OUT_OF_RANGE',\n  (str, range, input) => {\n    assert(range, 'Missing \"range\" argument')\n    let received\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 > 2n ** 32n || input < -(2n ** 32n)) {\n        received = addNumericalSeparator(received)\n      }\n      received += 'n'\n    } else {\n      received = inspect(input)\n    }\n    return `The value of \"${str}\" is out of range. It must be ${range}. Received ${received}`\n  },\n  RangeError\n)\nE('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times', Error)\nE('ERR_METHOD_NOT_IMPLEMENTED', 'The %s method is not implemented', Error)\nE('ERR_STREAM_ALREADY_FINISHED', 'Cannot call %s after a stream was finished', Error)\nE('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable', Error)\nE('ERR_STREAM_DESTROYED', 'Cannot call %s after a stream was destroyed', Error)\nE('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError)\nE('ERR_STREAM_PREMATURE_CLOSE', 'Premature close', Error)\nE('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF', Error)\nE('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event', Error)\nE('ERR_STREAM_WRITE_AFTER_END', 'write after end', Error)\nE('ERR_UNKNOWN_ENCODING', 'Unknown encoding: %s', TypeError)\nmodule.exports = {\n  AbortError,\n  aggregateTwoErrors: hideStackFrames(aggregateTwoErrors),\n  hideStackFrames,\n  codes\n}\n","'use strict'\n\n/*\n  This file is a reduced and adapted version of the main lib/internal/per_context/primordials.js file defined at\n\n  https://github.com/nodejs/node/blob/master/lib/internal/per_context/primordials.js\n\n  Don't try to replace with the original file and keep it up to date with the upstream file.\n*/\nmodule.exports = {\n  ArrayIsArray(self) {\n    return Array.isArray(self)\n  },\n  ArrayPrototypeIncludes(self, el) {\n    return self.includes(el)\n  },\n  ArrayPrototypeIndexOf(self, el) {\n    return self.indexOf(el)\n  },\n  ArrayPrototypeJoin(self, sep) {\n    return self.join(sep)\n  },\n  ArrayPrototypeMap(self, fn) {\n    return self.map(fn)\n  },\n  ArrayPrototypePop(self, el) {\n    return self.pop(el)\n  },\n  ArrayPrototypePush(self, el) {\n    return self.push(el)\n  },\n  ArrayPrototypeSlice(self, start, end) {\n    return self.slice(start, end)\n  },\n  Error,\n  FunctionPrototypeCall(fn, thisArgs, ...args) {\n    return fn.call(thisArgs, ...args)\n  },\n  FunctionPrototypeSymbolHasInstance(self, instance) {\n    return Function.prototype[Symbol.hasInstance].call(self, instance)\n  },\n  MathFloor: Math.floor,\n  Number,\n  NumberIsInteger: Number.isInteger,\n  NumberIsNaN: Number.isNaN,\n  NumberMAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER,\n  NumberMIN_SAFE_INTEGER: Number.MIN_SAFE_INTEGER,\n  NumberParseInt: Number.parseInt,\n  ObjectDefineProperties(self, props) {\n    return Object.defineProperties(self, props)\n  },\n  ObjectDefineProperty(self, name, prop) {\n    return Object.defineProperty(self, name, prop)\n  },\n  ObjectGetOwnPropertyDescriptor(self, name) {\n    return Object.getOwnPropertyDescriptor(self, name)\n  },\n  ObjectKeys(obj) {\n    return Object.keys(obj)\n  },\n  ObjectSetPrototypeOf(target, proto) {\n    return Object.setPrototypeOf(target, proto)\n  },\n  Promise,\n  PromisePrototypeCatch(self, fn) {\n    return self.catch(fn)\n  },\n  PromisePrototypeThen(self, thenFn, catchFn) {\n    return self.then(thenFn, catchFn)\n  },\n  PromiseReject(err) {\n    return Promise.reject(err)\n  },\n  ReflectApply: Reflect.apply,\n  RegExpPrototypeTest(self, value) {\n    return self.test(value)\n  },\n  SafeSet: Set,\n  String,\n  StringPrototypeSlice(self, start, end) {\n    return self.slice(start, end)\n  },\n  StringPrototypeToLowerCase(self) {\n    return self.toLowerCase()\n  },\n  StringPrototypeToUpperCase(self) {\n    return self.toUpperCase()\n  },\n  StringPrototypeTrim(self) {\n    return self.trim()\n  },\n  Symbol,\n  SymbolAsyncIterator: Symbol.asyncIterator,\n  SymbolHasInstance: Symbol.hasInstance,\n  SymbolIterator: Symbol.iterator,\n  TypedArrayPrototypeSet(self, buf, len) {\n    return self.set(buf, len)\n  },\n  Uint8Array\n}\n","'use strict'\n\nconst bufferModule = require('buffer')\nconst AsyncFunction = Object.getPrototypeOf(async function () {}).constructor\nconst Blob = globalThis.Blob || bufferModule.Blob\n/* eslint-disable indent */\nconst isBlob =\n  typeof Blob !== 'undefined'\n    ? function isBlob(b) {\n        // eslint-disable-next-line indent\n        return b instanceof Blob\n      }\n    : function isBlob(b) {\n        return false\n      }\n/* eslint-enable indent */\n\n// This is a simplified version of AggregateError\nclass AggregateError extends Error {\n  constructor(errors) {\n    if (!Array.isArray(errors)) {\n      throw new TypeError(`Expected input to be an Array, got ${typeof errors}`)\n    }\n    let message = ''\n    for (let i = 0; i < errors.length; i++) {\n      message += `    ${errors[i].stack}\\n`\n    }\n    super(message)\n    this.name = 'AggregateError'\n    this.errors = errors\n  }\n}\nmodule.exports = {\n  AggregateError,\n  kEmptyObject: Object.freeze({}),\n  once(callback) {\n    let called = false\n    return function (...args) {\n      if (called) {\n        return\n      }\n      called = true\n      callback.apply(this, args)\n    }\n  },\n  createDeferredPromise: function () {\n    let resolve\n    let reject\n\n    // eslint-disable-next-line promise/param-names\n    const promise = new Promise((res, rej) => {\n      resolve = res\n      reject = rej\n    })\n    return {\n      promise,\n      resolve,\n      reject\n    }\n  },\n  promisify(fn) {\n    return new Promise((resolve, reject) => {\n      fn((err, ...args) => {\n        if (err) {\n          return reject(err)\n        }\n        return resolve(...args)\n      })\n    })\n  },\n  debuglog() {\n    return function () {}\n  },\n  format(format, ...args) {\n    // Simplified version of https://nodejs.org/api/util.html#utilformatformat-args\n    return format.replace(/%([sdifj])/g, function (...[_unused, type]) {\n      const replacement = args.shift()\n      if (type === 'f') {\n        return replacement.toFixed(6)\n      } else if (type === 'j') {\n        return JSON.stringify(replacement)\n      } else if (type === 's' && typeof replacement === 'object') {\n        const ctor = replacement.constructor !== Object ? replacement.constructor.name : ''\n        return `${ctor} {}`.trim()\n      } else {\n        return replacement.toString()\n      }\n    })\n  },\n  inspect(value) {\n    // Vastly simplified version of https://nodejs.org/api/util.html#utilinspectobject-options\n    switch (typeof value) {\n      case 'string':\n        if (value.includes(\"'\")) {\n          if (!value.includes('\"')) {\n            return `\"${value}\"`\n          } else if (!value.includes('`') && !value.includes('${')) {\n            return `\\`${value}\\``\n          }\n        }\n        return `'${value}'`\n      case 'number':\n        if (isNaN(value)) {\n          return 'NaN'\n        } else if (Object.is(value, -0)) {\n          return String(value)\n        }\n        return value\n      case 'bigint':\n        return `${String(value)}n`\n      case 'boolean':\n      case 'undefined':\n        return String(value)\n      case 'object':\n        return '{}'\n    }\n  },\n  types: {\n    isAsyncFunction(fn) {\n      return fn instanceof AsyncFunction\n    },\n    isArrayBufferView(arr) {\n      return ArrayBuffer.isView(arr)\n    }\n  },\n  isBlob\n}\nmodule.exports.promisify.custom = Symbol.for('nodejs.util.promisify.custom')\n","/* replacement start */\n\nconst { Buffer } = require('buffer')\n\n/* replacement end */\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')\nconst { ObjectDefineProperty, ObjectKeys, ReflectApply } = require('./ours/primordials')\nconst {\n  promisify: { custom: customPromisify }\n} = require('./ours/util')\nconst { streamReturningOperators, promiseReturningOperators } = require('./internal/streams/operators')\nconst {\n  codes: { ERR_ILLEGAL_CONSTRUCTOR }\n} = require('./ours/errors')\nconst compose = require('./internal/streams/compose')\nconst { pipeline } = require('./internal/streams/pipeline')\nconst { destroyer } = require('./internal/streams/destroy')\nconst eos = require('./internal/streams/end-of-stream')\nconst internalBuffer = {}\nconst promises = require('./stream/promises')\nconst utils = require('./internal/streams/utils')\nconst Stream = (module.exports = require('./internal/streams/legacy').Stream)\nStream.isDisturbed = utils.isDisturbed\nStream.isErrored = utils.isErrored\nStream.isReadable = utils.isReadable\nStream.Readable = require('./internal/streams/readable')\nfor (const key of ObjectKeys(streamReturningOperators)) {\n  const op = streamReturningOperators[key]\n  function fn(...args) {\n    if (new.target) {\n      throw ERR_ILLEGAL_CONSTRUCTOR()\n    }\n    return Stream.Readable.from(ReflectApply(op, this, args))\n  }\n  ObjectDefineProperty(fn, 'name', {\n    __proto__: null,\n    value: op.name\n  })\n  ObjectDefineProperty(fn, 'length', {\n    __proto__: null,\n    value: op.length\n  })\n  ObjectDefineProperty(Stream.Readable.prototype, key, {\n    __proto__: null,\n    value: fn,\n    enumerable: false,\n    configurable: true,\n    writable: true\n  })\n}\nfor (const key of ObjectKeys(promiseReturningOperators)) {\n  const op = promiseReturningOperators[key]\n  function fn(...args) {\n    if (new.target) {\n      throw ERR_ILLEGAL_CONSTRUCTOR()\n    }\n    return ReflectApply(op, this, args)\n  }\n  ObjectDefineProperty(fn, 'name', {\n    __proto__: null,\n    value: op.name\n  })\n  ObjectDefineProperty(fn, 'length', {\n    __proto__: null,\n    value: op.length\n  })\n  ObjectDefineProperty(Stream.Readable.prototype, key, {\n    __proto__: null,\n    value: fn,\n    enumerable: false,\n    configurable: true,\n    writable: true\n  })\n}\nStream.Writable = require('./internal/streams/writable')\nStream.Duplex = require('./internal/streams/duplex')\nStream.Transform = require('./internal/streams/transform')\nStream.PassThrough = require('./internal/streams/passthrough')\nStream.pipeline = pipeline\nconst { addAbortSignal } = require('./internal/streams/add-abort-signal')\nStream.addAbortSignal = addAbortSignal\nStream.finished = eos\nStream.destroy = destroyer\nStream.compose = compose\nObjectDefineProperty(Stream, 'promises', {\n  __proto__: null,\n  configurable: true,\n  enumerable: true,\n  get() {\n    return promises\n  }\n})\nObjectDefineProperty(pipeline, customPromisify, {\n  __proto__: null,\n  enumerable: true,\n  get() {\n    return promises.pipeline\n  }\n})\nObjectDefineProperty(eos, customPromisify, {\n  __proto__: null,\n  enumerable: true,\n  get() {\n    return promises.finished\n  }\n})\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream\nStream._isUint8Array = function isUint8Array(value) {\n  return value instanceof Uint8Array\n}\nStream._uint8ArrayToBuffer = function _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)\n}\n","'use strict'\n\nconst { ArrayPrototypePop, Promise } = require('../ours/primordials')\nconst { isIterable, isNodeStream } = require('../internal/streams/utils')\nconst { pipelineImpl: pl } = require('../internal/streams/pipeline')\nconst { finished } = require('../internal/streams/end-of-stream')\nfunction pipeline(...streams) {\n  return new Promise((resolve, reject) => {\n    let signal\n    let end\n    const lastArg = streams[streams.length - 1]\n    if (lastArg && typeof lastArg === 'object' && !isNodeStream(lastArg) && !isIterable(lastArg)) {\n      const options = ArrayPrototypePop(streams)\n      signal = options.signal\n      end = options.end\n    }\n    pl(\n      streams,\n      (err, value) => {\n        if (err) {\n          reject(err)\n        } else {\n          resolve(value)\n        }\n      },\n      {\n        signal,\n        end\n      }\n    )\n  })\n}\nmodule.exports = {\n  finished,\n  pipeline\n}\n"],"names":["module","exports","AbortError","codes","eos","ERR_INVALID_ARG_TYPE","addAbortSignal","signal","stream","name","validateAbortSignal","obj","pipe","addAbortSignalNoValidate","onAbort","destroy","undefined","cause","reason","aborted","addEventListener","removeEventListener","StringPrototypeSlice","SymbolIterator","TypedArrayPrototypeSet","Uint8Array","Buffer","inspect","constructor","this","head","tail","length","push","v","entry","data","next","unshift","shift","ret","clear","join","s","p","concat","n","alloc","allocUnsafe","i","consume","hasStrings","slice","_getString","_getBuffer","first","c","str","retLen","buf","buffer","byteOffset","Symbol","for","_","options","depth","customInspect","pipeline","Duplex","destroyer","isNodeStream","isReadable","isWritable","ERR_INVALID_ARG_VALUE","ERR_MISSING_ARGS","streams","from","orgStreams","idx","ondrain","onfinish","onreadable","onclose","d","err","cb","readable","writable","writableObjectMode","readableObjectMode","_write","chunk","encoding","callback","write","_final","end","on","_read","read","_destroy","process","aggregateTwoErrors","ERR_MULTIPLE_CALLBACK","kDestroyed","isDestroyed","isFinished","isServerRequest","kDestroy","kConstruct","checkError","w","r","stack","errored","self","called","onDestroy","_readableState","_writableState","closed","nextTick","emitErrorCloseNT","emitCloseNT","emitErrorNT","closeEmitted","emitClose","emit","errorEmitted","errorOrDestroy","sync","destroyed","autoDestroy","constructNT","onConstruct","constructed","emitConstructNT","_construct","isRequest","setHeader","abort","emitCloseLegacy","emitErrorCloseLegacy","construct","once","listenerCount","socket","req","close","er","undestroy","reading","ended","endEmitted","finalCalled","prefinished","ending","finished","ObjectDefineProperties","ObjectGetOwnPropertyDescriptor","ObjectKeys","ObjectSetPrototypeOf","Readable","Writable","prototype","keys","method","call","allowHalfOpen","webStreamsAdapters","duplexify","lazyWebStreams","__proto__","writableHighWaterMark","writableBuffer","writableLength","writableFinished","writableCorked","writableEnded","writableNeedDrain","get","set","value","fromWeb","pair","newStreamDuplexFromReadableWritablePair","toWeb","duplex","newReadableWritablePairFromDuplex","body","bufferModule","isIterable","isReadableNodeStream","isWritableNodeStream","isDuplexNodeStream","ERR_INVALID_RETURN_VALUE","createDeferredPromise","Blob","globalThis","isBlob","b","AbortController","FunctionPrototypeCall","Duplexify","super","_duplexify","wrap","onfinished","final","fn","promise","resolve","ac","_promise","done","_resolve","fromAsyncGen","objectMode","then","val","async","arrayBuffer","ERR_STREAM_PREMATURE_CLOSE","kEmptyObject","validateFunction","validateObject","Promise","isClosed","isReadableFinished","isReadableErrored","isWritableFinished","isWritableErrored","willEmitClose","_willEmitClose","nop","_options$readable","_options$writable","arguments","wState","rState","onlegacyfinish","readableFinished","onend","onerror","onrequest","error","cleanup","removeListener","endCallback","originalCallback","args","apply","opts","reject","PromisePrototypeThen","SymbolAsyncIterator","ERR_STREAM_NULL_VALUES","iterable","iterator","isAsync","highWaterMark","res","hadError","hasThrow","throw","return","e","ArrayIsArray","EventEmitter","EE","Stream","prependListener","emitter","event","_events","dest","source","ondata","pause","resume","_isStdio","didOnEnd","ERR_OUT_OF_RANGE","validateInteger","kWeakHandler","ArrayPrototypePush","MathFloor","Number","NumberIsNaN","PromiseReject","kEmpty","kEof","map","concurrency","_options$signal","_options$signal2","queue","signalOpt","onDone","_val","catch","_options$signal3","pump","some","unused","filter","ReduceAwareErrMissingArgs","message","toIntegerOrInfinity","number","streamReturningOperators","asIndexedPairs","index","_options$signal4","drop","_options$signal8","_options$signal9","flatMap","values","take","_options$signal10","_options$signal11","promiseReturningOperators","every","forEach","reduce","reducer","initialValue","_options$signal5","hasInitialValue","gotAnyItemFromStream","_options$signal6","toArray","result","_options$signal7","find","PassThrough","Transform","_transform","destroyImpl","ERR_STREAM_DESTROYED","writing","makeAsyncIterable","fromReadable","finish","onresolve","wait","off","pipelineImpl","outerSignal","lastStreamCleanup","finishImpl","destroys","finishCount","code","isLastStream","onError","_ret","pt","src","dst","pop","popCallback","ArrayPrototypeIndexOf","NumberIsInteger","NumberParseInt","SafeSet","ReadableState","debug","BufferList","getHighWaterMark","getDefaultHighWaterMark","ERR_METHOD_NOT_IMPLEMENTED","ERR_STREAM_PUSH_AFTER_EOF","ERR_STREAM_UNSHIFT_AFTER_END_EVENT","kPaused","StringDecoder","isDuplex","pipes","flowing","needReadable","emittedReadable","readableListening","resumeScheduled","defaultEncoding","awaitDrainWriters","multiAwaitDrain","readingMore","dataEmitted","decoder","maybeReadMore","readableAddChunk","addToFront","state","toString","_isUint8Array","_uint8ArrayToBuffer","emitReadable","emitReadable_","onEofChunk","addChunk","_undestroy","captureRejectionSymbol","isPaused","setEncoding","enc","content","howMuchToRead","flow","maybeReadMore_","len","updateReadableListening","nReadingNextTick","resume_","streamToAsyncIterator","iter","destroyOnReturn","createAsyncIterator","fromList","endReadable","endReadableNT","endWritableNT","NaN","nOrig","computeNewHighWaterMark","doRead","pipeOpts","endFn","stdout","stderr","unpipe","onunpipe","unpipeInfo","hasUnpiped","cleanedUp","needDrain","includes","size","add","delete","pipeOnDrain","dests","splice","ev","addListener","removeAllListeners","paused","streamKeys","j","bind","readableDidRead","enumerable","readableAborted","readableHighWaterMark","readableBuffer","readableFlowing","readableLength","readableEncoding","readableEnded","pipesCount","_fromList","readableStream","newStreamReadableFromReadableStream","streamReadable","newReadableStreamFromStreamReadable","_ref","_src$readableObjectMo","duplexKey","hwm","highWaterMarkFrom","kCallback","transform","flush","_flush","prefinish","kIsErrored","kIsReadable","kIsDisturbed","strict","_obj$_readableState","_obj$_writableState","isWritableEnded","isOutgoingMessage","_closed","_defaultKeepAlive","_removedConnection","_removedContLen","isServerResponse","_sent100","isDisturbed","_stream$kIsDisturbed","isErrored","_ref2","_ref3","_ref4","_ref5","_stream$kIsErrored","_stream$_readableStat3","_stream$_writableStat3","_stream$_readableStat4","_stream$_writableStat4","readableErrored","writableErrored","isReadableEnded","_stream$_readableStat","_stream$_readableStat2","_stream$_writableStat","_stream$_writableStat2","_stream$req","_consuming","_dumped","upgradeOrConnect","ArrayPrototypeSlice","Error","FunctionPrototypeSymbolHasInstance","ObjectDefineProperty","StringPrototypeToLowerCase","SymbolHasInstance","WritableState","ERR_STREAM_CANNOT_PIPE","ERR_STREAM_ALREADY_FINISHED","ERR_STREAM_WRITE_AFTER_END","ERR_UNKNOWN_ENCODING","kOnFinished","noDecode","decodeStrings","corked","bufferProcessing","onwrite","writecb","writelen","afterWriteTickInfo","resetBuffer","pendingcb","buffered","bufferedIndex","allBuffers","allNoop","writev","_writev","clearBuffer","finishMaybe","isEncoding","writeOrBuffer","doWrite","onwriteError","errorBuffer","count","afterWriteTick","afterWrite","_state$errored","onfinishCallbacks","_state$errored2","bufferedLength","chunks","needFinish","onFinish","callFinal","getBuffer","object","cork","uncork","setDefaultEncoding","writableAborted","writableStream","newStreamWritableFromWritableStream","streamWritable","newWritableStreamFromStreamWritable","ArrayPrototypeIncludes","ArrayPrototypeJoin","ArrayPrototypeMap","NumberMAX_SAFE_INTEGER","NumberMIN_SAFE_INTEGER","ObjectPrototypeHasOwnProperty","RegExpPrototypeExec","String","StringPrototypeToUpperCase","StringPrototypeTrim","hideStackFrames","ERR_SOCKET_BAD_PORT","ERR_UNKNOWN_SIGNAL","normalizeEncoding","isAsyncFunction","isArrayBufferView","signals","octalReg","min","max","validateInt32","validateUint32","positive","validateString","validateOneOf","oneOf","allowed","getOwnPropertyValueOrDefault","key","defaultValue","allowArray","allowFunction","validateArray","minLength","validateBuffer","validatePlainFunction","validateUndefined","isInt32","isUint32","parseFileMode","def","validateBoolean","validateEncoding","normalizedEncoding","validateNumber","validatePort","port","allowZero","validateSignalName","validateUnion","union","CustomStream","promises","originalDestroy","compose","Object","defineProperty","configurable","format","AggregateError","CustomAggregateError","kIsNodeError","kTypes","classRegExp","assert","ERR_INTERNAL_ASSERTION","addNumericalSeparator","start","E","Base","NodeError","msg","expectedLength","match","getMessage","defineProperties","hidden","expected","actual","Array","isArray","endsWith","types","instances","other","toLowerCase","test","pos","indexOf","last","_actual$constructor","inspected","colors","TypeError","input","_value$constructor","a","range","received","isInteger","Math","abs","RangeError","innerError","outerError","errors","el","sep","ArrayPrototypePop","thisArgs","instance","Function","hasInstance","floor","isNaN","MAX_SAFE_INTEGER","MIN_SAFE_INTEGER","parseInt","props","prop","getOwnPropertyDescriptor","target","proto","setPrototypeOf","PromisePrototypeCatch","thenFn","catchFn","ReflectApply","Reflect","RegExpPrototypeTest","Set","toUpperCase","trim","asyncIterator","AsyncFunction","getPrototypeOf","freeze","rej","promisify","debuglog","replace","_unused","type","replacement","toFixed","JSON","stringify","is","arr","ArrayBuffer","isView","custom","customPromisify","ERR_ILLEGAL_CONSTRUCTOR","utils","op","byteLength","pl","lastArg"],"sourceRoot":""}