{"ast":null,"code":"// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n'use strict';\n\nmodule.exports = Writable;\n/* <replacement> */\n\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n} // It seems a linked list but it is not\n// there will be only 2 of these for each stream\n\n\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\n\n\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n/*<replacement>*/\n\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n    getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n    ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n    ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n    ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n    ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\n\nrequire('inherits')(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {}; // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream,\n  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n\n  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called\n\n  this.finalCalled = false; // drain event flag.\n\n  this.needDrain = false; // at the start of calling end()\n\n  this.ending = false; // when end() has been called, and returned\n\n  this.ended = false; // when 'finish' is emitted\n\n  this.finished = false; // has it been destroyed\n\n  this.destroyed = false; // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode; // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n\n  this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n\n  this.length = 0; // a flag to see when we're in the middle of a write.\n\n  this.writing = false; // when true all writes will be buffered until .uncork() call\n\n  this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n\n  this.sync = true; // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n\n  this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)\n\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  }; // the callback that the user supplies to write(chunk,encoding,cb)\n\n\n  this.writecb = null; // the amount that is being written when _write is called.\n\n  this.writelen = 0;\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null; // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n\n  this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n\n  this.prefinished = false; // True if the error was already emitted and should not be thrown again\n\n  this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.\n\n  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')\n\n  this.autoDestroy = !!options.autoDestroy; // count buffered requests\n\n  this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function writableStateBufferGetter() {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})(); // Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\n\n\nvar realHasInstance;\n\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function value(object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function realHasInstance(object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the WritableState constructor, at least with V8 6.5\n\n  var isDuplex = this instanceof Duplex;\n  if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n  this._writableState = new WritableState(options, this, isDuplex); // legacy.\n\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n    if (typeof options.writev === 'function') this._writev = options.writev;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n} // Otherwise people can pipe Writable streams, which is just wrong.\n\n\nWritable.prototype.pipe = function () {\n  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb\n\n  errorOrDestroy(stream, er);\n  process.nextTick(cb, er);\n} // Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\n\n\nfunction validChunk(stream, state, chunk, cb) {\n  var er;\n\n  if (chunk === null) {\n    er = new ERR_STREAM_NULL_VALUES();\n  } else if (typeof chunk !== 'string' && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n  }\n\n  if (er) {\n    errorOrDestroy(stream, er);\n    process.nextTick(cb, er);\n    return false;\n  }\n\n  return true;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n  if (typeof cb !== 'function') cb = nop;\n  if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  this._writableState.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n    if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.highWaterMark;\n  }\n}); // if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\n\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n\n  var len = state.objectMode ? 1 : chunk.length;\n  state.length += len;\n  var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.\n\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    process.nextTick(cb, er); // this can emit finish, and it will always happen\n    // after error\n\n    process.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er); // this can emit finish, but finish must\n    // always follow error\n\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n  if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n  onwriteStateUpdate(state);\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state) || stream.destroyed;\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      process.nextTick(afterWrite, stream, state, finished, cb);\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n} // Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\n\n\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n} // if there's something in the buffer waiting, then process it\n\n\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n    var count = 0;\n    var allBuffers = true;\n\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n\n    buffer.allBuffers = allBuffers;\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks\n\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  } // ignore unnecessary end() calls.\n\n\n  if (!state.ending) endWritable(this, state, cb);\n  return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.length;\n  }\n});\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\n\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n\n    if (err) {\n      errorOrDestroy(stream, err);\n    }\n\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\n\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function' && !state.destroyed) {\n      state.pendingcb++;\n      state.finalCalled = true;\n      process.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n\n  if (need) {\n    prefinish(stream, state);\n\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n\n      if (state.autoDestroy) {\n        // In case of duplex streams we need a way to detect\n        // if the readable side is ready for autoDestroy as well\n        var rState = stream._readableState;\n\n        if (!rState || rState.autoDestroy && rState.endEmitted) {\n          stream.destroy();\n        }\n      }\n    }\n  }\n\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n\n  if (cb) {\n    if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n  }\n\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  } // reuse the free corkReq.\n\n\n  state.corkedRequestsFree.next = corkReq;\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._writableState === undefined) {\n      return false;\n    }\n\n    return this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._writableState.destroyed = value;\n  }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\n\nWritable.prototype._destroy = function (err, cb) {\n  cb(err);\n};","map":{"version":3,"sources":["D:/Development/Work/CENOS/cenos-ui/node_modules/readable-stream/lib/_stream_writable.js"],"names":["module","exports","Writable","WriteReq","chunk","encoding","cb","callback","next","CorkedRequest","state","_this","entry","finish","onCorkedFinish","Duplex","WritableState","internalUtil","deprecate","require","Stream","Buffer","OurUint8Array","global","Uint8Array","_uint8ArrayToBuffer","from","_isUint8Array","obj","isBuffer","destroyImpl","_require","getHighWaterMark","_require$codes","codes","ERR_INVALID_ARG_TYPE","ERR_METHOD_NOT_IMPLEMENTED","ERR_MULTIPLE_CALLBACK","ERR_STREAM_CANNOT_PIPE","ERR_STREAM_DESTROYED","ERR_STREAM_NULL_VALUES","ERR_STREAM_WRITE_AFTER_END","ERR_UNKNOWN_ENCODING","errorOrDestroy","nop","options","stream","isDuplex","objectMode","writableObjectMode","highWaterMark","finalCalled","needDrain","ending","ended","finished","destroyed","noDecode","decodeStrings","defaultEncoding","length","writing","corked","sync","bufferProcessing","onwrite","er","writecb","writelen","bufferedRequest","lastBufferedRequest","pendingcb","prefinished","errorEmitted","emitClose","autoDestroy","bufferedRequestCount","corkedRequestsFree","prototype","getBuffer","current","out","push","Object","defineProperty","get","writableStateBufferGetter","_","realHasInstance","Symbol","hasInstance","Function","value","object","call","_writableState","writable","write","_write","writev","_writev","destroy","_destroy","final","_final","pipe","writeAfterEnd","process","nextTick","validChunk","ret","isBuf","writeOrBuffer","cork","uncork","clearBuffer","setDefaultEncoding","toLowerCase","indexOf","enumerable","decodeChunk","newChunk","len","last","doWrite","onwriteError","finishMaybe","onwriteStateUpdate","needFinish","afterWrite","onwriteDrain","emit","l","buffer","Array","holder","count","allBuffers","end","undefined","endWritable","callFinal","err","prefinish","need","rState","_readableState","endEmitted","once","corkReq","set","_undestroy","undestroy"],"mappings":"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","sourcesContent":["// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n'use strict';\n\nmodule.exports = Writable;\n/* <replacement> */\n\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n} // It seems a linked list but it is not\n// there will be only 2 of these for each stream\n\n\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\n\n\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n/*<replacement>*/\n\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n    getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n    ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n    ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n    ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n    ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\n\nrequire('inherits')(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {}; // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream,\n  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n\n  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called\n\n  this.finalCalled = false; // drain event flag.\n\n  this.needDrain = false; // at the start of calling end()\n\n  this.ending = false; // when end() has been called, and returned\n\n  this.ended = false; // when 'finish' is emitted\n\n  this.finished = false; // has it been destroyed\n\n  this.destroyed = false; // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode; // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n\n  this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n\n  this.length = 0; // a flag to see when we're in the middle of a write.\n\n  this.writing = false; // when true all writes will be buffered until .uncork() call\n\n  this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n\n  this.sync = true; // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n\n  this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)\n\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  }; // the callback that the user supplies to write(chunk,encoding,cb)\n\n\n  this.writecb = null; // the amount that is being written when _write is called.\n\n  this.writelen = 0;\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null; // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n\n  this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n\n  this.prefinished = false; // True if the error was already emitted and should not be thrown again\n\n  this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.\n\n  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')\n\n  this.autoDestroy = !!options.autoDestroy; // count buffered requests\n\n  this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function writableStateBufferGetter() {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})(); // Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\n\n\nvar realHasInstance;\n\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function value(object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function realHasInstance(object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the WritableState constructor, at least with V8 6.5\n\n  var isDuplex = this instanceof Duplex;\n  if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n  this._writableState = new WritableState(options, this, isDuplex); // legacy.\n\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n    if (typeof options.writev === 'function') this._writev = options.writev;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n} // Otherwise people can pipe Writable streams, which is just wrong.\n\n\nWritable.prototype.pipe = function () {\n  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb\n\n  errorOrDestroy(stream, er);\n  process.nextTick(cb, er);\n} // Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\n\n\nfunction validChunk(stream, state, chunk, cb) {\n  var er;\n\n  if (chunk === null) {\n    er = new ERR_STREAM_NULL_VALUES();\n  } else if (typeof chunk !== 'string' && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n  }\n\n  if (er) {\n    errorOrDestroy(stream, er);\n    process.nextTick(cb, er);\n    return false;\n  }\n\n  return true;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n  if (typeof cb !== 'function') cb = nop;\n  if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  this._writableState.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n    if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.highWaterMark;\n  }\n}); // if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\n\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n\n  var len = state.objectMode ? 1 : chunk.length;\n  state.length += len;\n  var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.\n\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    process.nextTick(cb, er); // this can emit finish, and it will always happen\n    // after error\n\n    process.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er); // this can emit finish, but finish must\n    // always follow error\n\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n  if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n  onwriteStateUpdate(state);\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state) || stream.destroyed;\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      process.nextTick(afterWrite, stream, state, finished, cb);\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n} // Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\n\n\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n} // if there's something in the buffer waiting, then process it\n\n\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n    var count = 0;\n    var allBuffers = true;\n\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n\n    buffer.allBuffers = allBuffers;\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks\n\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  } // ignore unnecessary end() calls.\n\n\n  if (!state.ending) endWritable(this, state, cb);\n  return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.length;\n  }\n});\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\n\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n\n    if (err) {\n      errorOrDestroy(stream, err);\n    }\n\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\n\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function' && !state.destroyed) {\n      state.pendingcb++;\n      state.finalCalled = true;\n      process.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n\n  if (need) {\n    prefinish(stream, state);\n\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n\n      if (state.autoDestroy) {\n        // In case of duplex streams we need a way to detect\n        // if the readable side is ready for autoDestroy as well\n        var rState = stream._readableState;\n\n        if (!rState || rState.autoDestroy && rState.endEmitted) {\n          stream.destroy();\n        }\n      }\n    }\n  }\n\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n\n  if (cb) {\n    if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n  }\n\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  } // reuse the free corkReq.\n\n\n  state.corkedRequestsFree.next = corkReq;\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._writableState === undefined) {\n      return false;\n    }\n\n    return this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._writableState.destroyed = value;\n  }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\n\nWritable.prototype._destroy = function (err, cb) {\n  cb(err);\n};"]},"metadata":{},"sourceType":"script"}