Node.js v11.13.0

10 files changed, 641 insertions, 0 deletions

diff --git a/deps/node/benchmark/es/defaultparams-bench.js b/deps/node/benchmark/es/defaultparams-bench.js
new file mode 100644
index 00000000..c568c12a
--- /dev/null
+++ b/deps/node/benchmark/es/defaultparams-bench.js
@@ -0,0 +1,50 @@
+'use strict';
+
+const common = require('../common.js');
+const assert = require('assert');
+
+const bench = common.createBenchmark(main, {
+  method: ['withoutdefaults', 'withdefaults'],
+  n: [1e8]
+});
+
+function oldStyleDefaults(x, y) {
+  x = x || 1;
+  y = y || 2;
+  assert.strictEqual(x, 1);
+  assert.strictEqual(y, 2);
+}
+
+function defaultParams(x = 1, y = 2) {
+  assert.strictEqual(x, 1);
+  assert.strictEqual(y, 2);
+}
+
+function runOldStyleDefaults(n) {
+  bench.start();
+  for (var i = 0; i < n; i++)
+    oldStyleDefaults();
+  bench.end(n);
+}
+
+function runDefaultParams(n) {
+  bench.start();
+  for (var i = 0; i < n; i++)
+    defaultParams();
+  bench.end(n);
+}
+
+function main({ n, method }) {
+  switch (method) {
+    case '':
+      // Empty string falls through to next line as default, mostly for tests.
+    case 'withoutdefaults':
+      runOldStyleDefaults(n);
+      break;
+    case 'withdefaults':
+      runDefaultParams(n);
+      break;
+    default:
+      throw new Error(`Unexpected method "${method}"`);
+  }
+}
diff --git a/deps/node/benchmark/es/destructuring-bench.js b/deps/node/benchmark/es/destructuring-bench.js
new file mode 100644
index 00000000..37f3fd9a
--- /dev/null
+++ b/deps/node/benchmark/es/destructuring-bench.js
@@ -0,0 +1,50 @@
+'use strict';
+
+const common = require('../common.js');
+const assert = require('assert');
+
+const bench = common.createBenchmark(main, {
+  method: ['swap', 'destructure'],
+  n: [1e8]
+});
+
+function runSwapManual(n) {
+  var x, y, r;
+  bench.start();
+  for (var i = 0; i < n; i++) {
+    x = 1, y = 2;
+    r = x;
+    x = y;
+    y = r;
+    assert.strictEqual(x, 2);
+    assert.strictEqual(y, 1);
+  }
+  bench.end(n);
+}
+
+function runSwapDestructured(n) {
+  var x, y;
+  bench.start();
+  for (var i = 0; i < n; i++) {
+    x = 1, y = 2;
+    [x, y] = [y, x];
+    assert.strictEqual(x, 2);
+    assert.strictEqual(y, 1);
+  }
+  bench.end(n);
+}
+
+function main({ n, method }) {
+  switch (method) {
+    case '':
+      // Empty string falls through to next line as default, mostly for tests.
+    case 'swap':
+      runSwapManual(n);
+      break;
+    case 'destructure':
+      runSwapDestructured(n);
+      break;
+    default:
+      throw new Error(`Unexpected method "${method}"`);
+  }
+}
diff --git a/deps/node/benchmark/es/destructuring-object-bench.js b/deps/node/benchmark/es/destructuring-object-bench.js
new file mode 100644
index 00000000..0c5615fd
--- /dev/null
+++ b/deps/node/benchmark/es/destructuring-object-bench.js
@@ -0,0 +1,49 @@
+'use strict';
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  method: ['normal', 'destructureObject'],
+  n: [1e8]
+});
+
+function runNormal(n) {
+  var i = 0;
+  const o = { x: 0, y: 1 };
+  bench.start();
+  for (; i < n; i++) {
+    /* eslint-disable no-unused-vars */
+    const x = o.x;
+    const y = o.y;
+    const r = o.r || 2;
+    /* eslint-enable no-unused-vars */
+  }
+  bench.end(n);
+}
+
+function runDestructured(n) {
+  var i = 0;
+  const o = { x: 0, y: 1 };
+  bench.start();
+  for (; i < n; i++) {
+    /* eslint-disable no-unused-vars */
+    const { x, y, r = 2 } = o;
+    /* eslint-enable no-unused-vars */
+  }
+  bench.end(n);
+}
+
+function main({ n, method }) {
+  switch (method) {
+    case '':
+      // Empty string falls through to next line as default, mostly for tests.
+    case 'normal':
+      runNormal(n);
+      break;
+    case 'destructureObject':
+      runDestructured(n);
+      break;
+    default:
+      throw new Error(`Unexpected method "${method}"`);
+  }
+}
diff --git a/deps/node/benchmark/es/foreach-bench.js b/deps/node/benchmark/es/foreach-bench.js
new file mode 100644
index 00000000..25ea97b4
--- /dev/null
+++ b/deps/node/benchmark/es/foreach-bench.js
@@ -0,0 +1,77 @@
+'use strict';
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  method: ['for', 'for-of', 'for-in', 'forEach'],
+  count: [5, 10, 20, 100],
+  n: [5e6]
+});
+
+function useFor(n, items, count) {
+  bench.start();
+  for (var i = 0; i < n; i++) {
+    for (var j = 0; j < count; j++) {
+      /* eslint-disable no-unused-vars */
+      const item = items[j];
+      /* esline-enable no-unused-vars */
+    }
+  }
+  bench.end(n);
+}
+
+function useForOf(n, items) {
+  var item;
+  bench.start();
+  for (var i = 0; i < n; i++) {
+    for (item of items) {}
+  }
+  bench.end(n);
+}
+
+function useForIn(n, items) {
+  bench.start();
+  for (var i = 0; i < n; i++) {
+    for (var j in items) {
+      /* eslint-disable no-unused-vars */
+      const item = items[j];
+      /* esline-enable no-unused-vars */
+    }
+  }
+  bench.end(n);
+}
+
+function useForEach(n, items) {
+  bench.start();
+  for (var i = 0; i < n; i++) {
+    items.forEach((item) => {});
+  }
+  bench.end(n);
+}
+
+function main({ n, count, method }) {
+  const items = new Array(count);
+  var fn;
+  for (var i = 0; i < count; i++)
+    items[i] = i;
+
+  switch (method) {
+    case '':
+      // Empty string falls through to next line as default, mostly for tests.
+    case 'for':
+      fn = useFor;
+      break;
+    case 'for-of':
+      fn = useForOf;
+      break;
+    case 'for-in':
+      fn = useForIn;
+      break;
+    case 'forEach':
+      fn = useForEach;
+      break;
+    default:
+      throw new Error(`Unexpected method "${method}"`);
+  }
+  fn(n, items, count);
+}
diff --git a/deps/node/benchmark/es/map-bench.js b/deps/node/benchmark/es/map-bench.js
new file mode 100644
index 00000000..a2f9e245
--- /dev/null
+++ b/deps/node/benchmark/es/map-bench.js
@@ -0,0 +1,130 @@
+'use strict';
+
+const common = require('../common.js');
+const assert = require('assert');
+
+const bench = common.createBenchmark(main, {
+  method: [
+    'object', 'nullProtoObject', 'nullProtoLiteralObject', 'storageObject',
+    'fakeMap', 'map',
+  ],
+  n: [1e6]
+});
+
+function runObject(n) {
+  const m = {};
+  bench.start();
+  for (var i = 0; i < n; i++) {
+    m[`i${i}`] = i;
+    m[`s${i}`] = String(i);
+    assert.strictEqual(String(m[`i${i}`]), m[`s${i}`]);
+    m[`i${i}`] = undefined;
+    m[`s${i}`] = undefined;
+  }
+  bench.end(n);
+}
+
+function runNullProtoObject(n) {
+  const m = Object.create(null);
+  bench.start();
+  for (var i = 0; i < n; i++) {
+    m[`i${i}`] = i;
+    m[`s${i}`] = String(i);
+    assert.strictEqual(String(m[`i${i}`]), m[`s${i}`]);
+    m[`i${i}`] = undefined;
+    m[`s${i}`] = undefined;
+  }
+  bench.end(n);
+}
+
+function runNullProtoLiteralObject(n) {
+  const m = { __proto__: null };
+  bench.start();
+  for (var i = 0; i < n; i++) {
+    m[`i${i}`] = i;
+    m[`s${i}`] = String(i);
+    assert.strictEqual(String(m[`i${i}`]), m[`s${i}`]);
+    m[`i${i}`] = undefined;
+    m[`s${i}`] = undefined;
+  }
+  bench.end(n);
+}
+
+function StorageObject() {}
+StorageObject.prototype = Object.create(null);
+
+function runStorageObject(n) {
+  const m = new StorageObject();
+  bench.start();
+  for (var i = 0; i < n; i++) {
+    m[`i${i}`] = i;
+    m[`s${i}`] = String(i);
+    assert.strictEqual(String(m[`i${i}`]), m[`s${i}`]);
+    m[`i${i}`] = undefined;
+    m[`s${i}`] = undefined;
+  }
+  bench.end(n);
+}
+
+function fakeMap() {
+  const m = {};
+  return {
+    get(key) { return m[`$${key}`]; },
+    set(key, val) { m[`$${key}`] = val; },
+    get size() { return Object.keys(m).length; },
+    has(key) { return Object.prototype.hasOwnProperty.call(m, `$${key}`); }
+  };
+}
+
+function runFakeMap(n) {
+  const m = fakeMap();
+  bench.start();
+  for (var i = 0; i < n; i++) {
+    m.set(`i${i}`, i);
+    m.set(`s${i}`, String(i));
+    assert.strictEqual(String(m.get(`i${i}`)), m.get(`s${i}`));
+    m.set(`i${i}`, undefined);
+    m.set(`s${i}`, undefined);
+  }
+  bench.end(n);
+}
+
+function runMap(n) {
+  const m = new Map();
+  bench.start();
+  for (var i = 0; i < n; i++) {
+    m.set(`i${i}`, i);
+    m.set(`s${i}`, String(i));
+    assert.strictEqual(String(m.get(`i${i}`)), m.get(`s${i}`));
+    m.set(`i${i}`, undefined);
+    m.set(`s${i}`, undefined);
+  }
+  bench.end(n);
+}
+
+function main({ n, method }) {
+  switch (method) {
+    case '':
+      // Empty string falls through to next line as default, mostly for tests.
+    case 'object':
+      runObject(n);
+      break;
+    case 'nullProtoObject':
+      runNullProtoObject(n);
+      break;
+    case 'nullProtoLiteralObject':
+      runNullProtoLiteralObject(n);
+      break;
+    case 'storageObject':
+      runStorageObject(n);
+      break;
+    case 'fakeMap':
+      runFakeMap(n);
+      break;
+    case 'map':
+      runMap(n);
+      break;
+    default:
+      throw new Error(`Unexpected method "${method}"`);
+  }
+}
diff --git a/deps/node/benchmark/es/restparams-bench.js b/deps/node/benchmark/es/restparams-bench.js
new file mode 100644
index 00000000..d9b4878c
--- /dev/null
+++ b/deps/node/benchmark/es/restparams-bench.js
@@ -0,0 +1,71 @@
+'use strict';
+
+const common = require('../common.js');
+const assert = require('assert');
+
+const bench = common.createBenchmark(main, {
+  method: ['copy', 'rest', 'arguments'],
+  n: [1e8]
+});
+
+function copyArguments() {
+  const len = arguments.length;
+  const args = new Array(len);
+  for (var i = 0; i < len; i++)
+    args[i] = arguments[i];
+  assert.strictEqual(args[0], 1);
+  assert.strictEqual(args[1], 2);
+  assert.strictEqual(args[2], 'a');
+  assert.strictEqual(args[3], 'b');
+}
+
+function restArguments(...args) {
+  assert.strictEqual(args[0], 1);
+  assert.strictEqual(args[1], 2);
+  assert.strictEqual(args[2], 'a');
+  assert.strictEqual(args[3], 'b');
+}
+
+function useArguments() {
+  assert.strictEqual(arguments[0], 1);
+  assert.strictEqual(arguments[1], 2);
+  assert.strictEqual(arguments[2], 'a');
+  assert.strictEqual(arguments[3], 'b');
+}
+
+function runCopyArguments(n) {
+  for (var i = 0; i < n; i++)
+    copyArguments(1, 2, 'a', 'b');
+}
+
+function runRestArguments(n) {
+  for (var i = 0; i < n; i++)
+    restArguments(1, 2, 'a', 'b');
+}
+
+function runUseArguments(n) {
+  for (var i = 0; i < n; i++)
+    useArguments(1, 2, 'a', 'b');
+}
+
+function main({ n, method }) {
+  var fn;
+  switch (method) {
+    case '':
+      // Empty string falls through to next line as default, mostly for tests.
+    case 'copy':
+      fn = runCopyArguments;
+      break;
+    case 'rest':
+      fn = runRestArguments;
+      break;
+    case 'arguments':
+      fn = runUseArguments;
+      break;
+    default:
+      throw new Error(`Unexpected method "${method}"`);
+  }
+  bench.start();
+  fn(n);
+  bench.end(n);
+}
diff --git a/deps/node/benchmark/es/spread-assign.js b/deps/node/benchmark/es/spread-assign.js
new file mode 100644
index 00000000..bbe07e02
--- /dev/null
+++ b/deps/node/benchmark/es/spread-assign.js
@@ -0,0 +1,45 @@
+'use strict';
+
+const common = require('../common.js');
+const util = require('util');
+
+const bench = common.createBenchmark(main, {
+  method: ['spread', 'assign', '_extend'],
+  count: [5, 10, 20],
+  n: [1e6]
+});
+
+function main({ n, context, count, rest, method }) {
+
+  const src = {};
+  for (let n = 0; n < count; n++)
+    src[`p${n}`] = n;
+
+  let obj;  // eslint-disable-line no-unused-vars
+  let i;
+
+  switch (method) {
+    case '':
+      // Empty string falls through to next line as default, mostly for tests.
+    case '_extend':
+      bench.start();
+      for (i = 0; i < n; i++)
+        obj = util._extend({}, src);
+      bench.end(n);
+      break;
+    case 'assign':
+      bench.start();
+      for (i = 0; i < n; i++)
+        obj = Object.assign({}, src);
+      bench.end(n);
+      break;
+    case 'spread':
+      bench.start();
+      for (i = 0; i < n; i++)
+        obj = { ...src };
+      bench.end(n);
+      break;
+    default:
+      throw new Error('Unexpected method');
+  }
+}
diff --git a/deps/node/benchmark/es/spread-bench.js b/deps/node/benchmark/es/spread-bench.js
new file mode 100644
index 00000000..97c7596b
--- /dev/null
+++ b/deps/node/benchmark/es/spread-bench.js
@@ -0,0 +1,60 @@
+'use strict';
+
+const common = require('../common.js');
+const assert = require('assert');
+
+const bench = common.createBenchmark(main, {
+  method: ['apply', 'spread', 'call-spread'],
+  count: [5, 10, 20],
+  context: ['context', 'null'],
+  rest: [0, 1],
+  n: [5e6]
+});
+
+function makeTest(count, rest) {
+  if (rest) {
+    return function test(...args) {
+      assert.strictEqual(count, args.length);
+    };
+  } else {
+    return function test() {
+      assert.strictEqual(count, arguments.length);
+    };
+  }
+}
+
+function main({ n, context, count, rest, method }) {
+  const ctx = context === 'context' ? {} : null;
+  var fn = makeTest(count, rest);
+  const args = new Array(count);
+  var i;
+  for (i = 0; i < count; i++)
+    args[i] = i;
+
+  switch (method) {
+    case '':
+      // Empty string falls through to next line as default, mostly for tests.
+    case 'apply':
+      bench.start();
+      for (i = 0; i < n; i++)
+        fn.apply(ctx, args);
+      bench.end(n);
+      break;
+    case 'spread':
+      if (ctx !== null)
+        fn = fn.bind(ctx);
+      bench.start();
+      for (i = 0; i < n; i++)
+        fn(...args);
+      bench.end(n);
+      break;
+    case 'call-spread':
+      bench.start();
+      for (i = 0; i < n; i++)
+        fn.call(ctx, ...args);
+      bench.end(n);
+      break;
+    default:
+      throw new Error(`Unexpected method "${method}"`);
+  }
+}
diff --git a/deps/node/benchmark/es/string-concatenations.js b/deps/node/benchmark/es/string-concatenations.js
new file mode 100644
index 00000000..72fb7f99
--- /dev/null
+++ b/deps/node/benchmark/es/string-concatenations.js
@@ -0,0 +1,69 @@
+'use strict';
+
+const common = require('../common.js');
+
+const configs = {
+  n: [1e3],
+  mode: [
+    'multi-concat',
+    'multi-join',
+    'multi-template',
+    'to-string-string',
+    'to-string-concat',
+    'to-string-template',
+  ],
+};
+
+const bench = common.createBenchmark(main, configs);
+
+function main({ n, mode }) {
+  const str = 'abc';
+  const num = 123;
+
+  let string;
+
+  switch (mode) {
+    case '':
+      // Empty string falls through to next line as default, mostly for tests.
+    case 'multi-concat':
+      bench.start();
+      for (let i = 0; i < n; i++)
+        string = '...' + str + ', ' + num + ', ' + str + ', ' + num + '.';
+      bench.end(n);
+      break;
+    case 'multi-join':
+      bench.start();
+      for (let i = 0; i < n; i++)
+        string = ['...', str, ', ', num, ', ', str, ', ', num, '.'].join('');
+      bench.end(n);
+      break;
+    case 'multi-template':
+      bench.start();
+      for (let i = 0; i < n; i++)
+        string = `...${str}, ${num}, ${str}, ${num}.`;
+      bench.end(n);
+      break;
+    case 'to-string-string':
+      bench.start();
+      for (let i = 0; i < n; i++)
+        string = String(num);
+      bench.end(n);
+      break;
+    case 'to-string-concat':
+      bench.start();
+      for (let i = 0; i < n; i++)
+        string = '' + num;
+      bench.end(n);
+      break;
+    case 'to-string-template':
+      bench.start();
+      for (let i = 0; i < n; i++)
+        string = `${num}`;
+      bench.end(n);
+      break;
+    default:
+      throw new Error(`Unexpected method "${mode}"`);
+  }
+
+  return string;
+}
diff --git a/deps/node/benchmark/es/string-repeat.js b/deps/node/benchmark/es/string-repeat.js
new file mode 100644
index 00000000..9e33e4ac
--- /dev/null
+++ b/deps/node/benchmark/es/string-repeat.js
@@ -0,0 +1,40 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common.js');
+
+const configs = {
+  n: [1e3],
+  mode: ['Array', 'repeat'],
+  encoding: ['ascii', 'utf8'],
+  size: [1e1, 1e3, 1e6],
+};
+
+const bench = common.createBenchmark(main, configs);
+
+function main({ n, size, encoding, mode }) {
+  const character = encoding === 'ascii' ? 'a' : '\ud83d\udc0e'; // '🐎'
+
+  let str;
+
+  switch (mode) {
+    case '':
+      // Empty string falls through to next line as default, mostly for tests.
+    case 'Array':
+      bench.start();
+      for (let i = 0; i < n; i++)
+        str = new Array(size + 1).join(character);
+      bench.end(n);
+      break;
+    case 'repeat':
+      bench.start();
+      for (let i = 0; i < n; i++)
+        str = character.repeat(size);
+      bench.end(n);
+      break;
+    default:
+      throw new Error(`Unexpected method "${mode}"`);
+  }
+
+  assert.strictEqual([...str].length, size);
+}