Update dependencies.

Author: mbostock

.github/eslint.json

@@ -0,0 +1,18 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "eslint-compact",
+      "pattern": [
+        {
+          "regexp": "^(.+):\\sline\\s(\\d+),\\scol\\s(\\d+),\\s(Error|Warning|Info)\\s-\\s(.+)\\s\\((.+)\\)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "severity": 4,
+          "message": 5,
+          "code": 6
+        }
+      ]
+    }
+  ]
+}

.github/workflows/node.js.yml

@@ -0,0 +1,30 @@
+# https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [12.x]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: yarn --frozen-lockfile
+    - run: |
+        echo ::add-matcher::.github/eslint.json
+        yarn run eslint src test --format=compact
+    - run: yarn test

package.json

@@ -28,17 +28,18 @@
   ],
   "scripts": {
     "pretest": "rollup -c",
-    "test": "tape 'test/**/*-test.js' && eslint src test",
+    "test": "./test/run.sh",
     "prepublishOnly": "rm -rf dist && yarn test",
     "postpublish": "git push && git push --tags && cd ../d3.github.com && git pull && cp ../${npm_package_name}/dist/${npm_package_name}.js ${npm_package_name}.v${npm_package_version%%.*}.js && cp ../${npm_package_name}/dist/${npm_package_name}.min.js ${npm_package_name}.v${npm_package_version%%.*}.min.js && git add ${npm_package_name}.v${npm_package_version%%.*}.js ${npm_package_name}.v${npm_package_version%%.*}.min.js && git commit -m \"${npm_package_name} ${npm_package_version}\" && git push && cd - && zip -j dist/${npm_package_name}.zip -- LICENSE README.md dist/${npm_package_name}.js dist/${npm_package_name}.min.js"
   },
   "sideEffects": false,
   "devDependencies": {
     "d3-array": "1 - 2",
-    "eslint": "6",
-    "jsdom": "15",
-    "rollup": "1",
-    "rollup-plugin-terser": "5",
-    "tape": "4"
+    "eslint": "7",
+    "jsdom": "16",
+    "rollup": "2",
+    "rollup-plugin-terser": "7",
+    "tape": "4",
+    "tape-await": "0.1"
   }
 }

test/bates-test.js

@@ -1,51 +1,46 @@
-var tape = require("tape"),
+var tape = require("tape-await"),
     d3 = Object.assign({}, require("../"), require("d3-array")),
     skewness = require("./skewness"),
     kurtosis = require("./kurtosis");
 
 require("./inDelta");
 
-tape("d3.randomBates(n) returns random numbers with a mean of one-half", function(test) {
+tape("d3.randomBates(n) returns random numbers with a mean of one-half", test => {
   var randomBates = d3.randomBates.source(d3.randomLcg(0.6351090615932817));
   test.inDelta(d3.mean(d3.range(10000).map(randomBates(1))), 0.5, 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomBates(10))), 0.5, 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomBates(1.5))), 0.5, 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomBates(4.2))), 0.5, 0.05);
-  test.end();
 });
 
-tape("d3.randomBates(n) returns random numbers with a variance of 1 / (12 * n)", function(test) {
+tape("d3.randomBates(n) returns random numbers with a variance of 1 / (12 * n)", test => {
   var randomBates = d3.randomBates.source(d3.randomLcg(0.1284832084868286));
   test.inDelta(d3.variance(d3.range(10000).map(randomBates(1))), 1 / 12, 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBates(10))), 1 / 120, 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBates(1.5))), 1 / 18, 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBates(4.2))), 1 / 50.4, 0.05);
-  test.end();
 });
 
-tape("d3.randomBates(n) returns random numbers with a skewness of 0", function(test) {
+tape("d3.randomBates(n) returns random numbers with a skewness of 0", test => {
   var randomBates = d3.randomBates.source(d3.randomLcg(0.051567609139606674));
   test.inDelta(skewness(d3.range(10000).map(randomBates(1))), 0, 0.05);
   test.inDelta(skewness(d3.range(10000).map(randomBates(10))), 0, 0.05);
   test.inDelta(skewness(d3.range(10000).map(randomBates(1.5))), 0, 0.05);
   test.inDelta(skewness(d3.range(10000).map(randomBates(4.2))), 0, 0.05);
-  test.end();
 });
 
-tape("d3.randomBates(n) returns random numbers with a kurtosis of -6 / (5 * n)", function(test) {
+tape("d3.randomBates(n) returns random numbers with a kurtosis of -6 / (5 * n)", test => {
   var randomBates = d3.randomBates.source(d3.randomLcg(0.696913354780724));
   test.inDelta(kurtosis(d3.range(10000).map(randomBates(1))), -6 / 5, 0.05);
   test.inDelta(kurtosis(d3.range(10000).map(randomBates(10))), -6 / 50, 0.1);
   test.inDelta(kurtosis(d3.range(10000).map(randomBates(1.5))), -6 / 7.5, 0.05);
   test.inDelta(kurtosis(d3.range(10000).map(randomBates(4.2))), -6 / 21, 0.05);
-  test.end();
 });
 
-tape("d3.randomBates(0) is equivalent to d3.randomUniform()", function(test) {
+tape("d3.randomBates(0) is equivalent to d3.randomUniform()", test => {
   var randomBates = d3.randomBates.source(d3.randomLcg(0.7717596603725383));
   test.inDelta(d3.mean(d3.range(10000).map(randomBates(0))), 0.5, 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBates(0))), 1 / 12, 0.05);
   test.inDelta(skewness(d3.range(10000).map(randomBates(0))), 0, 0.05);
   test.inDelta(kurtosis(d3.range(10000).map(randomBates(0))), -6 / 5, 0.05);
-  test.end();
 });

test/bernoulli-test.js

@@ -1,45 +1,52 @@
-var tape = require("tape"),
+var tape = require("tape-await"),
     skewness = require("./skewness"),
     kurtosis = require("./kurtosis"),
     d3 = Object.assign({}, require("../"), require("d3-array"));
 
 require("./inDelta");
 
-var mean = function(p) { return p; };
-var variance = function(p) { return p * (1 - p); };
-var skew = function(p) { return (1 - 2 * p) / Math.sqrt(variance(p)); };
-var kurt = function(p) { return (6 * Math.pow(p, 2) - 6 * p + 1) / variance(p); };
+function mean(p) {
+  return p;
+}
 
-tape("randomBernoulli(p) returns random bernoulli distributed numbers with a mean of p", function(test) {
+function variance(p) {
+  return p * (1 - p);
+}
+
+function skew(p) {
+  return (1 - 2 * p) / Math.sqrt(variance(p));
+}
+
+function kurt(p) {
+  return (6 * Math.pow(p, 2) - 6 * p + 1) / (variance(p));
+}
+
+tape("randomBernoulli(p) returns random bernoulli distributed numbers with a mean of p", test => {
   var randomBernoulli = d3.randomBernoulli.source(d3.randomLcg(0.48444190806583465));
   test.inDelta(d3.mean(d3.range(10000).map(randomBernoulli(1))), mean(1), variance(1));
   test.inDelta(d3.mean(d3.range(10000).map(randomBernoulli(.5))), mean(.5), variance(.5));
   test.inDelta(d3.mean(d3.range(10000).map(randomBernoulli(.25))), mean(.25), variance(.25));
   test.inDelta(d3.mean(d3.range(10000).map(randomBernoulli(0))), mean(0), variance(0));
-  test.end();
 });
 
-tape("randomBernoulli(p) returns random bernoulli distributed numbers with a variance of p * (1 - p)", function(test) {
+tape("randomBernoulli(p) returns random bernoulli distributed numbers with a variance of p * (1 - p)", test => {
   var randomBernoulli = d3.randomBernoulli.source(d3.randomLcg(0.9781605192898934));
   test.inDelta(d3.variance(d3.range(10000).map(randomBernoulli(1))), variance(1), 0);
   test.inDelta(d3.variance(d3.range(10000).map(randomBernoulli(.5))), variance(.5), 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBernoulli(.25))), variance(.25), 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBernoulli(0))), variance(0), 0);
-  test.end();
 });
 
-tape("randomBernoulli(p) returns random bernoulli distributed numbers with a skewness of (1 - 2 * p) / sqrt(p * (1 - p)).", function(test) {
+tape("randomBernoulli(p) returns random bernoulli distributed numbers with a skewness of (1 - 2 * p) / sqrt(p * (1 - p)).", test => {
   var randomBernoulli = d3.randomBernoulli.source(d3.randomLcg(0.9776249148208429));
   test.inDelta(skewness(d3.range(10000).map(randomBernoulli(.5))), skew(.5), 0.08);
   test.inDelta(skewness(d3.range(10000).map(randomBernoulli(.25))), skew(.25), 0.05);
-  test.end();
 });
 
-tape("randomBernoulli(p) returns random bernoulli distributed numbers with a kurtosis excess of (6 * p^2 - 6 * p - 1) / (p * (1 - p)).", function(test) {
+tape("randomBernoulli(p) returns random bernoulli distributed numbers with a kurtosis excess of (6 * p^2 - 6 * p - 1) / (p * (1 - p)).", test => {
   var randomBernoulli = d3.randomBernoulli.source(d3.randomLcg(0.8260973119979638));
   test.inDelta(kurtosis(d3.range(10000).map(randomBernoulli(.05))), kurt(.05), kurt(.05) * 0.2);
   test.inDelta(kurtosis(d3.range(10000).map(randomBernoulli(.10))), kurt(.10), kurt(.10) * 0.2);
   test.inDelta(kurtosis(d3.range(10000).map(randomBernoulli(.15))), kurt(.15), kurt(.15) * 0.2);
   test.inDelta(kurtosis(d3.range(50000).map(randomBernoulli(.20))), kurt(.20), kurt(.20) * 0.4);
-  test.end();
 });

test/beta-test.js

@@ -1,29 +1,32 @@
-var tape = require("tape"),
+var tape = require("tape-await"),
     d3 = Object.assign({}, require("../"), require("d3-array"));
 
 require("./inDelta");
 
-var mean = function(alpha, beta) { return alpha / (alpha + beta); };
-var variance = function(alpha, beta) { return (alpha * beta) / Math.pow(alpha + beta, 2) / (alpha + beta + 1); };
+function mean(alpha, beta) {
+  return alpha / (alpha + beta);
+}
 
-tape("randomBeta(alpha, beta) returns random numbers with a mean of alpha / (alpha + beta)", function(test) {
+function variance(alpha, beta) {
+  return (alpha * beta) / Math.pow(alpha + beta, 2) / (alpha + beta + 1);
+}
+
+tape("randomBeta(alpha, beta) returns random numbers with a mean of alpha / (alpha + beta)", test => {
   var randomBeta = d3.randomBeta.source(d3.randomLcg(0.8275880644751501));
   test.inDelta(d3.mean(d3.range(10000).map(randomBeta(1, 1))), mean(1, 1), 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomBeta(1, 2))), mean(1, 2), 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomBeta(2, 1))), mean(2, 1), 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomBeta(3, 4))), mean(3, 4), 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomBeta(0.5, 0.5))), mean(0.5, 0.5), 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomBeta(2.7, 0.3))), mean(2.7, 0.3), 0.05);
-  test.end();
 });
 
-tape("randomBeta(alpha, beta) returns random numbers with a variance of (alpha * beta) / (alpha + beta)^2 / (alpha + beta + 1)", function(test) {
+tape("randomBeta(alpha, beta) returns random numbers with a variance of (alpha * beta) / (alpha + beta)^2 / (alpha + beta + 1)", test => {
   var randomBeta = d3.randomBeta.source(d3.randomLcg(0.8272345925494458));
   test.inDelta(d3.variance(d3.range(10000).map(randomBeta(1, 1))), variance(1, 1), 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBeta(1, 2))), variance(1, 2), 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBeta(2, 1))), variance(2, 1), 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBeta(3, 4))), variance(3, 4), 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBeta(0.5, 0.5))), variance(0.5, 0.5), 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBeta(2.7, 0.3))), variance(2.7, 0.3), 0.05);
-  test.end();
 });

test/binomial-test.js

@@ -1,36 +1,45 @@
-var tape = require("tape"),
+var tape = require("tape-await"),
     skewness = require("./skewness"),
     kurtosis = require("./kurtosis"),
     d3 = Object.assign({}, require("../"), require("d3-array"));
 
 require("./inDelta");
 
-var mean = function(n, p) { return n * p; };
-var variance = function(n, p) { return n * p * (1 - p); };
-var skew = function(n, p) { return (1 - 2 * p) / Math.sqrt(variance(n, p)); };
-var kurt = function(n, p) { return (6 * Math.pow(p, 2) - 6 * p + 1) / (variance(n, p)); };
+function mean(n, p) {
+  return n * p;
+}
 
-tape("randomBinomial(n, p) returns random binomial distributed numbers with a mean of n * p", function(test) {
+function variance(n, p) {
+  return n * p * (1 - p);
+}
+
+function skew(n, p) {
+  return (1 - 2 * p) / Math.sqrt(variance(n, p));
+}
+
+function kurt(n, p) {
+  return (6 * Math.pow(p, 2) - 6 * p + 1) / (variance(n, p));
+}
+
+tape("randomBinomial(n, p) returns random binomial distributed numbers with a mean of n * p", test => {
   var randomBinomial = d3.randomBinomial.source(d3.randomLcg(0.3994478770613372));
   test.inDelta(d3.mean(d3.range(10000).map(randomBinomial(100, 1))), mean(100, 1), variance(100, 1));
   test.inDelta(d3.mean(d3.range(10000).map(randomBinomial(100, .5))), mean(100, .5), variance(100, .5));
   test.inDelta(d3.mean(d3.range(10000).map(randomBinomial(100, .25))), mean(100, .25), variance(100, .25));
   test.inDelta(d3.mean(d3.range(10000).map(randomBinomial(100, 0))), mean(100, 0), variance(100, 0));
   test.inDelta(d3.mean(d3.range(10000).map(randomBinomial(0, 0))), mean(0, 0), variance(0, 0));
-  test.end();
 });
 
-tape("randomBinomial(n, p) returns random binomial distributed numbers with a variance of n * p * (1 - p)", function(test) {
+tape("randomBinomial(n, p) returns random binomial distributed numbers with a variance of n * p * (1 - p)", test => {
   var randomBinomial = d3.randomBinomial.source(d3.randomLcg(0.7214876234380256));
   test.inDelta(d3.variance(d3.range(10000).map(randomBinomial(100, 1))), variance(100, 1), 0);
   test.inDelta(d3.variance(d3.range(10000).map(randomBinomial(100, .5))), variance(100, .5), 0.5);
   test.inDelta(d3.variance(d3.range(10000).map(randomBinomial(100, .25))), variance(100, .25), 1);
   test.inDelta(d3.variance(d3.range(10000).map(randomBinomial(100, 0))), variance(100, 0), 0);
   test.inDelta(d3.variance(d3.range(10000).map(randomBinomial(0, 0))), variance(0, 0), 0);
-  test.end();
 });
 
-tape("randomBinomial(n, p) returns random binomial distributed numbers with a skewness of (1 - 2 * p) / sqrt(n * p * (1 - p))", function(test) {
+tape("randomBinomial(n, p) returns random binomial distributed numbers with a skewness of (1 - 2 * p) / sqrt(n * p * (1 - p))", test => {
   var randomBinomial = d3.randomBinomial.source(d3.randomLcg(0.0646181509291679));
   test.inDelta(skewness(d3.range(10000).map(randomBinomial(100, .05))), skew(100, .05), 0.05);
   test.inDelta(skewness(d3.range(10000).map(randomBinomial(100, .10))), skew(100, .10), 0.05);
@@ -41,10 +50,9 @@ tape("randomBinomial(n, p) returns random binomial distributed numbers with a sk
   test.inDelta(skewness(d3.range(10000).map(randomBinomial(100, .35))), skew(100, .35), 0.05);
   test.inDelta(skewness(d3.range(10000).map(randomBinomial(100, .40))), skew(100, .40), 0.05);
   test.inDelta(skewness(d3.range(10000).map(randomBinomial(100, .45))), skew(100, .45), 0.05);
-  test.end();
 });
 
-tape("randomBinomial(n, p) returns random binomial distributed numbers with a kurtosis excess of (6 * p^2 - 6 * p - 1) / (n * p * (1 - p))", function(test) {
+tape("randomBinomial(n, p) returns random binomial distributed numbers with a kurtosis excess of (6 * p^2 - 6 * p - 1) / (n * p * (1 - p))", test => {
   var randomBinomial = d3.randomBinomial.source(d3.randomLcg(0.6451552018202751));
   test.inDelta(kurtosis(d3.range(10000).map(randomBinomial(100, .05))), kurt(100, .05), 0.2);
   test.inDelta(kurtosis(d3.range(10000).map(randomBinomial(100, .10))), kurt(100, .10), 0.1);
@@ -55,5 +63,4 @@ tape("randomBinomial(n, p) returns random binomial distributed numbers with a ku
   test.inDelta(kurtosis(d3.range(10000).map(randomBinomial(100, .35))), kurt(100, .35), 0.1);
   test.inDelta(kurtosis(d3.range(10000).map(randomBinomial(100, .40))), kurt(100, .40), 0.1);
   test.inDelta(kurtosis(d3.range(10000).map(randomBinomial(100, .45))), kurt(100, .45), 0.05);
-  test.end();
 });

test/cauchy-test.js

@@ -1,17 +1,16 @@
-var tape = require("tape"),
+var tape = require("tape-await"),
     d3 = Object.assign({}, require("../"), require("d3-array"));
 
 require("./inDelta");
 
 // Since the Cauchy distribution is "pathological" in that no integral moments exist,
 // we simply test for the median, equivalent to the location parameter.
 
-tape("randomCauchy(a, b) returns random numbers with a median of a", function(test) {
+tape("randomCauchy(a, b) returns random numbers with a median of a", test => {
   var randomCauchy = d3.randomCauchy.source(d3.randomLcg(0.42));
   test.inDelta(d3.median(d3.range(10000).map(randomCauchy())), 0, 0.05);
   test.inDelta(d3.median(d3.range(10000).map(randomCauchy(5))), 5, 0.05);
   test.inDelta(d3.median(d3.range(10000).map(randomCauchy(0, 4))), 0, 0.1);
   test.inDelta(d3.median(d3.range(10000).map(randomCauchy(1, 3))), 1, 0.1);
   test.inDelta(d3.median(d3.range(10000).map(randomCauchy(3, 1))), 3, 0.05);
-  test.end();
 });

test/exponential-test.js

@@ -1,12 +1,11 @@
-var tape = require("tape"),
+var tape = require("tape-await"),
     d3 = Object.assign({}, require("../"), require("d3-array"));
 
 require("./inDelta");
 
-tape("d3.randomExponential(lambda) returns random exponentially distributed numbers with a mean of 1/lambda.", function(test) {
-  var randomExponential = d3.randomExponential.source(d3.randomLcg(0.42));
-
-  var mean = 20,
+tape("d3.randomExponential(lambda) returns random exponentially distributed numbers with a mean of 1/lambda.", test => {
+  var randomExponential = d3.randomExponential.source(d3.randomLcg(0.42)),
+      mean = 20,
       lambda = 1 / mean, // average rate (e.g. 1 per 20 minutes)
       times = d3.range(10000).map(randomExponential(lambda));
 
@@ -18,6 +17,4 @@ tape("d3.randomExponential(lambda) returns random exponentially distributed numb
         expected = 1 - Math.exp(-elapsed * lambda);
     test.inDelta(within.length / times.length, expected, expected * 0.02);
   });
-
-  test.end();
 });