Updated to @babel/core@7, node 10.14.2

README.md

@@ -15,7 +15,7 @@ npm install --save readable-stream
 
 This package is a mirror of the streams implementations in Node.js.
 
-Full documentation may be found on the [Node.js website](https://nodejs.org/dist/v10.11.0/docs/api/stream.html).
+Full documentation may be found on the [Node.js website](https://nodejs.org/dist/v10.14.2/docs/api/stream.html).
 
 If you want to guarantee a stable streams base, regardless of what version of
 Node you, or the users of your libraries are using, use **readable-stream** *only* and avoid the *"stream"* module in Node-core, for background see [this blogpost](http://r.va.gg/2014/06/why-i-dont-use-nodes-core-stream-module.html).

build/build.js

@@ -6,7 +6,7 @@ const hyperquest  = require('hyperquest')
     , path        = require('path')
     , tar         = require('tar-fs')
     , gunzip      = require('gunzip-maybe')
-    , babel       = require('babel-core')
+    , babel       = require('@babel/core')
     , glob        = require('glob')
     , pump        = require('pump')
     , rimraf      = require('rimraf')
@@ -63,20 +63,21 @@ function processFile (inputLoc, out, replacements, addAtEnd) {
       try {
         const transformed = babel.transform(data, {
           plugins: [
-            'transform-es2015-parameters',
-            'transform-es2015-arrow-functions',
-            'transform-es2015-block-scoping',
-            'transform-es2015-template-literals',
-            'transform-es2015-shorthand-properties',
-            'transform-es2015-for-of',
-            ['transform-es2015-classes', { loose: true }],
-            'transform-es2015-destructuring',
-            'transform-es2015-computed-properties',
-            'transform-es2015-spread',
-            'transform-optional-catch-binding',
-            'transform-inline-imports-commonjs',
-            'transform-async-to-generator',
-            'transform-async-generator-functions'
+            '@babel/plugin-transform-parameters',
+            '@babel/plugin-transform-arrow-functions',
+            '@babel/plugin-proposal-object-rest-spread',
+            '@babel/plugin-transform-block-scoping',
+            '@babel/plugin-transform-template-literals',
+            '@babel/plugin-transform-shorthand-properties',
+            '@babel/plugin-transform-for-of',
+            ['@babel/transform-classes', { loose: true }],
+            '@babel/plugin-transform-destructuring',
+            '@babel/plugin-transform-computed-properties',
+            '@babel/plugin-transform-spread',
+            '@babel/plugin-proposal-optional-catch-binding',
+            '@babel/plugin-transform-modules-commonjs',
+            '@babel/plugin-transform-async-to-generator',
+            '@babel/plugin-proposal-async-generator-functions'
           ]
         })
         data = transformed.code
@@ -159,6 +160,7 @@ pump(
             file !== 'test-stream-inheritance.js' &&
             file !== 'test-stream-base-prototype-accessors.js' &&
             file !== 'test-stream-base-prototype-accessors-enumerability.js'  &&
+            file !== 'test-stream-wrap-drain.js' &&
             file !== 'test-stream-base-typechecking.js') {
           processTestFile(file)
         }

build/files.js

@@ -205,8 +205,8 @@ function CorkedRequest(state) {
       ,   'if (typeof Symbol === \'function\' ) {\nReadable.prototype[Symbol.asyncIterator] = function () {'
   ]
   , noAsyncIterators2 = [
-          /return new ReadableAsyncIterator\(this\);\n};/m
-      ,   'return new ReadableAsyncIterator(this);\n};\n}'
+          /return createReadableStreamAsyncIterator\(this\);\n};/m
+      ,   'return createReadableStreamAsyncIterator(this);\n};\n}'
   ]
   , once = [
           /const \{ once \} = require\('internal\/util'\);/
@@ -298,18 +298,17 @@ module.exports['_stream_writable.js'] = [
 ]
 
 module.exports['internal/streams/buffer_list.js'] = [
+    [
+      /inspect.custom/g,
+      'custom'
+    ],
     [
       /const \{ inspect \} = require\('util'\);/,
       `
 const { inspect } = require('util')
 const custom = inspect && inspect.custom || 'inspect'
       `
     ]
-  , [
-    /inspect.custom/g,
-    'custom'
-  ]
-
 ]
 module.exports['internal/streams/destroy.js'] = [
     errorsTwoLevel
@@ -322,6 +321,18 @@ module.exports['internal/streams/state.js'] = [
 
 module.exports['internal/streams/async_iterator.js'] = [
   , errorsTwoLevel
+  , [
+      /internal\/streams\/end-of-stream/,
+      './end-of-stream'
+    ]
+  , [
+      /const AsyncIteratorPrototype = Object\.getPrototypeOf\(\n.*Object\.getPrototypeOf\(async function\* \(\) \{\}\).prototype\);/m,
+      'const AsyncIteratorPrototype = Object\.getPrototypeOf(function () {})'
+    ]
+  , [
+      /  return\(\)/,
+      '[Symbol.asyncIterator]() { return this },\n  return\(\)'
+    ]
 ]
 
 module.exports['internal/streams/end-of-stream.js'] = [

build/test-replacements.js

@@ -156,7 +156,7 @@ module.exports['common.js'] = [
     , [
       /^/,
       `/*<replacement>*/
-      require('babel-polyfill');
+      require('@babel/polyfill');
       var util = require('util');
       for (var i in util) exports[i] = util[i];
       /*</replacement>*/`
@@ -317,6 +317,10 @@ module.exports['test-stream2-readable-from-list.js'] = [
   [
     /require\('internal\/streams\/buffer_list'\)/,
     'require(\'../../lib/internal/streams/buffer_list\')'
+  ],
+  [
+    /assert\.strictEqual\(\n *util.inspect\(\[ list \], \{ compact: false \}\),\n *`\[\n *BufferList \{\n *head: \[Object\],\n *tail: \[Object\],\n *length: 4\n *\}\n *\]`\);/m,
+    'assert.strictEqual(util.inspect([ list ], { compact: false }).indexOf(\'BufferList\') > 0, true)'
   ]
 ]
 module.exports['test-stream-writev.js'] = [
@@ -438,5 +442,13 @@ module.exports['test-stream-readable-async-iterators.js'] = [
   [
     /assert.rejects\(/g,
     '(function(f, e) { let success = false; f().then(function() { success = true; throw new Error(\'should not succeeed\') }).catch(function(e2) { if (success) { throw e2; } assert.strictEqual(e.message, e2.message); })})('
+  ],
+  [
+    /tests\(\).then\(common\.mustCall\(\)\)/,
+    'tests().then(common.mustCall(), common.mustNotCall(console.log))'
+  ],
+  [
+    /const AsyncIteratorPrototype = Object\.getPrototypeOf\(\n.*Object\.getPrototypeOf\(async function\* \(\) \{\}\).prototype\);/m,
+    'const AsyncIteratorPrototype = Object\.getPrototypeOf(function () {})'
   ]
 ]

errors-browser.js

@@ -1,12 +1,18 @@
 'use strict';
 
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
 var codes = {};
 
@@ -23,57 +29,60 @@ function createErrorType(code, message, Base) {
     }
   }
 
-  var NodeError = function (_Base) {
+  var NodeError =
+  /*#__PURE__*/
+  function (_Base) {
     _inherits(NodeError, _Base);
 
     function NodeError(arg1, arg2, arg3) {
       _classCallCheck(this, NodeError);
 
-      return _possibleConstructorReturn(this, (NodeError.__proto__ || Object.getPrototypeOf(NodeError)).call(this, getMessage(arg1, arg2, arg3)));
+      return _possibleConstructorReturn(this, _getPrototypeOf(NodeError).call(this, getMessage(arg1, arg2, arg3)));
     }
 
     return NodeError;
   }(Base);
 
   NodeError.prototype.name = Base.name;
   NodeError.prototype.code = code;
-
   codes[code] = NodeError;
-}
+} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
+
 
-// https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
 function oneOf(expected, thing) {
   if (Array.isArray(expected)) {
     var len = expected.length;
     expected = expected.map(function (i) {
       return String(i);
     });
+
     if (len > 2) {
-      return 'one of ' + thing + ' ' + expected.slice(0, len - 1).join(', ') + ', or ' + expected[len - 1];
+      return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1];
     } else if (len === 2) {
-      return 'one of ' + thing + ' ' + expected[0] + ' or ' + expected[1];
+      return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
     } else {
-      return 'of ' + thing + ' ' + expected[0];
+      return "of ".concat(thing, " ").concat(expected[0]);
     }
   } else {
-    return 'of ' + thing + ' ' + String(expected);
+    return "of ".concat(thing, " ").concat(String(expected));
   }
-}
+} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+
 
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
 function startsWith(str, search, pos) {
   return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
-}
+} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
+
 
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
 function endsWith(str, search, this_len) {
   if (this_len === undefined || this_len > str.length) {
     this_len = str.length;
   }
+
   return str.substring(this_len - search.length, this_len) === search;
-}
+} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
+
 
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
 function includes(str, search, start) {
   if (typeof start !== 'number') {
     start = 0;
@@ -91,24 +100,26 @@ createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
 }, TypeError);
 createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
   // determiner: 'must be' or 'must not be'
-  var determiner = void 0;
+  var determiner;
+
   if (typeof expected === 'string' && startsWith(expected, 'not ')) {
     determiner = 'must not be';
     expected = expected.replace(/^not /, '');
   } else {
     determiner = 'must be';
   }
 
-  var msg = void 0;
+  var msg;
+
   if (endsWith(name, ' argument')) {
     // For cases like 'first argument'
-    msg = 'The ' + name + ' ' + determiner + ' ' + oneOf(expected, 'type');
+    msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
   } else {
     var type = includes(name, '.') ? 'property' : 'argument';
-    msg = 'The "' + name + '" ' + type + ' ' + determiner + ' ' + oneOf(expected, 'type');
+    msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
   }
 
-  msg += '. Received type ' + (typeof actual === 'undefined' ? 'undefined' : _typeof(actual));
+  msg += ". Received type ".concat(_typeof(actual));
   return msg;
 }, TypeError);
 createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
@@ -127,5 +138,4 @@ createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
   return 'Unknown encoding: ' + arg;
 }, TypeError);
 createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
-
 module.exports.codes = codes;

lib/_stream_duplex.js

@@ -18,34 +18,37 @@
 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
-
 // a duplex stream is just a stream that is both readable and writable.
 // Since JS doesn't have multiple prototypal inheritance, this class
 // prototypally inherits from Readable, and then parasitically from
 // Writable.
-
 'use strict';
-
 /*<replacement>*/
 
 var objectKeys = Object.keys || function (obj) {
   var keys = [];
+
   for (var key in obj) {
     keys.push(key);
-  }return keys;
+  }
+
+  return keys;
 };
 /*</replacement>*/
 
+
 module.exports = Duplex;
 
 var Readable = require('./_stream_readable');
+
 var Writable = require('./_stream_writable');
 
 require('inherits')(Duplex, Readable);
 
 {
   // Allow the keys array to be GC'ed.
   var keys = objectKeys(Writable.prototype);
+
   for (var v = 0; v < keys.length; v++) {
     var method = keys[v];
     if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
@@ -54,14 +57,12 @@ require('inherits')(Duplex, Readable);
 
 function Duplex(options) {
   if (!(this instanceof Duplex)) return new Duplex(options);
-
   Readable.call(this, options);
   Writable.call(this, options);
   this.allowHalfOpen = true;
 
   if (options) {
     if (options.readable === false) this.readable = false;
-
     if (options.writable === false) this.writable = false;
 
     if (options.allowHalfOpen === false) {
@@ -80,7 +81,6 @@ Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
     return this._writableState.highWaterMark;
   }
 });
-
 Object.defineProperty(Duplex.prototype, 'writableBuffer', {
   // making it explicit this property is not enumerable
   // because otherwise some prototype manipulation in
@@ -90,7 +90,6 @@ Object.defineProperty(Duplex.prototype, 'writableBuffer', {
     return this._writableState && this._writableState.getBuffer();
   }
 });
-
 Object.defineProperty(Duplex.prototype, 'writableLength', {
   // making it explicit this property is not enumerable
   // because otherwise some prototype manipulation in
@@ -99,15 +98,13 @@ Object.defineProperty(Duplex.prototype, 'writableLength', {
   get: function () {
     return this._writableState.length;
   }
-});
+}); // the no-half-open enforcer
 
-// the no-half-open enforcer
 function onend() {
   // If the writable side ended, then we're ok.
-  if (this._writableState.ended) return;
-
-  // no more data can be written.
+  if (this._writableState.ended) return; // no more data can be written.
   // But allow more writes to happen in this tick.
+
   process.nextTick(onEndNT, this);
 }
 
@@ -124,17 +121,18 @@ Object.defineProperty(Duplex.prototype, 'destroyed', {
     if (this._readableState === undefined || this._writableState === undefined) {
       return false;
     }
+
     return this._readableState.destroyed && this._writableState.destroyed;
   },
   set: function (value) {
     // we ignore the value if the stream
     // has not been initialized yet
     if (this._readableState === undefined || this._writableState === undefined) {
       return;
-    }
-
-    // backward compatibility, the user is explicitly
+    } // backward compatibility, the user is explicitly
     // managing destroyed
+
+
     this._readableState.destroyed = value;
     this._writableState.destroyed = value;
   }