Index: node_modules/d3-ease/LICENSE =================================================================== --- node_modules/d3-ease/LICENSE (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/LICENSE (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,28 @@ +Copyright 2010-2021 Mike Bostock +Copyright 2001 Robert Penner +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of the author nor the names of contributors may be used to + endorse or promote products derived from this software without specific prior + written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Index: node_modules/d3-ease/README.md =================================================================== --- node_modules/d3-ease/README.md (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/README.md (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,253 @@ +# d3-ease + +*Easing* is a method of distorting time to control apparent motion in animation. It is most commonly used for [slow-in, slow-out](https://en.wikipedia.org/wiki/12_basic_principles_of_animation#Slow_In_and_Slow_Out). By easing time, [animated transitions](https://github.com/d3/d3-transition) are smoother and exhibit more plausible motion. + +The easing types in this module implement the [ease method](#ease_ease), which takes a normalized time *t* and returns the corresponding “eased” time *tʹ*. Both the normalized time and the eased time are typically in the range [0,1], where 0 represents the start of the animation and 1 represents the end; some easing types, such as [elastic](#easeElastic), may return eased times slightly outside this range. A good easing type should return 0 if *t* = 0 and 1 if *t* = 1. See the [easing explorer](https://observablehq.com/@d3/easing) for a visual demonstration. + +These easing types are largely based on work by [Robert Penner](http://robertpenner.com/easing/). + +## Installing + +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 + +``` + +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 + + +``` + +[Try d3-ease in your browser.](https://observablehq.com/@d3/easing-animations) + +## API Reference + +# ease(t) + +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 +const te = d3.easeCubic(t); +``` + +Similarly, to apply custom [elastic](#easeElastic) easing: + +```js +// Before the animation starts, create your easing function. +const customElastic = d3.easeElastic.period(0.4); + +// During the animation, apply the easing function. +const te = customElastic(t); +``` + +# d3.easeLinear(t) [<>](https://github.com/d3/d3-ease/blob/master/src/linear.js "Source") + +Linear easing; the identity function; *linear*(*t*) returns *t*. + +[linear](https://observablehq.com/@d3/easing#linear) + +# d3.easePolyIn(t) [<>](https://github.com/d3/d3-ease/blob/master/src/poly.js#L3 "Source") + +Polynomial easing; raises *t* to the specified [exponent](#poly_exponent). If the exponent is not specified, it defaults to 3, equivalent to [cubicIn](#easeCubicIn). + +[polyIn](https://observablehq.com/@d3/easing#polyIn) + +# d3.easePolyOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/poly.js#L15 "Source") + +Reverse polynomial easing; equivalent to 1 - [polyIn](#easePolyIn)(1 - *t*). If the [exponent](#poly_exponent) is not specified, it defaults to 3, equivalent to [cubicOut](#easeCubicOut). + +[polyOut](https://observablehq.com/@d3/easing#polyOut) + +# d3.easePoly(t) [<>](https://github.com/d3/d3-ease/blob/master/src/poly.js "Source") +
# d3.easePolyInOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/poly.js#L27 "Source") + +Symmetric polynomial easing; scales [polyIn](#easePolyIn) for *t* in [0, 0.5] and [polyOut](#easePolyOut) for *t* in [0.5, 1]. If the [exponent](#poly_exponent) is not specified, it defaults to 3, equivalent to [cubic](#easeCubic). + +[polyInOut](https://observablehq.com/@d3/easing#polyInOut) + +# poly.exponent(e) [<>](https://github.com/d3/d3-ease/blob/master/src/poly.js#L1 "Source") + +Returns a new polynomial easing with the specified exponent *e*. For example, to create equivalents of [linear](#easeLinear), [quad](#easeQuad), and [cubic](#easeCubic): + +```js +const linear = d3.easePoly.exponent(1); +const quad = d3.easePoly.exponent(2); +const cubic = d3.easePoly.exponent(3); +``` + +# d3.easeQuadIn(t) [<>](https://github.com/d3/d3-ease/blob/master/src/quad.js#L1 "Source") + +Quadratic easing; equivalent to [polyIn](#easePolyIn).[exponent](#poly_exponent)(2). + +[quadIn](https://observablehq.com/@d3/easing#quadIn) + +# d3.easeQuadOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/quad.js#L5 "Source") + +Reverse quadratic easing; equivalent to 1 - [quadIn](#easeQuadIn)(1 - *t*). Also equivalent to [polyOut](#easePolyOut).[exponent](#poly_exponent)(2). + +[quadOut](https://observablehq.com/@d3/easing#quadOut) + +# d3.easeQuad(t) [<>](https://github.com/d3/d3-ease/blob/master/src/quad.js "Source") +
# d3.easeQuadInOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/quad.js#L9 "Source") + +Symmetric quadratic easing; scales [quadIn](#easeQuadIn) for *t* in [0, 0.5] and [quadOut](#easeQuadOut) for *t* in [0.5, 1]. Also equivalent to [poly](#easePoly).[exponent](#poly_exponent)(2). + +[quadInOut](https://observablehq.com/@d3/easing#quadInOut) + +# d3.easeCubicIn(t) [<>](https://github.com/d3/d3-ease/blob/master/src/cubic.js#L1 "Source") + +Cubic easing; equivalent to [polyIn](#easePolyIn).[exponent](#poly_exponent)(3). + +[cubicIn](https://observablehq.com/@d3/easing#cubicIn) + +# d3.easeCubicOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/cubic.js#L5 "Source") + +Reverse cubic easing; equivalent to 1 - [cubicIn](#easeCubicIn)(1 - *t*). Also equivalent to [polyOut](#easePolyOut).[exponent](#poly_exponent)(3). + +[cubicOut](https://observablehq.com/@d3/easing#cubicOut) + +# d3.easeCubic(t) [<>](https://github.com/d3/d3-ease/blob/master/src/cubic.js "Source") +
# d3.easeCubicInOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/cubic.js#L9 "Source") + +Symmetric cubic easing; scales [cubicIn](#easeCubicIn) for *t* in [0, 0.5] and [cubicOut](#easeCubicOut) for *t* in [0.5, 1]. Also equivalent to [poly](#easePoly).[exponent](#poly_exponent)(3). + +[cubicInOut](https://observablehq.com/@d3/easing#cubicInOut) + +# d3.easeSinIn(t) [<>](https://github.com/d3/d3-ease/blob/master/src/sin.js#L4 "Source") + +Sinusoidal easing; returns sin(*t*). + +[sinIn](https://observablehq.com/@d3/easing#sinIn) + +# d3.easeSinOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/sin.js#L8 "Source") + +Reverse sinusoidal easing; equivalent to 1 - [sinIn](#easeSinIn)(1 - *t*). + +[sinOut](https://observablehq.com/@d3/easing#sinOut) + +# d3.easeSin(t) [<>](https://github.com/d3/d3-ease/blob/master/src/sin.js "Source") +
# d3.easeSinInOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/sin.js#L12 "Source") + +Symmetric sinusoidal easing; scales [sinIn](#easeSinIn) for *t* in [0, 0.5] and [sinOut](#easeSinOut) for *t* in [0.5, 1]. + +[sinInOut](https://observablehq.com/@d3/easing#sinInOut) + +# d3.easeExpIn(t) [<>](https://github.com/d3/d3-ease/blob/master/src/exp.js#L1 "Source") + +Exponential easing; raises 2 to the exponent 10 \* (*t* - 1). + +[expIn](https://observablehq.com/@d3/easing#expIn) + +# d3.easeExpOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/exp.js#L5 "Source") + +Reverse exponential easing; equivalent to 1 - [expIn](#easeExpIn)(1 - *t*). + +[expOut](https://observablehq.com/@d3/easing#expOut) + +# d3.easeExp(t) [<>](https://github.com/d3/d3-ease/blob/master/src/exp.js "Source") +
# d3.easeExpInOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/exp.js#L9 "Source") + +Symmetric exponential easing; scales [expIn](#easeExpIn) for *t* in [0, 0.5] and [expOut](#easeExpOut) for *t* in [0.5, 1]. + +[expInOut](https://observablehq.com/@d3/easing#expInOut) + +# d3.easeCircleIn(t) [<>](https://github.com/d3/d3-ease/blob/master/src/circle.js#L1 "Source") + +Circular easing. + +[circleIn](https://observablehq.com/@d3/easing#circleIn) + +# d3.easeCircleOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/circle.js#L5 "Source") + +Reverse circular easing; equivalent to 1 - [circleIn](#easeCircleIn)(1 - *t*). + +[circleOut](https://observablehq.com/@d3/easing#circleOut) + +# d3.easeCircle(t) [<>](https://github.com/d3/d3-ease/blob/master/src/circle.js "Source") +
# d3.easeCircleInOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/circle.js#L9 "Source") + +Symmetric circular easing; scales [circleIn](#easeCircleIn) for *t* in [0, 0.5] and [circleOut](#easeCircleOut) for *t* in [0.5, 1]. + +[circleInOut](https://observablehq.com/@d3/easing#circleInOut) + +# d3.easeElasticIn(t) [<>](https://github.com/d3/d3-ease/blob/master/src/elastic.js#L5 "Source") + +Elastic easing, like a rubber band. The [amplitude](#elastic_amplitude) and [period](#elastic_period) of the oscillation are configurable; if not specified, they default to 1 and 0.3, respectively. + +[elasticIn](https://observablehq.com/@d3/easing#elasticIn) + +# d3.easeElastic(t) [<>](https://github.com/d3/d3-ease/blob/master/src/elastic.js "Source") +
# d3.easeElasticOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/elastic.js#L18 "Source") + +Reverse elastic easing; equivalent to 1 - [elasticIn](#easeElasticIn)(1 - *t*). + +[elasticOut](https://observablehq.com/@d3/easing#elasticOut) + +# d3.easeElasticInOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/elastic.js#L31 "Source") + +Symmetric elastic easing; scales [elasticIn](#easeElasticIn) for *t* in [0, 0.5] and [elasticOut](#easeElasticOut) for *t* in [0.5, 1]. + +[elasticInOut](https://observablehq.com/@d3/easing#elasticInOut) + +# elastic.amplitude(a) [<>](https://github.com/d3/d3-ease/blob/master/src/elastic.js#L40 "Source") + +Returns a new elastic easing with the specified amplitude *a*. + +# elastic.period(p) [<>](https://github.com/d3/d3-ease/blob/master/src/elastic.js#L41 "Source") + +Returns a new elastic easing with the specified period *p*. + +# d3.easeBackIn(t) [<>](https://github.com/d3/d3-ease/blob/master/src/back.js#L3 "Source") + +[Anticipatory](https://en.wikipedia.org/wiki/12_basic_principles_of_animation#Anticipation) easing, like a dancer bending his knees before jumping off the floor. The degree of [overshoot](#back_overshoot) is configurable; if not specified, it defaults to 1.70158. + +[backIn](https://observablehq.com/@d3/easing#backIn) + +# d3.easeBackOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/back.js#L15 "Source") + +Reverse anticipatory easing; equivalent to 1 - [backIn](#easeBackIn)(1 - *t*). + +[backOut](https://observablehq.com/@d3/easing#backOut) + +# d3.easeBack(t) [<>](https://github.com/d3/d3-ease/blob/master/src/back.js "Source") +
# d3.easeBackInOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/back.js#L27 "Source") + +Symmetric anticipatory easing; scales [backIn](#easeBackIn) for *t* in [0, 0.5] and [backOut](#easeBackOut) for *t* in [0.5, 1]. + +[backInOut](https://observablehq.com/@d3/easing#backInOut) + +# back.overshoot(s) [<>](https://github.com/d3/d3-ease/blob/master/src/back.js#L1 "Source") + +Returns a new back easing with the specified overshoot *s*. + +# d3.easeBounceIn(t) [<>](https://github.com/d3/d3-ease/blob/master/src/bounce.js#L12 "Source") + +Bounce easing, like a rubber ball. + +[bounceIn](https://observablehq.com/@d3/easing#bounceIn) + +# d3.easeBounce(t) [<>](https://github.com/d3/d3-ease/blob/master/src/bounce.js "Source") +
# d3.easeBounceOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/bounce.js#L16 "Source") + +Reverse bounce easing; equivalent to 1 - [bounceIn](#easeBounceIn)(1 - *t*). + +[bounceOut](https://observablehq.com/@d3/easing#bounceOut) + +# d3.easeBounceInOut(t) [<>](https://github.com/d3/d3-ease/blob/master/src/bounce.js#L20 "Source") + +Symmetric bounce easing; scales [bounceIn](#easeBounceIn) for *t* in [0, 0.5] and [bounceOut](#easeBounceOut) for *t* in [0.5, 1]. + +[bounceInOut](https://observablehq.com/@d3/easing#bounceInOut) Index: node_modules/d3-ease/dist/d3-ease.js =================================================================== --- node_modules/d3-ease/dist/d3-ease.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/dist/d3-ease.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,262 @@ +// https://d3js.org/d3-ease/ v3.0.1 Copyright 2010-2021 Mike Bostock, 2001 Robert Penner +(function (global, factory) { +typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : +typeof define === 'function' && define.amd ? define(['exports'], factory) : +(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.d3 = global.d3 || {})); +}(this, (function (exports) { 'use strict'; + +const linear = t => +t; + +function quadIn(t) { + return t * t; +} + +function quadOut(t) { + return t * (2 - t); +} + +function quadInOut(t) { + return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2; +} + +function cubicIn(t) { + return t * t * t; +} + +function cubicOut(t) { + return --t * t * t + 1; +} + +function cubicInOut(t) { + return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2; +} + +var exponent = 3; + +var polyIn = (function custom(e) { + e = +e; + + function polyIn(t) { + return Math.pow(t, e); + } + + polyIn.exponent = custom; + + return polyIn; +})(exponent); + +var polyOut = (function custom(e) { + e = +e; + + function polyOut(t) { + return 1 - Math.pow(1 - t, e); + } + + polyOut.exponent = custom; + + return polyOut; +})(exponent); + +var polyInOut = (function custom(e) { + e = +e; + + function polyInOut(t) { + return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2; + } + + polyInOut.exponent = custom; + + return polyInOut; +})(exponent); + +var pi = Math.PI, + halfPi = pi / 2; + +function sinIn(t) { + return (+t === 1) ? 1 : 1 - Math.cos(t * halfPi); +} + +function sinOut(t) { + return Math.sin(t * halfPi); +} + +function sinInOut(t) { + return (1 - Math.cos(pi * t)) / 2; +} + +// tpmt is two power minus ten times t scaled to [0,1] +function tpmt(x) { + return (Math.pow(2, -10 * x) - 0.0009765625) * 1.0009775171065494; +} + +function expIn(t) { + return tpmt(1 - +t); +} + +function expOut(t) { + return 1 - tpmt(t); +} + +function expInOut(t) { + return ((t *= 2) <= 1 ? tpmt(1 - t) : 2 - tpmt(t - 1)) / 2; +} + +function circleIn(t) { + return 1 - Math.sqrt(1 - t * t); +} + +function circleOut(t) { + return Math.sqrt(1 - --t * t); +} + +function circleInOut(t) { + return ((t *= 2) <= 1 ? 1 - Math.sqrt(1 - t * t) : Math.sqrt(1 - (t -= 2) * t) + 1) / 2; +} + +var b1 = 4 / 11, + b2 = 6 / 11, + b3 = 8 / 11, + b4 = 3 / 4, + b5 = 9 / 11, + b6 = 10 / 11, + b7 = 15 / 16, + b8 = 21 / 22, + b9 = 63 / 64, + b0 = 1 / b1 / b1; + +function bounceIn(t) { + return 1 - bounceOut(1 - t); +} + +function bounceOut(t) { + return (t = +t) < b1 ? b0 * t * t : t < b3 ? b0 * (t -= b2) * t + b4 : t < b6 ? b0 * (t -= b5) * t + b7 : b0 * (t -= b8) * t + b9; +} + +function bounceInOut(t) { + return ((t *= 2) <= 1 ? 1 - bounceOut(1 - t) : bounceOut(t - 1) + 1) / 2; +} + +var overshoot = 1.70158; + +var backIn = (function custom(s) { + s = +s; + + function backIn(t) { + return (t = +t) * t * (s * (t - 1) + t); + } + + backIn.overshoot = custom; + + return backIn; +})(overshoot); + +var backOut = (function custom(s) { + s = +s; + + function backOut(t) { + return --t * t * ((t + 1) * s + t) + 1; + } + + backOut.overshoot = custom; + + return backOut; +})(overshoot); + +var backInOut = (function custom(s) { + s = +s; + + function backInOut(t) { + return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2; + } + + backInOut.overshoot = custom; + + return backInOut; +})(overshoot); + +var tau = 2 * Math.PI, + amplitude = 1, + period = 0.3; + +var elasticIn = (function custom(a, p) { + var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); + + function elasticIn(t) { + return a * tpmt(-(--t)) * Math.sin((s - t) / p); + } + + elasticIn.amplitude = function(a) { return custom(a, p * tau); }; + elasticIn.period = function(p) { return custom(a, p); }; + + return elasticIn; +})(amplitude, period); + +var elasticOut = (function custom(a, p) { + var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); + + function elasticOut(t) { + return 1 - a * tpmt(t = +t) * Math.sin((t + s) / p); + } + + elasticOut.amplitude = function(a) { return custom(a, p * tau); }; + elasticOut.period = function(p) { return custom(a, p); }; + + return elasticOut; +})(amplitude, period); + +var elasticInOut = (function custom(a, p) { + var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); + + function elasticInOut(t) { + return ((t = t * 2 - 1) < 0 + ? a * tpmt(-t) * Math.sin((s - t) / p) + : 2 - a * tpmt(t) * Math.sin((s + t) / p)) / 2; + } + + elasticInOut.amplitude = function(a) { return custom(a, p * tau); }; + elasticInOut.period = function(p) { return custom(a, p); }; + + return elasticInOut; +})(amplitude, period); + +exports.easeBack = backInOut; +exports.easeBackIn = backIn; +exports.easeBackInOut = backInOut; +exports.easeBackOut = backOut; +exports.easeBounce = bounceOut; +exports.easeBounceIn = bounceIn; +exports.easeBounceInOut = bounceInOut; +exports.easeBounceOut = bounceOut; +exports.easeCircle = circleInOut; +exports.easeCircleIn = circleIn; +exports.easeCircleInOut = circleInOut; +exports.easeCircleOut = circleOut; +exports.easeCubic = cubicInOut; +exports.easeCubicIn = cubicIn; +exports.easeCubicInOut = cubicInOut; +exports.easeCubicOut = cubicOut; +exports.easeElastic = elasticOut; +exports.easeElasticIn = elasticIn; +exports.easeElasticInOut = elasticInOut; +exports.easeElasticOut = elasticOut; +exports.easeExp = expInOut; +exports.easeExpIn = expIn; +exports.easeExpInOut = expInOut; +exports.easeExpOut = expOut; +exports.easeLinear = linear; +exports.easePoly = polyInOut; +exports.easePolyIn = polyIn; +exports.easePolyInOut = polyInOut; +exports.easePolyOut = polyOut; +exports.easeQuad = quadInOut; +exports.easeQuadIn = quadIn; +exports.easeQuadInOut = quadInOut; +exports.easeQuadOut = quadOut; +exports.easeSin = sinInOut; +exports.easeSinIn = sinIn; +exports.easeSinInOut = sinInOut; +exports.easeSinOut = sinOut; + +Object.defineProperty(exports, '__esModule', { value: true }); + +}))); Index: node_modules/d3-ease/dist/d3-ease.min.js =================================================================== --- node_modules/d3-ease/dist/d3-ease.min.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/dist/d3-ease.min.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,2 @@ +// https://d3js.org/d3-ease/ v3.0.1 Copyright 2010-2021 Mike Bostock, 2001 Robert Penner +!function(n,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((n="undefined"!=typeof globalThis?globalThis:n||self).d3=n.d3||{})}(this,(function(n){"use strict";function e(n){return((n*=2)<=1?n*n:--n*(2-n)+1)/2}function t(n){return((n*=2)<=1?n*n*n:(n-=2)*n*n+2)/2}var u=function n(e){function t(n){return Math.pow(n,e)}return e=+e,t.exponent=n,t}(3),r=function n(e){function t(n){return 1-Math.pow(1-n,e)}return e=+e,t.exponent=n,t}(3),a=function n(e){function t(n){return((n*=2)<=1?Math.pow(n,e):2-Math.pow(2-n,e))/2}return e=+e,t.exponent=n,t}(3),o=Math.PI,i=o/2;function c(n){return(1-Math.cos(o*n))/2}function s(n){return 1.0009775171065494*(Math.pow(2,-10*n)-.0009765625)}function f(n){return((n*=2)<=1?s(1-n):2-s(n-1))/2}function h(n){return((n*=2)<=1?1-Math.sqrt(1-n*n):Math.sqrt(1-(n-=2)*n)+1)/2}var p=4/11,M=7.5625;function d(n){return(n=+n)+n,n.easePoly=a,n.easePolyIn=u,n.easePolyInOut=a,n.easePolyOut=r,n.easeQuad=e,n.easeQuadIn=function(n){return n*n},n.easeQuadInOut=e,n.easeQuadOut=function(n){return n*(2-n)},n.easeSin=c,n.easeSinIn=function(n){return 1==+n?1:1-Math.cos(n*i)},n.easeSinInOut=c,n.easeSinOut=function(n){return Math.sin(n*i)},Object.defineProperty(n,"__esModule",{value:!0})})); Index: node_modules/d3-ease/package.json =================================================================== --- node_modules/d3-ease/package.json (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/package.json (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,51 @@ +{ + "name": "d3-ease", + "version": "3.0.1", + "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", + "ease", + "easing", + "animation", + "transition" + ], + "license": "BSD-3-Clause", + "author": { + "name": "Mike Bostock", + "url": "http://bost.ocks.org/mike" + }, + "type": "module", + "files": [ + "dist/**/*.js", + "src/**/*.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": "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" + } +} Index: node_modules/d3-ease/src/back.js =================================================================== --- node_modules/d3-ease/src/back.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/src/back.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,37 @@ +var overshoot = 1.70158; + +export var backIn = (function custom(s) { + s = +s; + + function backIn(t) { + return (t = +t) * t * (s * (t - 1) + t); + } + + backIn.overshoot = custom; + + return backIn; +})(overshoot); + +export var backOut = (function custom(s) { + s = +s; + + function backOut(t) { + return --t * t * ((t + 1) * s + t) + 1; + } + + backOut.overshoot = custom; + + return backOut; +})(overshoot); + +export var backInOut = (function custom(s) { + s = +s; + + function backInOut(t) { + return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2; + } + + backInOut.overshoot = custom; + + return backInOut; +})(overshoot); Index: node_modules/d3-ease/src/bounce.js =================================================================== --- node_modules/d3-ease/src/bounce.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/src/bounce.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,22 @@ +var b1 = 4 / 11, + b2 = 6 / 11, + b3 = 8 / 11, + b4 = 3 / 4, + b5 = 9 / 11, + b6 = 10 / 11, + b7 = 15 / 16, + b8 = 21 / 22, + b9 = 63 / 64, + b0 = 1 / b1 / b1; + +export function bounceIn(t) { + return 1 - bounceOut(1 - t); +} + +export function bounceOut(t) { + return (t = +t) < b1 ? b0 * t * t : t < b3 ? b0 * (t -= b2) * t + b4 : t < b6 ? b0 * (t -= b5) * t + b7 : b0 * (t -= b8) * t + b9; +} + +export function bounceInOut(t) { + return ((t *= 2) <= 1 ? 1 - bounceOut(1 - t) : bounceOut(t - 1) + 1) / 2; +} Index: node_modules/d3-ease/src/circle.js =================================================================== --- node_modules/d3-ease/src/circle.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/src/circle.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,11 @@ +export function circleIn(t) { + return 1 - Math.sqrt(1 - t * t); +} + +export function circleOut(t) { + return Math.sqrt(1 - --t * t); +} + +export function circleInOut(t) { + return ((t *= 2) <= 1 ? 1 - Math.sqrt(1 - t * t) : Math.sqrt(1 - (t -= 2) * t) + 1) / 2; +} Index: node_modules/d3-ease/src/cubic.js =================================================================== --- node_modules/d3-ease/src/cubic.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/src/cubic.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,11 @@ +export function cubicIn(t) { + return t * t * t; +} + +export function cubicOut(t) { + return --t * t * t + 1; +} + +export function cubicInOut(t) { + return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2; +} Index: node_modules/d3-ease/src/elastic.js =================================================================== --- node_modules/d3-ease/src/elastic.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/src/elastic.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,46 @@ +import {tpmt} from "./math.js"; + +var tau = 2 * Math.PI, + amplitude = 1, + period = 0.3; + +export var elasticIn = (function custom(a, p) { + var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); + + function elasticIn(t) { + return a * tpmt(-(--t)) * Math.sin((s - t) / p); + } + + elasticIn.amplitude = function(a) { return custom(a, p * tau); }; + elasticIn.period = function(p) { return custom(a, p); }; + + return elasticIn; +})(amplitude, period); + +export var elasticOut = (function custom(a, p) { + var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); + + function elasticOut(t) { + return 1 - a * tpmt(t = +t) * Math.sin((t + s) / p); + } + + elasticOut.amplitude = function(a) { return custom(a, p * tau); }; + elasticOut.period = function(p) { return custom(a, p); }; + + return elasticOut; +})(amplitude, period); + +export var elasticInOut = (function custom(a, p) { + var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); + + function elasticInOut(t) { + return ((t = t * 2 - 1) < 0 + ? a * tpmt(-t) * Math.sin((s - t) / p) + : 2 - a * tpmt(t) * Math.sin((s + t) / p)) / 2; + } + + elasticInOut.amplitude = function(a) { return custom(a, p * tau); }; + elasticInOut.period = function(p) { return custom(a, p); }; + + return elasticInOut; +})(amplitude, period); Index: node_modules/d3-ease/src/exp.js =================================================================== --- node_modules/d3-ease/src/exp.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/src/exp.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,13 @@ +import {tpmt} from "./math.js"; + +export function expIn(t) { + return tpmt(1 - +t); +} + +export function expOut(t) { + return 1 - tpmt(t); +} + +export function expInOut(t) { + return ((t *= 2) <= 1 ? tpmt(1 - t) : 2 - tpmt(t - 1)) / 2; +} Index: node_modules/d3-ease/src/index.js =================================================================== --- node_modules/d3-ease/src/index.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/src/index.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,66 @@ +export { + linear as easeLinear +} from "./linear.js"; + +export { + quadInOut as easeQuad, + quadIn as easeQuadIn, + quadOut as easeQuadOut, + quadInOut as easeQuadInOut +} from "./quad.js"; + +export { + cubicInOut as easeCubic, + cubicIn as easeCubicIn, + cubicOut as easeCubicOut, + cubicInOut as easeCubicInOut +} from "./cubic.js"; + +export { + polyInOut as easePoly, + polyIn as easePolyIn, + polyOut as easePolyOut, + polyInOut as easePolyInOut +} from "./poly.js"; + +export { + sinInOut as easeSin, + sinIn as easeSinIn, + sinOut as easeSinOut, + sinInOut as easeSinInOut +} from "./sin.js"; + +export { + expInOut as easeExp, + expIn as easeExpIn, + expOut as easeExpOut, + expInOut as easeExpInOut +} from "./exp.js"; + +export { + circleInOut as easeCircle, + circleIn as easeCircleIn, + circleOut as easeCircleOut, + circleInOut as easeCircleInOut +} from "./circle.js"; + +export { + bounceOut as easeBounce, + bounceIn as easeBounceIn, + bounceOut as easeBounceOut, + bounceInOut as easeBounceInOut +} from "./bounce.js"; + +export { + backInOut as easeBack, + backIn as easeBackIn, + backOut as easeBackOut, + backInOut as easeBackInOut +} from "./back.js"; + +export { + elasticOut as easeElastic, + elasticIn as easeElasticIn, + elasticOut as easeElasticOut, + elasticInOut as easeElasticInOut +} from "./elastic.js"; Index: node_modules/d3-ease/src/linear.js =================================================================== --- node_modules/d3-ease/src/linear.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/src/linear.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,1 @@ +export const linear = t => +t; Index: node_modules/d3-ease/src/math.js =================================================================== --- node_modules/d3-ease/src/math.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/src/math.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,4 @@ +// tpmt is two power minus ten times t scaled to [0,1] +export function tpmt(x) { + return (Math.pow(2, -10 * x) - 0.0009765625) * 1.0009775171065494; +} Index: node_modules/d3-ease/src/poly.js =================================================================== --- node_modules/d3-ease/src/poly.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/src/poly.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,37 @@ +var exponent = 3; + +export var polyIn = (function custom(e) { + e = +e; + + function polyIn(t) { + return Math.pow(t, e); + } + + polyIn.exponent = custom; + + return polyIn; +})(exponent); + +export var polyOut = (function custom(e) { + e = +e; + + function polyOut(t) { + return 1 - Math.pow(1 - t, e); + } + + polyOut.exponent = custom; + + return polyOut; +})(exponent); + +export var polyInOut = (function custom(e) { + e = +e; + + function polyInOut(t) { + return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2; + } + + polyInOut.exponent = custom; + + return polyInOut; +})(exponent); Index: node_modules/d3-ease/src/quad.js =================================================================== --- node_modules/d3-ease/src/quad.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/src/quad.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,11 @@ +export function quadIn(t) { + return t * t; +} + +export function quadOut(t) { + return t * (2 - t); +} + +export function quadInOut(t) { + return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2; +} Index: node_modules/d3-ease/src/sin.js =================================================================== --- node_modules/d3-ease/src/sin.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) +++ node_modules/d3-ease/src/sin.js (revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a) @@ -0,0 +1,14 @@ +var pi = Math.PI, + halfPi = pi / 2; + +export function sinIn(t) { + return (+t === 1) ? 1 : 1 - Math.cos(t * halfPi); +} + +export function sinOut(t) { + return Math.sin(t * halfPi); +} + +export function sinInOut(t) { + return (1 - Math.cos(pi * t)) / 2; +}