{"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/**/\n\nvar pna = require('process-nextick-args');\n/**/\n\n\nmodule.exports = Writable;\n/* */\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/* */\n\n/**/\n\n\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/**/\n\n/**/\n\nvar Duplex;\n/**/\n\nWritable.WritableState = WritableState;\n/**/\n\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/**/\n\n/**/\n\nvar internalUtil = {\n deprecate: require('util-deprecate')\n};\n/**/\n\n/**/\n\nvar Stream = require('./internal/streams/stream');\n/**/\n\n/**/\n\n\nvar Buffer = require('safe-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/**/\n\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n Duplex = Duplex || require('./_stream_duplex');\n options = options || {}; // Duplex streams are both readable and writable, but share\n // the same options object.\n // However, some cases require setting options to different\n // values for the readable and the writable sides of the duplex stream.\n // These options can be provided separately as readableXXX and writableXXX.\n\n var 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 var hwm = options.highWaterMark;\n var writableHwm = options.writableHighWaterMark;\n var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm; // cast to ints.\n\n this.highWaterMark = Math.floor(this.highWaterMark); // 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; // 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 () {\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 (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 (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\n if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n return new Writable(options);\n }\n\n this._writableState = new WritableState(options, this); // 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 this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n var er = new Error('write after end'); // TODO: defer error events consistently everywhere, not just the cb\n\n stream.emit('error', er);\n pna.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 valid = true;\n var er = false;\n\n if (chunk === null) {\n er = new TypeError('May not write null values to stream');\n } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n er = new TypeError('Invalid non-string/buffer chunk');\n }\n\n if (er) {\n stream.emit('error', er);\n pna.nextTick(cb, er);\n valid = false;\n }\n\n return valid;\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.ended) 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 var state = this._writableState;\n state.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.finished && !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 TypeError('Unknown encoding: ' + encoding);\n this._writableState.defaultEncoding = encoding;\n return this;\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 () {\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 (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 pna.nextTick(cb, er); // this can emit finish, and it will always happen\n // after error\n\n pna.nextTick(finishMaybe, stream, state);\n stream._writableState.errorEmitted = true;\n stream.emit('error', 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 stream.emit('error', 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 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);\n\n if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n clearBuffer(stream, state);\n }\n\n if (sync) {\n /**/\n asyncWrite(afterWrite, stream, state, finished, cb);\n /**/\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 Error('_write() is not implemented'));\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 && !state.finished) endWritable(this, state, cb);\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 stream.emit('error', 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') {\n state.pendingcb++;\n state.finalCalled = true;\n pna.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 }\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) pna.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 }\n\n if (state.corkedRequestsFree) {\n state.corkedRequestsFree.next = corkReq;\n } else {\n state.corkedRequestsFree = corkReq;\n }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n get: function () {\n if (this._writableState === undefined) {\n return false;\n }\n\n return this._writableState.destroyed;\n },\n set: function (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 this.end();\n cb(err);\n};","map":{"version":3,"sources":["D:/Development/Work/CENOS/cenos-ui/node_modules/winston-transport/node_modules/readable-stream/lib/_stream_writable.js"],"names":["pna","require","module","exports","Writable","WriteReq","chunk","encoding","cb","callback","next","CorkedRequest","state","_this","entry","finish","onCorkedFinish","asyncWrite","process","browser","indexOf","version","slice","setImmediate","nextTick","Duplex","WritableState","util","Object","create","inherits","internalUtil","deprecate","Stream","Buffer","OurUint8Array","global","Uint8Array","_uint8ArrayToBuffer","from","_isUint8Array","obj","isBuffer","destroyImpl","nop","options","stream","isDuplex","objectMode","writableObjectMode","hwm","highWaterMark","writableHwm","writableHighWaterMark","defaultHwm","Math","floor","finalCalled","needDrain","ending","ended","finished","destroyed","noDecode","decodeStrings","defaultEncoding","length","writing","corked","sync","bufferProcessing","onwrite","er","writecb","writelen","bufferedRequest","lastBufferedRequest","pendingcb","prefinished","errorEmitted","bufferedRequestCount","corkedRequestsFree","prototype","getBuffer","current","out","push","defineProperty","get","_","realHasInstance","Symbol","hasInstance","Function","value","object","call","_writableState","writable","write","_write","writev","_writev","destroy","_destroy","final","_final","pipe","emit","Error","writeAfterEnd","validChunk","valid","TypeError","undefined","ret","isBuf","writeOrBuffer","cork","uncork","clearBuffer","setDefaultEncoding","toLowerCase","decodeChunk","enumerable","newChunk","len","last","doWrite","onwriteError","finishMaybe","onwriteStateUpdate","needFinish","afterWrite","onwriteDrain","l","buffer","Array","holder","count","allBuffers","end","endWritable","callFinal","err","prefinish","need","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\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';\n\n/**/\n\nvar pna = require('process-nextick-args');\n/**/\n\nmodule.exports = Writable;\n\n/* */\nfunction WriteReq(chunk, encoding, cb) {\n this.chunk = chunk;\n this.encoding = encoding;\n this.callback = cb;\n this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n var _this = this;\n\n this.next = null;\n this.entry = null;\n this.finish = function () {\n onCorkedFinish(_this, state);\n };\n}\n/* */\n\n/**/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/**/\n\n/**/\nvar Duplex;\n/**/\n\nWritable.WritableState = WritableState;\n\n/**/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/**/\n\n/**/\nvar internalUtil = {\n deprecate: require('util-deprecate')\n};\n/**/\n\n/**/\nvar Stream = require('./internal/streams/stream');\n/**/\n\n/**/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/**/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n Duplex = Duplex || require('./_stream_duplex');\n\n options = options || {};\n\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 var isDuplex = stream instanceof Duplex;\n\n // object stream flag to indicate whether or not this stream\n // contains buffers or objects.\n this.objectMode = !!options.objectMode;\n\n if (isDuplex) this.objectMode = this.objectMode || !!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 var hwm = options.highWaterMark;\n var writableHwm = options.writableHighWaterMark;\n var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;\n\n // cast to ints.\n this.highWaterMark = Math.floor(this.highWaterMark);\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 var noDecode = 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.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 = function (er) {\n onwrite(stream, er);\n };\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 this.bufferedRequest = null;\n this.lastBufferedRequest = null;\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 // 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 // count buffered requests\n this.bufferedRequestCount = 0;\n\n // allocate the first CorkedRequest, there is always\n // one allocated and free to use, and we maintain at most two\n this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n var current = this.bufferedRequest;\n var out = [];\n while (current) {\n out.push(current);\n current = current.next;\n }\n return out;\n};\n\n(function () {\n try {\n Object.defineProperty(WritableState.prototype, 'buffer', {\n get: internalUtil.deprecate(function () {\n return this.getBuffer();\n }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n });\n } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\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 (object) {\n if (realHasInstance.call(this, object)) return true;\n if (this !== Writable) return false;\n\n return object && object._writableState instanceof WritableState;\n }\n });\n} else {\n realHasInstance = function (object) {\n return object instanceof this;\n };\n}\n\nfunction Writable(options) {\n Duplex = Duplex || require('./_stream_duplex');\n\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 if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n return new Writable(options);\n }\n\n this._writableState = new WritableState(options, this);\n\n // legacy.\n this.writable = true;\n\n if (options) {\n if (typeof options.write === 'function') this._write = options.write;\n\n if (typeof options.writev === 'function') this._writev = options.writev;\n\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n if (typeof options.final === 'function') this._final = options.final;\n }\n\n Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n var er = new Error('write after end');\n // TODO: defer error events consistently everywhere, not just the cb\n stream.emit('error', er);\n pna.nextTick(cb, er);\n}\n\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.\nfunction validChunk(stream, state, chunk, cb) {\n var valid = true;\n var er = false;\n\n if (chunk === null) {\n er = new TypeError('May not write null values to stream');\n } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n er = new TypeError('Invalid non-string/buffer chunk');\n }\n if (er) {\n stream.emit('error', er);\n pna.nextTick(cb, er);\n valid = false;\n }\n return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n var state = this._writableState;\n var ret = false;\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\n if (typeof cb !== 'function') cb = nop;\n\n if (state.ended) 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\n return ret;\n};\n\nWritable.prototype.cork = function () {\n var state = this._writableState;\n\n state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n var state = this._writableState;\n\n if (state.corked) {\n state.corked--;\n\n if (!state.writing && !state.corked && !state.finished && !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 TypeError('Unknown encoding: ' + encoding);\n this._writableState.defaultEncoding = encoding;\n return this;\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 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 () {\n return this._writableState.highWaterMark;\n }\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, isBuf, chunk, encoding, cb) {\n if (!isBuf) {\n var newChunk = decodeChunk(state, chunk, encoding);\n if (chunk !== newChunk) {\n isBuf = true;\n encoding = 'buffer';\n chunk = newChunk;\n }\n }\n var len = state.objectMode ? 1 : chunk.length;\n\n state.length += len;\n\n var 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\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 if (last) {\n last.next = state.lastBufferedRequest;\n } else {\n state.bufferedRequest = state.lastBufferedRequest;\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 (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 pna.nextTick(cb, er);\n // this can emit finish, and it will always happen\n // after error\n pna.nextTick(finishMaybe, stream, state);\n stream._writableState.errorEmitted = true;\n stream.emit('error', 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 stream.emit('error', er);\n // this can emit finish, but finish must\n // always follow error\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\n onwriteStateUpdate(state);\n\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);\n\n if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n clearBuffer(stream, state);\n }\n\n if (sync) {\n /**/\n asyncWrite(afterWrite, stream, state, finished, cb);\n /**/\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}\n\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.\nfunction onwriteDrain(stream, state) {\n if (state.length === 0 && state.needDrain) {\n state.needDrain = false;\n stream.emit('drain');\n }\n}\n\n// if there's something in the buffer waiting, then process it\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\n var count = 0;\n var allBuffers = true;\n while (entry) {\n buffer[count] = entry;\n if (!entry.isBuf) allBuffers = false;\n entry = entry.next;\n count += 1;\n }\n buffer.allBuffers = allBuffers;\n\n doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n // doWrite is almost always async, defer these to save a bit of time\n // as the hot path ends with doWrite\n state.pendingcb++;\n state.lastBufferedRequest = null;\n if (holder.next) {\n state.corkedRequestsFree = holder.next;\n holder.next = null;\n } else {\n state.corkedRequestsFree = new CorkedRequest(state);\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\n doWrite(stream, state, false, len, chunk, encoding, cb);\n entry = entry.next;\n state.bufferedRequestCount--;\n // 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 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 Error('_write() is not implemented'));\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);\n\n // .end() fully uncorks\n if (state.corked) {\n state.corked = 1;\n this.uncork();\n }\n\n // ignore unnecessary end() calls.\n if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n stream._final(function (err) {\n state.pendingcb--;\n if (err) {\n stream.emit('error', err);\n }\n state.prefinished = true;\n stream.emit('prefinish');\n finishMaybe(stream, state);\n });\n}\nfunction prefinish(stream, state) {\n if (!state.prefinished && !state.finalCalled) {\n if (typeof stream._final === 'function') {\n state.pendingcb++;\n state.finalCalled = true;\n pna.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 if (need) {\n prefinish(stream, state);\n if (state.pendingcb === 0) {\n state.finished = true;\n stream.emit('finish');\n }\n }\n return need;\n}\n\nfunction endWritable(stream, state, cb) {\n state.ending = true;\n finishMaybe(stream, state);\n if (cb) {\n if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);\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 while (entry) {\n var cb = entry.callback;\n state.pendingcb--;\n cb(err);\n entry = entry.next;\n }\n if (state.corkedRequestsFree) {\n state.corkedRequestsFree.next = corkReq;\n } else {\n state.corkedRequestsFree = corkReq;\n }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n get: function () {\n if (this._writableState === undefined) {\n return false;\n }\n return this._writableState.destroyed;\n },\n set: function (value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._writableState) {\n return;\n }\n\n // backward compatibility, the user is explicitly\n // managing destroyed\n this._writableState.destroyed = value;\n }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n this.end();\n cb(err);\n};"]},"metadata":{},"sourceType":"script"}