Adopt type=module

.eslintrc.json

@@ -3,13 +3,5 @@
   "parserOptions": {
     "sourceType": "module",
     "ecmaVersion": 8
-  },
-  "env": {
-    "es6": true,
-    "node": true,
-    "browser": true
-  },
-  "rules": {
-    "no-cond-assign": 0
   }
 }

.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: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [14.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

LICENSE

@@ -1,4 +1,4 @@
-Copyright 2010-2016 Mike Bostock
+Copyright 2010-2021 Mike Bostock
 Copyright 2001 Robert Penner
 All rights reserved.
 

README.md

@@ -8,13 +8,25 @@ These easing types are largely based on work by [Robert Penner](http://robertpen
 
 ## Installing
 
-If you use NPM, `npm install d3-ease`. Otherwise, download the [latest release](https://github.com/d3/d3-ease/releases/latest). You can also load directly from [d3js.org](https://d3js.org), either as a [standalone library](https://d3js.org/d3-ease.v1.min.js) or as part of [D3](https://github.com/d3/d3). AMD, CommonJS, and vanilla environments are supported. In vanilla, a `d3` global is exported:
+If you use npm, `npm install d3-ease`. You can also download the [latest release on GitHub](https://github.com/d3/d3-ease/releases/latest). For vanilla HTML in modern browsers, import d3-ease from Skypack:
 
 ```html
-<script src="https://d3js.org/d3-ease.v2.min.js"></script>
+<script type="module">
+
+import {easeCubic} from "https://cdn.skypack.dev/d3-ease@3";
+
+const e = easeCubic(0.25);
+
+</script>
+```
+
+For legacy environments, you can load d3-ease’s UMD bundle from an npm-based CDN such as jsDelivr; a `d3` global is exported:
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/d3-ease@3"></script>
 <script>
 
-var ease = d3.easeCubic;
+const e = d3.easeCubic(0.25);
 
 </script>
 ```
@@ -28,17 +40,17 @@ var ease = d3.easeCubic;
 Given the specified normalized time *t*, typically in the range [0,1], returns the “eased” time *tʹ*, also typically in [0,1]. 0 represents the start of the animation and 1 represents the end. A good implementation returns 0 if *t* = 0 and 1 if *t* = 1. See the [easing explorer](https://observablehq.com/@d3/easing) for a visual demonstration. For example, to apply [cubic](#easeCubic) easing:
 
 ```js
-var te = d3.easeCubic(t);
+const te = d3.easeCubic(t);
 ```
 
 Similarly, to apply custom [elastic](#easeElastic) easing:
 
 ```js
 // Before the animation starts, create your easing function.
-var customElastic = d3.easeElastic.period(0.4);
+const customElastic = d3.easeElastic.period(0.4);
 
 // During the animation, apply the easing function.
-var te = customElastic(t);
+const te = customElastic(t);
 ```
 
 <a name="easeLinear" href="#easeLinear">#</a> d3.<b>easeLinear</b>(<i>t</i>) [<>](https://github.com/d3/d3-ease/blob/master/src/linear.js "Source")
@@ -71,9 +83,9 @@ Symmetric polynomial easing; scales [polyIn](#easePolyIn) for *t* in [0, 0.5] an
 Returns a new polynomial easing with the specified exponent *e*. For example, to create equivalents of [linear](#easeLinear), [quad](#easeQuad), and [cubic](#easeCubic):
 
 ```js
-var linear = d3.easePoly.exponent(1),
-    quad = d3.easePoly.exponent(2),
-    cubic = d3.easePoly.exponent(3);
+const linear = d3.easePoly.exponent(1);
+const quad = d3.easePoly.exponent(2);
+const cubic = d3.easePoly.exponent(3);
 ```
 
 <a name="easeQuadIn" href="#easeQuadIn">#</a> d3.<b>easeQuadIn</b>(<i>t</i>) [<>](https://github.com/d3/d3-ease/blob/master/src/quad.js#L1 "Source")

package.json

@@ -2,6 +2,11 @@
   "name": "d3-ease",
   "version": "2.0.0",
   "description": "Easing functions for smooth animation.",
+  "homepage": "https://d3js.org/d3-ease/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/d3/d3-ease.git"
+  },
   "keywords": [
     "d3",
     "d3-module",
@@ -10,35 +15,37 @@
     "animation",
     "transition"
   ],
-  "homepage": "https://d3js.org/d3-ease/",
   "license": "BSD-3-Clause",
   "author": {
     "name": "Mike Bostock",
     "url": "http://bost.ocks.org/mike"
   },
-  "main": "dist/d3-ease.js",
-  "unpkg": "dist/d3-ease.min.js",
-  "jsdelivr": "dist/d3-ease.min.js",
-  "module": "src/index.js",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/d3/d3-ease.git"
-  },
+  "type": "module",
   "files": [
     "dist/**/*.js",
     "src/**/*.js"
   ],
-  "scripts": {
-    "pretest": "rollup -c",
-    "test": "tape 'test/**/*-test.js' && eslint src test",
-    "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"
+  "module": "src/index.js",
+  "main": "src/index.js",
+  "jsdelivr": "dist/d3-ease.min.js",
+  "unpkg": "dist/d3-ease.min.js",
+  "exports": {
+    "umd": "./dist/d3-ease.min.js",
+    "default": "./src/index.js"
   },
   "sideEffects": false,
   "devDependencies": {
-    "eslint": "6",
-    "rollup": "1",
-    "rollup-plugin-terser": "5",
-    "tape": "4"
+    "eslint": "7",
+    "mocha": "8",
+    "rollup": "2",
+    "rollup-plugin-terser": "7"
+  },
+  "scripts": {
+    "test": "mocha 'test/**/*-test.js' && eslint src test",
+    "prepublishOnly": "rm -rf dist && yarn test && rollup -c",
+    "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 -"
+  },
+  "engines": {
+    "node": ">=12"
   }
 }

test/.eslintrc.json

@@ -0,0 +1,10 @@
+{
+  "extends": "eslint:recommended",
+  "parserOptions": {
+    "sourceType": "module",
+    "ecmaVersion": 8
+  },
+  "env": {
+    "mocha": true
+  }
+}

test/asserts.js

@@ -0,0 +1,5 @@
+import assert from "assert";
+
+export function assertInDelta(actual, expected) {
+  assert(expected - 1e-6 < actual && actual < expected + 1e-6);
+}

test/back-test.js

@@ -1,75 +1,67 @@
-var tape = require("tape"),
-    ease = require("../"),
-    generic = require("./generic");
+import assert from "assert";
+import {easeBack, easeBackIn, easeBackInOut, easeBackOut} from "../src/index.js";
+import {out, inOut} from "./generic.js"
+import {assertInDelta} from "./asserts.js";
 
-require("./inDelta");
-
-tape("easeBack is an alias for easeBackInOut", function(test) {
-  test.equal(ease.easeBack, ease.easeBackInOut);
-  test.end();
+it("easeBack is an alias for easeBackInOut", () => {
+  assert.strictEqual(easeBack, easeBackInOut);
 });
 
-tape("easeBackIn(t) returns the expected results", function(test) {
-  test.equal(ease.easeBackIn(0.0),  0.000000);
-  test.inDelta(ease.easeBackIn(0.1), -0.014314);
-  test.inDelta(ease.easeBackIn(0.2), -0.046451);
-  test.inDelta(ease.easeBackIn(0.3), -0.080200);
-  test.inDelta(ease.easeBackIn(0.4), -0.099352);
-  test.inDelta(ease.easeBackIn(0.5), -0.087698);
-  test.inDelta(ease.easeBackIn(0.6), -0.029028);
-  test.inDelta(ease.easeBackIn(0.7), +0.092868);
-  test.inDelta(ease.easeBackIn(0.8), +0.294198);
-  test.inDelta(ease.easeBackIn(0.9), +0.591172);
-  test.equal(ease.easeBackIn(1.0), +1.000000);
-  test.end();
+it("easeBackIn(t) returns the expected results", () => {
+  assert.strictEqual(Math.abs(easeBackIn(0.0)),  0.000000);
+  assertInDelta(easeBackIn(0.1), -0.014314);
+  assertInDelta(easeBackIn(0.2), -0.046451);
+  assertInDelta(easeBackIn(0.3), -0.080200);
+  assertInDelta(easeBackIn(0.4), -0.099352);
+  assertInDelta(easeBackIn(0.5), -0.087698);
+  assertInDelta(easeBackIn(0.6), -0.029028);
+  assertInDelta(easeBackIn(0.7), +0.092868);
+  assertInDelta(easeBackIn(0.8), +0.294198);
+  assertInDelta(easeBackIn(0.9), +0.591172);
+  assert.strictEqual(easeBackIn(1.0), +1.000000);
 });
 
-tape("easeBackIn(t) coerces t to a number", function(test) {
-  test.strictEqual(ease.easeBackIn(".9"), ease.easeBackIn(0.9));
-  test.strictEqual(ease.easeBackIn({valueOf: function() { return 0.9; }}), ease.easeBackIn(0.9));
-  test.end();
+it("easeBackIn(t) coerces t to a number", () => {
+  assert.strictEqual(easeBackIn(".9"), easeBackIn(0.9));
+  assert.strictEqual(easeBackIn({valueOf: function() { return 0.9; }}), easeBackIn(0.9));
 });
 
-tape("easeBackOut(t) returns the expected results", function(test) {
-  var backOut = generic.out(ease.easeBackIn);
-  test.equal(ease.easeBackOut(0.0), backOut(0.0));
-  test.inDelta(ease.easeBackOut(0.1), backOut(0.1));
-  test.inDelta(ease.easeBackOut(0.2), backOut(0.2));
-  test.inDelta(ease.easeBackOut(0.3), backOut(0.3));
-  test.inDelta(ease.easeBackOut(0.4), backOut(0.4));
-  test.inDelta(ease.easeBackOut(0.5), backOut(0.5));
-  test.inDelta(ease.easeBackOut(0.6), backOut(0.6));
-  test.inDelta(ease.easeBackOut(0.7), backOut(0.7));
-  test.inDelta(ease.easeBackOut(0.8), backOut(0.8));
-  test.inDelta(ease.easeBackOut(0.9), backOut(0.9));
-  test.equal(ease.easeBackOut(1.0), backOut(1.0));
-  test.end();
+it("easeBackOut(t) returns the expected results", () => {
+  const backOut = out(easeBackIn);
+  assert.strictEqual(easeBackOut(0.0), backOut(0.0));
+  assertInDelta(easeBackOut(0.1), backOut(0.1));
+  assertInDelta(easeBackOut(0.2), backOut(0.2));
+  assertInDelta(easeBackOut(0.3), backOut(0.3));
+  assertInDelta(easeBackOut(0.4), backOut(0.4));
+  assertInDelta(easeBackOut(0.5), backOut(0.5));
+  assertInDelta(easeBackOut(0.6), backOut(0.6));
+  assertInDelta(easeBackOut(0.7), backOut(0.7));
+  assertInDelta(easeBackOut(0.8), backOut(0.8));
+  assertInDelta(easeBackOut(0.9), backOut(0.9));
+  assert.strictEqual(easeBackOut(1.0), backOut(1.0));
 });
 
-tape("easeBackOut(t) coerces t to a number", function(test) {
-  test.strictEqual(ease.easeBackOut(".9"), ease.easeBackOut(0.9));
-  test.strictEqual(ease.easeBackOut({valueOf: function() { return 0.9; }}), ease.easeBackOut(0.9));
-  test.end();
+it("easeBackOut(t) coerces t to a number", () => {
+  assert.strictEqual(easeBackOut(".9"), easeBackOut(0.9));
+  assert.strictEqual(easeBackOut({valueOf: function() { return 0.9; }}), easeBackOut(0.9));
 });
 
-tape("easeBackInOut(t) returns the expected results", function(test) {
-  var backInOut = generic.inOut(ease.easeBackIn);
-  test.equal(ease.easeBackInOut(0.0), backInOut(0.0));
-  test.inDelta(ease.easeBackInOut(0.1), backInOut(0.1));
-  test.inDelta(ease.easeBackInOut(0.2), backInOut(0.2));
-  test.inDelta(ease.easeBackInOut(0.3), backInOut(0.3));
-  test.inDelta(ease.easeBackInOut(0.4), backInOut(0.4));
-  test.inDelta(ease.easeBackInOut(0.5), backInOut(0.5));
-  test.inDelta(ease.easeBackInOut(0.6), backInOut(0.6));
-  test.inDelta(ease.easeBackInOut(0.7), backInOut(0.7));
-  test.inDelta(ease.easeBackInOut(0.8), backInOut(0.8));
-  test.inDelta(ease.easeBackInOut(0.9), backInOut(0.9));
-  test.equal(ease.easeBackInOut(1.0), backInOut(1.0));
-  test.end();
+it("easeBackInOut(t) returns the expected results", () => {
+  const backInOut = inOut(easeBackIn);
+  assert.strictEqual(easeBackInOut(0.0), backInOut(0.0));
+  assertInDelta(easeBackInOut(0.1), backInOut(0.1));
+  assertInDelta(easeBackInOut(0.2), backInOut(0.2));
+  assertInDelta(easeBackInOut(0.3), backInOut(0.3));
+  assertInDelta(easeBackInOut(0.4), backInOut(0.4));
+  assertInDelta(easeBackInOut(0.5), backInOut(0.5));
+  assertInDelta(easeBackInOut(0.6), backInOut(0.6));
+  assertInDelta(easeBackInOut(0.7), backInOut(0.7));
+  assertInDelta(easeBackInOut(0.8), backInOut(0.8));
+  assertInDelta(easeBackInOut(0.9), backInOut(0.9));
+  assert.strictEqual(easeBackInOut(1.0), backInOut(1.0));
 });
 
-tape("easeBackInOut(t) coerces t to a number", function(test) {
-  test.strictEqual(ease.easeBackInOut(".9"), ease.easeBackInOut(0.9));
-  test.strictEqual(ease.easeBackInOut({valueOf: function() { return 0.9; }}), ease.easeBackInOut(0.9));
-  test.end();
+it("easeBackInOut(t) coerces t to a number", () => {
+  assert.strictEqual(easeBackInOut(".9"), easeBackInOut(0.9));
+  assert.strictEqual(easeBackInOut({valueOf: function() { return 0.9; }}), easeBackInOut(0.9));
 });