{"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 transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n/*<replacement>*/\n\n\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return this.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n  cb(er);\n  var rs = this._readableState;\n  rs.reading = false;\n\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n  Duplex.call(this, options);\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  }; // start out asking for a readable event once data is transformed.\n\n  this._readableState.needReadable = true; // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  } // When the writable side finishes, then flush out anything remaining.\n\n\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function') {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n}; // This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\n\n\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n}; // Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\n\n\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this2 = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n\n    _this2.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data); // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n\n  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');\n  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');\n  return stream.push(null);\n}","map":{"version":3,"sources":["/Users/tylerkoenig/Code/personal/react-scss2/node_modules/readable-stream/lib/_stream_transform.js"],"names":["module","exports","Transform","Duplex","require","util","Object","create","inherits","afterTransform","er","data","ts","_transformState","transforming","cb","writecb","emit","Error","writechunk","push","rs","_readableState","reading","needReadable","length","highWaterMark","_read","options","call","bind","needTransform","writeencoding","sync","transform","_transform","flush","_flush","on","prefinish","_this","done","prototype","chunk","encoding","_write","n","_destroy","err","_this2","err2","stream","_writableState"],"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 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\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return this.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n\n  cb(er);\n\n  var rs = this._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\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\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function') {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this2 = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this2.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}"]},"metadata":{},"sourceType":"script"}