mirror of
https://github.com/swc-project/swc.git
synced 2024-12-19 19:52:21 +03:00
877936f626
**Description:** As our minifier is two-pass by default, this is enough. At the first pass, we inline all numeric literals using sequential inliner, and minifier can then inline constants correctly in the second pass.
11003 lines
548 KiB
JavaScript
11003 lines
548 KiB
JavaScript
!function(global, factory) {
|
|
'object' == typeof exports && 'undefined' != typeof module ? factory(exports) : 'function' == typeof define && define.amd ? define([
|
|
'exports'
|
|
], factory) : factory((global = 'undefined' != typeof globalThis ? globalThis : global || self).d3 = global.d3 || {});
|
|
}(this, function(exports1) {
|
|
'use strict';
|
|
function ascending(a, b) {
|
|
return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
|
|
}
|
|
function bisector(f) {
|
|
var f1;
|
|
let delta = f, compare = f;
|
|
function left(a, x, lo, hi) {
|
|
for(null == lo && (lo = 0), null == hi && (hi = a.length); lo < hi;){
|
|
const mid = lo + hi >>> 1;
|
|
0 > compare(a[mid], x) ? lo = mid + 1 : hi = mid;
|
|
}
|
|
return lo;
|
|
}
|
|
return 1 === f.length && (delta = (d, x)=>f(d) - x, f1 = f, compare = (d, x)=>ascending(f1(d), x)), {
|
|
left,
|
|
center: function(a, x, lo, hi) {
|
|
null == lo && (lo = 0), null == hi && (hi = a.length);
|
|
const i = left(a, x, lo, hi - 1);
|
|
return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
|
|
},
|
|
right: function(a, x, lo, hi) {
|
|
for(null == lo && (lo = 0), null == hi && (hi = a.length); lo < hi;){
|
|
const mid = lo + hi >>> 1;
|
|
compare(a[mid], x) > 0 ? hi = mid : lo = mid + 1;
|
|
}
|
|
return lo;
|
|
}
|
|
};
|
|
}
|
|
function number(x) {
|
|
return null === x ? NaN : +x;
|
|
}
|
|
const ascendingBisect = bisector(ascending), bisectRight = ascendingBisect.right, bisectLeft = ascendingBisect.left, bisectCenter = bisector(number).center;
|
|
function count(values, valueof) {
|
|
let count = 0;
|
|
if (void 0 === valueof) for (let value of values)null != value && (value = +value) >= value && ++count;
|
|
else {
|
|
let index = -1;
|
|
for (let value1 of values)null != (value1 = valueof(value1, ++index, values)) && (value1 = +value1) >= value1 && ++count;
|
|
}
|
|
return count;
|
|
}
|
|
function length(array) {
|
|
return 0 | array.length;
|
|
}
|
|
function empty(length) {
|
|
return !(length > 0);
|
|
}
|
|
function arrayify(values) {
|
|
return "object" != typeof values || "length" in values ? values : Array.from(values);
|
|
}
|
|
function variance(values, valueof) {
|
|
let delta, count = 0, mean = 0, sum = 0;
|
|
if (void 0 === valueof) for (let value of values)null != value && (value = +value) >= value && (delta = value - mean, mean += delta / ++count, sum += delta * (value - mean));
|
|
else {
|
|
let index = -1;
|
|
for (let value1 of values)null != (value1 = valueof(value1, ++index, values)) && (value1 = +value1) >= value1 && (delta = value1 - mean, mean += delta / ++count, sum += delta * (value1 - mean));
|
|
}
|
|
if (count > 1) return sum / (count - 1);
|
|
}
|
|
function deviation(values, valueof) {
|
|
const v = variance(values, valueof);
|
|
return v ? Math.sqrt(v) : v;
|
|
}
|
|
function extent(values, valueof) {
|
|
let min, max;
|
|
if (void 0 === valueof) for (const value of values)null != value && (void 0 === min ? value >= value && (min = max = value) : (min > value && (min = value), max < value && (max = value)));
|
|
else {
|
|
let index = -1;
|
|
for (let value1 of values)null != (value1 = valueof(value1, ++index, values)) && (void 0 === min ? value1 >= value1 && (min = max = value1) : (min > value1 && (min = value1), max < value1 && (max = value1)));
|
|
}
|
|
return [
|
|
min,
|
|
max
|
|
];
|
|
}
|
|
class Adder {
|
|
constructor(){
|
|
this._partials = new Float64Array(32), this._n = 0;
|
|
}
|
|
add(x) {
|
|
const p = this._partials;
|
|
let i = 0;
|
|
for(let j = 0; j < this._n && j < 32; j++){
|
|
const y = p[j], hi = x + y, lo = Math.abs(x) < Math.abs(y) ? x - (hi - y) : y - (hi - x);
|
|
lo && (p[i++] = lo), x = hi;
|
|
}
|
|
return p[i] = x, this._n = i + 1, this;
|
|
}
|
|
valueOf() {
|
|
const p = this._partials;
|
|
let n = this._n, x, y, lo, hi = 0;
|
|
if (n > 0) {
|
|
for(hi = p[--n]; n > 0 && (hi = (x = hi) + (y = p[--n]), !(lo = y - (hi - x))););
|
|
n > 0 && (lo < 0 && p[n - 1] < 0 || lo > 0 && p[n - 1] > 0) && (x = hi + (y = 2 * lo), y == x - hi && (hi = x));
|
|
}
|
|
return hi;
|
|
}
|
|
}
|
|
function identity(x) {
|
|
return x;
|
|
}
|
|
function unique(values) {
|
|
if (1 !== values.length) throw Error("duplicate key");
|
|
return values[0];
|
|
}
|
|
function nest(values, map, reduce, keys) {
|
|
return function regroup(values, i) {
|
|
if (i >= keys.length) return reduce(values);
|
|
const groups = new Map(), keyof = keys[i++];
|
|
let index = -1;
|
|
for (const value of values){
|
|
const key = keyof(value, ++index, values), group = groups.get(key);
|
|
group ? group.push(value) : groups.set(key, [
|
|
value
|
|
]);
|
|
}
|
|
for (const [key1, values1] of groups)groups.set(key1, regroup(values1, i));
|
|
return map(groups);
|
|
}(values, 0);
|
|
}
|
|
var slice = Array.prototype.slice;
|
|
function constant(x) {
|
|
return function() {
|
|
return x;
|
|
};
|
|
}
|
|
var e10 = Math.sqrt(50), e5 = Math.sqrt(10), e2 = Math.sqrt(2);
|
|
function ticks(start, stop, count) {
|
|
var reverse, n, ticks, step, i = -1;
|
|
if (count = +count, (start = +start) == (stop = +stop) && count > 0) return [
|
|
start
|
|
];
|
|
if ((reverse = stop < start) && (n = start, start = stop, stop = n), 0 === (step = tickIncrement(start, stop, count)) || !isFinite(step)) return [];
|
|
if (step > 0) for(start = Math.ceil(start / step), ticks = Array(n = Math.ceil((stop = Math.floor(stop / step)) - start + 1)); ++i < n;)ticks[i] = (start + i) * step;
|
|
else for(start = Math.ceil(start * (step = -step)), ticks = Array(n = Math.ceil((stop = Math.floor(stop * step)) - start + 1)); ++i < n;)ticks[i] = (start + i) / step;
|
|
return reverse && ticks.reverse(), ticks;
|
|
}
|
|
function tickIncrement(start, stop, count) {
|
|
var step = (stop - start) / Math.max(0, count), power = Math.floor(Math.log(step) / Math.LN10), error = step / Math.pow(10, power);
|
|
return power >= 0 ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power) : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);
|
|
}
|
|
function tickStep(start, stop, count) {
|
|
var step0 = Math.abs(stop - start) / Math.max(0, count), step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)), error = step0 / step1;
|
|
return error >= e10 ? step1 *= 10 : error >= e5 ? step1 *= 5 : error >= e2 && (step1 *= 2), stop < start ? -step1 : step1;
|
|
}
|
|
function nice(start, stop, count) {
|
|
let prestep;
|
|
for(;;){
|
|
const step = tickIncrement(start, stop, count);
|
|
if (step === prestep || 0 === step || !isFinite(step)) return [
|
|
start,
|
|
stop
|
|
];
|
|
step > 0 ? (start = Math.floor(start / step) * step, stop = Math.ceil(stop / step) * step) : step < 0 && (start = Math.ceil(start * step) / step, stop = Math.floor(stop * step) / step), prestep = step;
|
|
}
|
|
}
|
|
function thresholdSturges(values) {
|
|
return Math.ceil(Math.log(count(values)) / Math.LN2) + 1;
|
|
}
|
|
function bin() {
|
|
var value = identity, domain = extent, threshold = thresholdSturges;
|
|
function histogram(data) {
|
|
Array.isArray(data) || (data = Array.from(data));
|
|
var i, x, n = data.length, values = Array(n);
|
|
for(i = 0; i < n; ++i)values[i] = value(data[i], i, data);
|
|
var xz = domain(values), x0 = xz[0], x1 = xz[1], tz = threshold(values, x0, x1);
|
|
if (!Array.isArray(tz)) {
|
|
const max = x1, tn = +tz;
|
|
if (domain === extent && ([x0, x1] = nice(x0, x1, tn)), (tz = ticks(x0, x1, tn))[tz.length - 1] >= x1) {
|
|
if (max >= x1 && domain === extent) {
|
|
const step = tickIncrement(x0, x1, tn);
|
|
isFinite(step) && (step > 0 ? x1 = (Math.floor(x1 / step) + 1) * step : step < 0 && (x1 = -((Math.ceil(-(x1 * step)) + 1) / step)));
|
|
} else tz.pop();
|
|
}
|
|
}
|
|
for(var m = tz.length; tz[0] <= x0;)tz.shift(), --m;
|
|
for(; tz[m - 1] > x1;)tz.pop(), --m;
|
|
var bin, bins = Array(m + 1);
|
|
for(i = 0; i <= m; ++i)(bin = bins[i] = []).x0 = i > 0 ? tz[i - 1] : x0, bin.x1 = i < m ? tz[i] : x1;
|
|
for(i = 0; i < n; ++i)x0 <= (x = values[i]) && x <= x1 && bins[bisectRight(tz, x, 0, m)].push(data[i]);
|
|
return bins;
|
|
}
|
|
return histogram.value = function(_) {
|
|
return arguments.length ? (value = "function" == typeof _ ? _ : constant(_), histogram) : value;
|
|
}, histogram.domain = function(_) {
|
|
return arguments.length ? (domain = "function" == typeof _ ? _ : constant([
|
|
_[0],
|
|
_[1]
|
|
]), histogram) : domain;
|
|
}, histogram.thresholds = function(_) {
|
|
return arguments.length ? (threshold = "function" == typeof _ ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold;
|
|
}, histogram;
|
|
}
|
|
function max(values, valueof) {
|
|
let max;
|
|
if (void 0 === valueof) for (const value of values)null != value && (max < value || void 0 === max && value >= value) && (max = value);
|
|
else {
|
|
let index = -1;
|
|
for (let value1 of values)null != (value1 = valueof(value1, ++index, values)) && (max < value1 || void 0 === max && value1 >= value1) && (max = value1);
|
|
}
|
|
return max;
|
|
}
|
|
function min(values, valueof) {
|
|
let min;
|
|
if (void 0 === valueof) for (const value of values)null != value && (min > value || void 0 === min && value >= value) && (min = value);
|
|
else {
|
|
let index = -1;
|
|
for (let value1 of values)null != (value1 = valueof(value1, ++index, values)) && (min > value1 || void 0 === min && value1 >= value1) && (min = value1);
|
|
}
|
|
return min;
|
|
}
|
|
function quickselect(array, k, left = 0, right = array.length - 1, compare = ascending) {
|
|
for(; right > left;){
|
|
if (right - left > 600) {
|
|
const n = right - left + 1, m = k - left + 1, z = Math.log(n), s = 0.5 * Math.exp(2 * z / 3), sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1), newLeft = Math.max(left, Math.floor(k - m * s / n + sd)), newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
|
|
quickselect(array, k, newLeft, newRight, compare);
|
|
}
|
|
const t = array[k];
|
|
let i = left, j = right;
|
|
for(swap(array, left, k), compare(array[right], t) > 0 && swap(array, left, right); i < j;){
|
|
for(swap(array, i, j), ++i, --j; 0 > compare(array[i], t);)++i;
|
|
for(; compare(array[j], t) > 0;)--j;
|
|
}
|
|
0 === compare(array[left], t) ? swap(array, left, j) : swap(array, ++j, right), j <= k && (left = j + 1), k <= j && (right = j - 1);
|
|
}
|
|
return array;
|
|
}
|
|
function swap(array, i, j) {
|
|
const t = array[i];
|
|
array[i] = array[j], array[j] = t;
|
|
}
|
|
function quantile(values, p, valueof) {
|
|
if (n = (values = Float64Array.from(function*(values, valueof) {
|
|
if (void 0 === valueof) for (let value of values)null != value && (value = +value) >= value && (yield value);
|
|
else {
|
|
let index = -1;
|
|
for (let value1 of values)null != (value1 = valueof(value1, ++index, values)) && (value1 = +value1) >= value1 && (yield value1);
|
|
}
|
|
}(values, valueof))).length) {
|
|
if ((p = +p) <= 0 || n < 2) return min(values);
|
|
if (p >= 1) return max(values);
|
|
var n, i = (n - 1) * p, i0 = Math.floor(i), value0 = max(quickselect(values, i0).subarray(0, i0 + 1)), value1 = min(values.subarray(i0 + 1));
|
|
return value0 + (value1 - value0) * (i - i0);
|
|
}
|
|
}
|
|
function quantileSorted(values, p, valueof = number) {
|
|
if (n = values.length) {
|
|
if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);
|
|
if (p >= 1) return +valueof(values[n - 1], n - 1, values);
|
|
var n, i = (n - 1) * p, i0 = Math.floor(i), value0 = +valueof(values[i0], i0, values), value1 = +valueof(values[i0 + 1], i0 + 1, values);
|
|
return value0 + (value1 - value0) * (i - i0);
|
|
}
|
|
}
|
|
function maxIndex(values, valueof) {
|
|
let max;
|
|
let maxIndex = -1, index = -1;
|
|
if (void 0 === valueof) for (const value of values)++index, null != value && (max < value || void 0 === max && value >= value) && (max = value, maxIndex = index);
|
|
else for (let value1 of values)null != (value1 = valueof(value1, ++index, values)) && (max < value1 || void 0 === max && value1 >= value1) && (max = value1, maxIndex = index);
|
|
return maxIndex;
|
|
}
|
|
function merge(arrays) {
|
|
return Array.from(function*(arrays) {
|
|
for (const array of arrays)yield* array;
|
|
}(arrays));
|
|
}
|
|
function minIndex(values, valueof) {
|
|
let min;
|
|
let minIndex = -1, index = -1;
|
|
if (void 0 === valueof) for (const value of values)++index, null != value && (min > value || void 0 === min && value >= value) && (min = value, minIndex = index);
|
|
else for (let value1 of values)null != (value1 = valueof(value1, ++index, values)) && (min > value1 || void 0 === min && value1 >= value1) && (min = value1, minIndex = index);
|
|
return minIndex;
|
|
}
|
|
function pair(a, b) {
|
|
return [
|
|
a,
|
|
b
|
|
];
|
|
}
|
|
function permute(source, keys) {
|
|
return Array.from(keys, (key)=>source[key]);
|
|
}
|
|
function sequence(start, stop, step) {
|
|
start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
|
|
for(var i = -1, n = 0 | Math.max(0, Math.ceil((stop - start) / step)), range = Array(n); ++i < n;)range[i] = start + i * step;
|
|
return range;
|
|
}
|
|
function leastIndex(values, compare = ascending) {
|
|
let minValue;
|
|
if (1 === compare.length) return minIndex(values, compare);
|
|
let min = -1, index = -1;
|
|
for (const value of values)++index, (min < 0 ? 0 === compare(value, value) : 0 > compare(value, minValue)) && (minValue = value, min = index);
|
|
return min;
|
|
}
|
|
var shuffle = shuffler(Math.random);
|
|
function shuffler(random) {
|
|
return function(array, i0 = 0, i1 = array.length) {
|
|
let m = i1 - (i0 = +i0);
|
|
for(; m;){
|
|
const i = random() * m-- | 0, t = array[m + i0];
|
|
array[m + i0] = array[i + i0], array[i + i0] = t;
|
|
}
|
|
return array;
|
|
};
|
|
}
|
|
function transpose(matrix) {
|
|
if (!(n = matrix.length)) return [];
|
|
for(var i = -1, m = min(matrix, length$1), transpose = Array(m); ++i < m;)for(var n, j = -1, row = transpose[i] = Array(n); ++j < n;)row[j] = matrix[j][i];
|
|
return transpose;
|
|
}
|
|
function length$1(d) {
|
|
return d.length;
|
|
}
|
|
function set(values) {
|
|
return values instanceof Set ? values : new Set(values);
|
|
}
|
|
function superset(values, other) {
|
|
const iterator = values[Symbol.iterator](), set = new Set();
|
|
for (const o of other){
|
|
let value, done;
|
|
if (!set.has(o)) for(; { value , done } = iterator.next();){
|
|
if (done) return !1;
|
|
if (set.add(value), Object.is(o, value)) break;
|
|
}
|
|
}
|
|
return !0;
|
|
}
|
|
var slice$1 = Array.prototype.slice;
|
|
function identity$1(x) {
|
|
return x;
|
|
}
|
|
function translateX(x) {
|
|
return "translate(" + (x + 0.5) + ",0)";
|
|
}
|
|
function translateY(y) {
|
|
return "translate(0," + (y + 0.5) + ")";
|
|
}
|
|
function number$1(scale) {
|
|
return (d)=>+scale(d);
|
|
}
|
|
function center(scale) {
|
|
var offset = Math.max(0, scale.bandwidth() - 1) / 2;
|
|
return scale.round() && (offset = Math.round(offset)), function(d) {
|
|
return +scale(d) + offset;
|
|
};
|
|
}
|
|
function entering() {
|
|
return !this.__axis;
|
|
}
|
|
function axis(orient, scale) {
|
|
var tickArguments = [], tickValues = null, tickFormat = null, tickSizeInner = 6, tickSizeOuter = 6, tickPadding = 3, k = 1 === orient || 4 === orient ? -1 : 1, x = 4 === orient || 2 === orient ? "x" : "y", transform = 1 === orient || 3 === orient ? translateX : translateY;
|
|
function axis(context) {
|
|
var values = null == tickValues ? scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain() : tickValues, format = null == tickFormat ? scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : identity$1 : tickFormat, spacing = Math.max(tickSizeInner, 0) + tickPadding, range = scale.range(), range0 = +range[0] + 0.5, range1 = +range[range.length - 1] + 0.5, position = (scale.bandwidth ? center : number$1)(scale.copy()), selection = context.selection ? context.selection() : context, path = selection.selectAll(".domain").data([
|
|
null
|
|
]), tick = selection.selectAll(".tick").data(values, scale).order(), tickExit = tick.exit(), tickEnter = tick.enter().append("g").attr("class", "tick"), line = tick.select("line"), text = tick.select("text");
|
|
path = path.merge(path.enter().insert("path", ".tick").attr("class", "domain").attr("stroke", "currentColor")), tick = tick.merge(tickEnter), line = line.merge(tickEnter.append("line").attr("stroke", "currentColor").attr(x + "2", k * tickSizeInner)), text = text.merge(tickEnter.append("text").attr("fill", "currentColor").attr(x, k * spacing).attr("dy", 1 === orient ? "0em" : 3 === orient ? "0.71em" : "0.32em")), context !== selection && (path = path.transition(context), tick = tick.transition(context), line = line.transition(context), text = text.transition(context), tickExit = tickExit.transition(context).attr("opacity", 1e-6).attr("transform", function(d) {
|
|
return isFinite(d = position(d)) ? transform(d) : this.getAttribute("transform");
|
|
}), tickEnter.attr("opacity", 1e-6).attr("transform", function(d) {
|
|
var p = this.parentNode.__axis;
|
|
return transform(p && isFinite(p = p(d)) ? p : position(d));
|
|
})), tickExit.remove(), path.attr("d", 4 === orient || 2 == orient ? tickSizeOuter ? "M" + k * tickSizeOuter + "," + range0 + "H0.5V" + range1 + "H" + k * tickSizeOuter : "M0.5," + range0 + "V" + range1 : tickSizeOuter ? "M" + range0 + "," + k * tickSizeOuter + "V0.5H" + range1 + "V" + k * tickSizeOuter : "M" + range0 + ",0.5H" + range1), tick.attr("opacity", 1).attr("transform", function(d) {
|
|
return transform(position(d));
|
|
}), line.attr(x + "2", k * tickSizeInner), text.attr(x, k * spacing).text(format), selection.filter(entering).attr("fill", "none").attr("font-size", 10).attr("font-family", "sans-serif").attr("text-anchor", 2 === orient ? "start" : 4 === orient ? "end" : "middle"), selection.each(function() {
|
|
this.__axis = position;
|
|
});
|
|
}
|
|
return axis.scale = function(_) {
|
|
return arguments.length ? (scale = _, axis) : scale;
|
|
}, axis.ticks = function() {
|
|
return tickArguments = slice$1.call(arguments), axis;
|
|
}, axis.tickArguments = function(_) {
|
|
return arguments.length ? (tickArguments = null == _ ? [] : slice$1.call(_), axis) : tickArguments.slice();
|
|
}, axis.tickValues = function(_) {
|
|
return arguments.length ? (tickValues = null == _ ? null : slice$1.call(_), axis) : tickValues && tickValues.slice();
|
|
}, axis.tickFormat = function(_) {
|
|
return arguments.length ? (tickFormat = _, axis) : tickFormat;
|
|
}, axis.tickSize = function(_) {
|
|
return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis) : tickSizeInner;
|
|
}, axis.tickSizeInner = function(_) {
|
|
return arguments.length ? (tickSizeInner = +_, axis) : tickSizeInner;
|
|
}, axis.tickSizeOuter = function(_) {
|
|
return arguments.length ? (tickSizeOuter = +_, axis) : tickSizeOuter;
|
|
}, axis.tickPadding = function(_) {
|
|
return arguments.length ? (tickPadding = +_, axis) : tickPadding;
|
|
}, axis;
|
|
}
|
|
var noop = {
|
|
value () {}
|
|
};
|
|
function dispatch() {
|
|
for(var t, i = 0, n = arguments.length, _ = {}; i < n; ++i){
|
|
if (!(t = arguments[i] + "") || t in _ || /[\s.]/.test(t)) throw Error("illegal type: " + t);
|
|
_[t] = [];
|
|
}
|
|
return new Dispatch(_);
|
|
}
|
|
function Dispatch(_) {
|
|
this._ = _;
|
|
}
|
|
function set$1(type, name, callback) {
|
|
for(var i = 0, n = type.length; i < n; ++i)if (type[i].name === name) {
|
|
type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1));
|
|
break;
|
|
}
|
|
return null != callback && type.push({
|
|
name: name,
|
|
value: callback
|
|
}), type;
|
|
}
|
|
Dispatch.prototype = dispatch.prototype = {
|
|
constructor: Dispatch,
|
|
on: function(typename, callback) {
|
|
var typenames, types, t, _ = this._, T = (typenames = typename + "").trim().split(/^|\s+/).map(function(t) {
|
|
var name = "", i = t.indexOf(".");
|
|
if (i >= 0 && (name = t.slice(i + 1), t = t.slice(0, i)), t && !_.hasOwnProperty(t)) throw Error("unknown type: " + t);
|
|
return {
|
|
type: t,
|
|
name: name
|
|
};
|
|
}), i = -1, n = T.length;
|
|
if (arguments.length < 2) {
|
|
for(; ++i < n;)if ((t = (typename = T[i]).type) && (t = function(type, name) {
|
|
for(var c, i = 0, n = type.length; i < n; ++i)if ((c = type[i]).name === name) return c.value;
|
|
}(_[t], typename.name))) return t;
|
|
return;
|
|
}
|
|
if (null != callback && "function" != typeof callback) throw Error("invalid callback: " + callback);
|
|
for(; ++i < n;)if (t = (typename = T[i]).type) _[t] = set$1(_[t], typename.name, callback);
|
|
else if (null == callback) for(t in _)_[t] = set$1(_[t], typename.name, null);
|
|
return this;
|
|
},
|
|
copy: function() {
|
|
var copy = {}, _ = this._;
|
|
for(var t in _)copy[t] = _[t].slice();
|
|
return new Dispatch(copy);
|
|
},
|
|
call: function(type, that) {
|
|
if ((n = arguments.length - 2) > 0) for(var n, t, args = Array(n), i = 0; i < n; ++i)args[i] = arguments[i + 2];
|
|
if (!this._.hasOwnProperty(type)) throw Error("unknown type: " + type);
|
|
for(t = this._[type], i = 0, n = t.length; i < n; ++i)t[i].value.apply(that, args);
|
|
},
|
|
apply: function(type, that, args) {
|
|
if (!this._.hasOwnProperty(type)) throw Error("unknown type: " + type);
|
|
for(var t = this._[type], i = 0, n = t.length; i < n; ++i)t[i].value.apply(that, args);
|
|
}
|
|
};
|
|
var xhtml = "http://www.w3.org/1999/xhtml", namespaces = {
|
|
svg: "http://www.w3.org/2000/svg",
|
|
xhtml: xhtml,
|
|
xlink: "http://www.w3.org/1999/xlink",
|
|
xml: "http://www.w3.org/XML/1998/namespace",
|
|
xmlns: "http://www.w3.org/2000/xmlns/"
|
|
};
|
|
function namespace(name) {
|
|
var prefix = name += "", i = prefix.indexOf(":");
|
|
return i >= 0 && "xmlns" !== (prefix = name.slice(0, i)) && (name = name.slice(i + 1)), namespaces.hasOwnProperty(prefix) ? {
|
|
space: namespaces[prefix],
|
|
local: name
|
|
} : name;
|
|
}
|
|
function creatorInherit(name) {
|
|
return function() {
|
|
var document1 = this.ownerDocument, uri = this.namespaceURI;
|
|
return uri === xhtml && document1.documentElement.namespaceURI === xhtml ? document1.createElement(name) : document1.createElementNS(uri, name);
|
|
};
|
|
}
|
|
function creatorFixed(fullname) {
|
|
return function() {
|
|
return this.ownerDocument.createElementNS(fullname.space, fullname.local);
|
|
};
|
|
}
|
|
function creator(name) {
|
|
var fullname = namespace(name);
|
|
return (fullname.local ? creatorFixed : creatorInherit)(fullname);
|
|
}
|
|
function none() {}
|
|
function selector(selector) {
|
|
return null == selector ? none : function() {
|
|
return this.querySelector(selector);
|
|
};
|
|
}
|
|
function array$1(x) {
|
|
return "object" == typeof x && "length" in x ? x : Array.from(x);
|
|
}
|
|
function empty$1() {
|
|
return [];
|
|
}
|
|
function selectorAll(selector) {
|
|
return null == selector ? empty$1 : function() {
|
|
return this.querySelectorAll(selector);
|
|
};
|
|
}
|
|
function matcher(selector) {
|
|
return function() {
|
|
return this.matches(selector);
|
|
};
|
|
}
|
|
function childMatcher(selector) {
|
|
return function(node) {
|
|
return node.matches(selector);
|
|
};
|
|
}
|
|
var find = Array.prototype.find;
|
|
function childFirst() {
|
|
return this.firstElementChild;
|
|
}
|
|
var filter$1 = Array.prototype.filter;
|
|
function children() {
|
|
return this.children;
|
|
}
|
|
function sparse(update) {
|
|
return Array(update.length);
|
|
}
|
|
function EnterNode(parent, datum) {
|
|
this.ownerDocument = parent.ownerDocument, this.namespaceURI = parent.namespaceURI, this._next = null, this._parent = parent, this.__data__ = datum;
|
|
}
|
|
function bindIndex(parent, group, enter, update, exit, data) {
|
|
for(var node, i = 0, groupLength = group.length, dataLength = data.length; i < dataLength; ++i)(node = group[i]) ? (node.__data__ = data[i], update[i] = node) : enter[i] = new EnterNode(parent, data[i]);
|
|
for(; i < groupLength; ++i)(node = group[i]) && (exit[i] = node);
|
|
}
|
|
function bindKey(parent, group, enter, update, exit, data, key) {
|
|
var i, node, keyValue, nodeByKeyValue = new Map, groupLength = group.length, dataLength = data.length, keyValues = Array(groupLength);
|
|
for(i = 0; i < groupLength; ++i)(node = group[i]) && (keyValues[i] = keyValue = key.call(node, node.__data__, i, group) + "", nodeByKeyValue.has(keyValue) ? exit[i] = node : nodeByKeyValue.set(keyValue, node));
|
|
for(i = 0; i < dataLength; ++i)keyValue = key.call(parent, data[i], i, data) + "", (node = nodeByKeyValue.get(keyValue)) ? (update[i] = node, node.__data__ = data[i], nodeByKeyValue.delete(keyValue)) : enter[i] = new EnterNode(parent, data[i]);
|
|
for(i = 0; i < groupLength; ++i)(node = group[i]) && nodeByKeyValue.get(keyValues[i]) === node && (exit[i] = node);
|
|
}
|
|
function datum(node) {
|
|
return node.__data__;
|
|
}
|
|
function ascending$1(a, b) {
|
|
return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
|
|
}
|
|
function attrRemove(name) {
|
|
return function() {
|
|
this.removeAttribute(name);
|
|
};
|
|
}
|
|
function attrRemoveNS(fullname) {
|
|
return function() {
|
|
this.removeAttributeNS(fullname.space, fullname.local);
|
|
};
|
|
}
|
|
function attrConstant(name, value) {
|
|
return function() {
|
|
this.setAttribute(name, value);
|
|
};
|
|
}
|
|
function attrConstantNS(fullname, value) {
|
|
return function() {
|
|
this.setAttributeNS(fullname.space, fullname.local, value);
|
|
};
|
|
}
|
|
function attrFunction(name, value) {
|
|
return function() {
|
|
var v = value.apply(this, arguments);
|
|
null == v ? this.removeAttribute(name) : this.setAttribute(name, v);
|
|
};
|
|
}
|
|
function attrFunctionNS(fullname, value) {
|
|
return function() {
|
|
var v = value.apply(this, arguments);
|
|
null == v ? this.removeAttributeNS(fullname.space, fullname.local) : this.setAttributeNS(fullname.space, fullname.local, v);
|
|
};
|
|
}
|
|
function defaultView(node) {
|
|
return node.ownerDocument && node.ownerDocument.defaultView || node.document && node || node.defaultView;
|
|
}
|
|
function styleRemove(name) {
|
|
return function() {
|
|
this.style.removeProperty(name);
|
|
};
|
|
}
|
|
function styleConstant(name, value, priority) {
|
|
return function() {
|
|
this.style.setProperty(name, value, priority);
|
|
};
|
|
}
|
|
function styleFunction(name, value, priority) {
|
|
return function() {
|
|
var v = value.apply(this, arguments);
|
|
null == v ? this.style.removeProperty(name) : this.style.setProperty(name, v, priority);
|
|
};
|
|
}
|
|
function styleValue(node, name) {
|
|
return node.style.getPropertyValue(name) || defaultView(node).getComputedStyle(node, null).getPropertyValue(name);
|
|
}
|
|
function propertyRemove(name) {
|
|
return function() {
|
|
delete this[name];
|
|
};
|
|
}
|
|
function propertyConstant(name, value) {
|
|
return function() {
|
|
this[name] = value;
|
|
};
|
|
}
|
|
function propertyFunction(name, value) {
|
|
return function() {
|
|
var v = value.apply(this, arguments);
|
|
null == v ? delete this[name] : this[name] = v;
|
|
};
|
|
}
|
|
function classArray(string) {
|
|
return string.trim().split(/^|\s+/);
|
|
}
|
|
function classList(node) {
|
|
return node.classList || new ClassList(node);
|
|
}
|
|
function ClassList(node) {
|
|
this._node = node, this._names = classArray(node.getAttribute("class") || "");
|
|
}
|
|
function classedAdd(node, names) {
|
|
for(var list = classList(node), i = -1, n = names.length; ++i < n;)list.add(names[i]);
|
|
}
|
|
function classedRemove(node, names) {
|
|
for(var list = classList(node), i = -1, n = names.length; ++i < n;)list.remove(names[i]);
|
|
}
|
|
function classedTrue(names) {
|
|
return function() {
|
|
classedAdd(this, names);
|
|
};
|
|
}
|
|
function classedFalse(names) {
|
|
return function() {
|
|
classedRemove(this, names);
|
|
};
|
|
}
|
|
function classedFunction(names, value) {
|
|
return function() {
|
|
(value.apply(this, arguments) ? classedAdd : classedRemove)(this, names);
|
|
};
|
|
}
|
|
function textRemove() {
|
|
this.textContent = "";
|
|
}
|
|
function textConstant(value) {
|
|
return function() {
|
|
this.textContent = value;
|
|
};
|
|
}
|
|
function textFunction(value) {
|
|
return function() {
|
|
var v = value.apply(this, arguments);
|
|
this.textContent = null == v ? "" : v;
|
|
};
|
|
}
|
|
function htmlRemove() {
|
|
this.innerHTML = "";
|
|
}
|
|
function htmlConstant(value) {
|
|
return function() {
|
|
this.innerHTML = value;
|
|
};
|
|
}
|
|
function htmlFunction(value) {
|
|
return function() {
|
|
var v = value.apply(this, arguments);
|
|
this.innerHTML = null == v ? "" : v;
|
|
};
|
|
}
|
|
function raise() {
|
|
this.nextSibling && this.parentNode.appendChild(this);
|
|
}
|
|
function lower() {
|
|
this.previousSibling && this.parentNode.insertBefore(this, this.parentNode.firstChild);
|
|
}
|
|
function constantNull() {
|
|
return null;
|
|
}
|
|
function remove() {
|
|
var parent = this.parentNode;
|
|
parent && parent.removeChild(this);
|
|
}
|
|
function selection_cloneShallow() {
|
|
var clone = this.cloneNode(!1), parent = this.parentNode;
|
|
return parent ? parent.insertBefore(clone, this.nextSibling) : clone;
|
|
}
|
|
function selection_cloneDeep() {
|
|
var clone = this.cloneNode(!0), parent = this.parentNode;
|
|
return parent ? parent.insertBefore(clone, this.nextSibling) : clone;
|
|
}
|
|
function onRemove(typename) {
|
|
return function() {
|
|
var on = this.__on;
|
|
if (on) {
|
|
for(var o, j = 0, i = -1, m = on.length; j < m; ++j)(o = on[j], typename.type && o.type !== typename.type || o.name !== typename.name) ? on[++i] = o : this.removeEventListener(o.type, o.listener, o.options);
|
|
++i ? on.length = i : delete this.__on;
|
|
}
|
|
};
|
|
}
|
|
function onAdd(typename, value, options) {
|
|
return function() {
|
|
var listener, o, on = this.__on, listener1 = function(event) {
|
|
value.call(this, event, this.__data__);
|
|
};
|
|
if (on) {
|
|
for(var j = 0, m = on.length; j < m; ++j)if ((o = on[j]).type === typename.type && o.name === typename.name) {
|
|
this.removeEventListener(o.type, o.listener, o.options), this.addEventListener(o.type, o.listener = listener1, o.options = options), o.value = value;
|
|
return;
|
|
}
|
|
}
|
|
this.addEventListener(typename.type, listener1, options), o = {
|
|
type: typename.type,
|
|
name: typename.name,
|
|
value: value,
|
|
listener: listener1,
|
|
options: options
|
|
}, on ? on.push(o) : this.__on = [
|
|
o
|
|
];
|
|
};
|
|
}
|
|
function dispatchEvent(node, type, params) {
|
|
var window1 = defaultView(node), event = window1.CustomEvent;
|
|
"function" == typeof event ? event = new event(type, params) : (event = window1.document.createEvent("Event"), params ? (event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail) : event.initEvent(type, !1, !1)), node.dispatchEvent(event);
|
|
}
|
|
function dispatchConstant(type, params) {
|
|
return function() {
|
|
return dispatchEvent(this, type, params);
|
|
};
|
|
}
|
|
function dispatchFunction(type, params) {
|
|
return function() {
|
|
return dispatchEvent(this, type, params.apply(this, arguments));
|
|
};
|
|
}
|
|
EnterNode.prototype = {
|
|
constructor: EnterNode,
|
|
appendChild: function(child) {
|
|
return this._parent.insertBefore(child, this._next);
|
|
},
|
|
insertBefore: function(child, next) {
|
|
return this._parent.insertBefore(child, next);
|
|
},
|
|
querySelector: function(selector) {
|
|
return this._parent.querySelector(selector);
|
|
},
|
|
querySelectorAll: function(selector) {
|
|
return this._parent.querySelectorAll(selector);
|
|
}
|
|
}, ClassList.prototype = {
|
|
add: function(name) {
|
|
0 > this._names.indexOf(name) && (this._names.push(name), this._node.setAttribute("class", this._names.join(" ")));
|
|
},
|
|
remove: function(name) {
|
|
var i = this._names.indexOf(name);
|
|
i >= 0 && (this._names.splice(i, 1), this._node.setAttribute("class", this._names.join(" ")));
|
|
},
|
|
contains: function(name) {
|
|
return this._names.indexOf(name) >= 0;
|
|
}
|
|
};
|
|
var root = [
|
|
null
|
|
];
|
|
function Selection(groups, parents) {
|
|
this._groups = groups, this._parents = parents;
|
|
}
|
|
function selection() {
|
|
return new Selection([
|
|
[
|
|
document.documentElement
|
|
]
|
|
], root);
|
|
}
|
|
function select(selector) {
|
|
return "string" == typeof selector ? new Selection([
|
|
[
|
|
document.querySelector(selector)
|
|
]
|
|
], [
|
|
document.documentElement
|
|
]) : new Selection([
|
|
[
|
|
selector
|
|
]
|
|
], root);
|
|
}
|
|
Selection.prototype = selection.prototype = {
|
|
constructor: Selection,
|
|
select: function(select) {
|
|
"function" != typeof select && (select = selector(select));
|
|
for(var groups = this._groups, m = groups.length, subgroups = Array(m), j = 0; j < m; ++j)for(var node, subnode, group = groups[j], n = group.length, subgroup = subgroups[j] = Array(n), i = 0; i < n; ++i)(node = group[i]) && (subnode = select.call(node, node.__data__, i, group)) && ("__data__" in node && (subnode.__data__ = node.__data__), subgroup[i] = subnode);
|
|
return new Selection(subgroups, this._parents);
|
|
},
|
|
selectAll: function(select) {
|
|
if ("function" == typeof select) {
|
|
var select1;
|
|
select1 = select, select = function() {
|
|
var group = select1.apply(this, arguments);
|
|
return null == group ? [] : array$1(group);
|
|
};
|
|
} else select = selectorAll(select);
|
|
for(var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j)for(var node, group = groups[j], n = group.length, i = 0; i < n; ++i)(node = group[i]) && (subgroups.push(select.call(node, node.__data__, i, group)), parents.push(node));
|
|
return new Selection(subgroups, parents);
|
|
},
|
|
selectChild: function(match) {
|
|
var match1;
|
|
return this.select(null == match ? childFirst : (match1 = "function" == typeof match ? match : childMatcher(match), function() {
|
|
return find.call(this.children, match1);
|
|
}));
|
|
},
|
|
selectChildren: function(match) {
|
|
var match1;
|
|
return this.selectAll(null == match ? children : (match1 = "function" == typeof match ? match : childMatcher(match), function() {
|
|
return filter$1.call(this.children, match1);
|
|
}));
|
|
},
|
|
filter: function(match) {
|
|
"function" != typeof match && (match = matcher(match));
|
|
for(var groups = this._groups, m = groups.length, subgroups = Array(m), j = 0; j < m; ++j)for(var node, group = groups[j], n = group.length, subgroup = subgroups[j] = [], i = 0; i < n; ++i)(node = group[i]) && match.call(node, node.__data__, i, group) && subgroup.push(node);
|
|
return new Selection(subgroups, this._parents);
|
|
},
|
|
data: function(value, key) {
|
|
if (!arguments.length) return Array.from(this, datum);
|
|
var bind = key ? bindKey : bindIndex, parents = this._parents, groups = this._groups;
|
|
"function" != typeof value && (x = value, value = function() {
|
|
return x;
|
|
});
|
|
for(var m = groups.length, update = Array(m), enter = Array(m), exit = Array(m), j = 0; j < m; ++j){
|
|
var parent = parents[j], group = groups[j], groupLength = group.length, data = array$1(value.call(parent, parent && parent.__data__, j, parents)), dataLength = data.length, enterGroup = enter[j] = Array(dataLength), updateGroup = update[j] = Array(dataLength), exitGroup = exit[j] = Array(groupLength);
|
|
bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);
|
|
for(var x, previous, next, i0 = 0, i1 = 0; i0 < dataLength; ++i0)if (previous = enterGroup[i0]) {
|
|
for(i0 >= i1 && (i1 = i0 + 1); !(next = updateGroup[i1]) && ++i1 < dataLength;);
|
|
previous._next = next || null;
|
|
}
|
|
}
|
|
return (update = new Selection(update, parents))._enter = enter, update._exit = exit, update;
|
|
},
|
|
enter: function() {
|
|
return new Selection(this._enter || this._groups.map(sparse), this._parents);
|
|
},
|
|
exit: function() {
|
|
return new Selection(this._exit || this._groups.map(sparse), this._parents);
|
|
},
|
|
join: function(onenter, onupdate, onexit) {
|
|
var enter = this.enter(), update = this, exit = this.exit();
|
|
return enter = "function" == typeof onenter ? onenter(enter) : enter.append(onenter + ""), null != onupdate && (update = onupdate(update)), null == onexit ? exit.remove() : onexit(exit), enter && update ? enter.merge(update).order() : update;
|
|
},
|
|
merge: function(selection) {
|
|
if (!(selection instanceof Selection)) throw Error("invalid merge");
|
|
for(var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = Array(m0), j = 0; j < m; ++j)for(var node, group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = Array(n), i = 0; i < n; ++i)(node = group0[i] || group1[i]) && (merge[i] = node);
|
|
for(; j < m0; ++j)merges[j] = groups0[j];
|
|
return new Selection(merges, this._parents);
|
|
},
|
|
selection: function() {
|
|
return this;
|
|
},
|
|
order: function() {
|
|
for(var groups = this._groups, j = -1, m = groups.length; ++j < m;)for(var node, group = groups[j], i = group.length - 1, next = group[i]; --i >= 0;)(node = group[i]) && (next && 4 ^ node.compareDocumentPosition(next) && next.parentNode.insertBefore(node, next), next = node);
|
|
return this;
|
|
},
|
|
sort: function(compare) {
|
|
function compareNode(a, b) {
|
|
return a && b ? compare(a.__data__, b.__data__) : !a - !b;
|
|
}
|
|
compare || (compare = ascending$1);
|
|
for(var groups = this._groups, m = groups.length, sortgroups = Array(m), j = 0; j < m; ++j){
|
|
for(var node, group = groups[j], n = group.length, sortgroup = sortgroups[j] = Array(n), i = 0; i < n; ++i)(node = group[i]) && (sortgroup[i] = node);
|
|
sortgroup.sort(compareNode);
|
|
}
|
|
return new Selection(sortgroups, this._parents).order();
|
|
},
|
|
call: function() {
|
|
var callback = arguments[0];
|
|
return arguments[0] = this, callback.apply(null, arguments), this;
|
|
},
|
|
nodes: function() {
|
|
return Array.from(this);
|
|
},
|
|
node: function() {
|
|
for(var groups = this._groups, j = 0, m = groups.length; j < m; ++j)for(var group = groups[j], i = 0, n = group.length; i < n; ++i){
|
|
var node = group[i];
|
|
if (node) return node;
|
|
}
|
|
return null;
|
|
},
|
|
size: function() {
|
|
let size = 0;
|
|
for (const node of this)++size;
|
|
return size;
|
|
},
|
|
empty: function() {
|
|
return !this.node();
|
|
},
|
|
each: function(callback) {
|
|
for(var groups = this._groups, j = 0, m = groups.length; j < m; ++j)for(var node, group = groups[j], i = 0, n = group.length; i < n; ++i)(node = group[i]) && callback.call(node, node.__data__, i, group);
|
|
return this;
|
|
},
|
|
attr: function(name, value) {
|
|
var fullname = namespace(name);
|
|
if (arguments.length < 2) {
|
|
var node = this.node();
|
|
return fullname.local ? node.getAttributeNS(fullname.space, fullname.local) : node.getAttribute(fullname);
|
|
}
|
|
return this.each((null == value ? fullname.local ? attrRemoveNS : attrRemove : "function" == typeof value ? fullname.local ? attrFunctionNS : attrFunction : fullname.local ? attrConstantNS : attrConstant)(fullname, value));
|
|
},
|
|
style: function(name, value, priority) {
|
|
return arguments.length > 1 ? this.each((null == value ? styleRemove : "function" == typeof value ? styleFunction : styleConstant)(name, value, null == priority ? "" : priority)) : styleValue(this.node(), name);
|
|
},
|
|
property: function(name, value) {
|
|
return arguments.length > 1 ? this.each((null == value ? propertyRemove : "function" == typeof value ? propertyFunction : propertyConstant)(name, value)) : this.node()[name];
|
|
},
|
|
classed: function(name, value) {
|
|
var names = classArray(name + "");
|
|
if (arguments.length < 2) {
|
|
for(var list = classList(this.node()), i = -1, n = names.length; ++i < n;)if (!list.contains(names[i])) return !1;
|
|
return !0;
|
|
}
|
|
return this.each(("function" == typeof value ? classedFunction : value ? classedTrue : classedFalse)(names, value));
|
|
},
|
|
text: function(value) {
|
|
return arguments.length ? this.each(null == value ? textRemove : ("function" == typeof value ? textFunction : textConstant)(value)) : this.node().textContent;
|
|
},
|
|
html: function(value) {
|
|
return arguments.length ? this.each(null == value ? htmlRemove : ("function" == typeof value ? htmlFunction : htmlConstant)(value)) : this.node().innerHTML;
|
|
},
|
|
raise: function() {
|
|
return this.each(raise);
|
|
},
|
|
lower: function() {
|
|
return this.each(lower);
|
|
},
|
|
append: function(name) {
|
|
var create = "function" == typeof name ? name : creator(name);
|
|
return this.select(function() {
|
|
return this.appendChild(create.apply(this, arguments));
|
|
});
|
|
},
|
|
insert: function(name, before) {
|
|
var create = "function" == typeof name ? name : creator(name), select = null == before ? constantNull : "function" == typeof before ? before : selector(before);
|
|
return this.select(function() {
|
|
return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null);
|
|
});
|
|
},
|
|
remove: function() {
|
|
return this.each(remove);
|
|
},
|
|
clone: function(deep) {
|
|
return this.select(deep ? selection_cloneDeep : selection_cloneShallow);
|
|
},
|
|
datum: function(value) {
|
|
return arguments.length ? this.property("__data__", value) : this.node().__data__;
|
|
},
|
|
on: function(typename, value, options) {
|
|
var i, t, typenames = (typename + "").trim().split(/^|\s+/).map(function(t) {
|
|
var name = "", i = t.indexOf(".");
|
|
return i >= 0 && (name = t.slice(i + 1), t = t.slice(0, i)), {
|
|
type: t,
|
|
name: name
|
|
};
|
|
}), n = typenames.length;
|
|
if (arguments.length < 2) {
|
|
var on = this.node().__on;
|
|
if (on) {
|
|
for(var o, j = 0, m = on.length; j < m; ++j)for(i = 0, o = on[j]; i < n; ++i)if ((t = typenames[i]).type === o.type && t.name === o.name) return o.value;
|
|
}
|
|
return;
|
|
}
|
|
for(i = 0, on = value ? onAdd : onRemove; i < n; ++i)this.each(on(typenames[i], value, options));
|
|
return this;
|
|
},
|
|
dispatch: function(type, params) {
|
|
return this.each(("function" == typeof params ? dispatchFunction : dispatchConstant)(type, params));
|
|
},
|
|
[Symbol.iterator]: function*() {
|
|
for(var groups = this._groups, j = 0, m = groups.length; j < m; ++j)for(var node, group = groups[j], i = 0, n = group.length; i < n; ++i)(node = group[i]) && (yield node);
|
|
}
|
|
};
|
|
var nextId = 0;
|
|
function local() {
|
|
return new Local;
|
|
}
|
|
function Local() {
|
|
this._ = "@" + (++nextId).toString(36);
|
|
}
|
|
function sourceEvent(event) {
|
|
let sourceEvent;
|
|
for(; sourceEvent = event.sourceEvent;)event = sourceEvent;
|
|
return event;
|
|
}
|
|
function pointer(event, node) {
|
|
if (event = sourceEvent(event), void 0 === node && (node = event.currentTarget), node) {
|
|
var svg = node.ownerSVGElement || node;
|
|
if (svg.createSVGPoint) {
|
|
var point = svg.createSVGPoint();
|
|
return point.x = event.clientX, point.y = event.clientY, [
|
|
(point = point.matrixTransform(node.getScreenCTM().inverse())).x,
|
|
point.y
|
|
];
|
|
}
|
|
if (node.getBoundingClientRect) {
|
|
var rect = node.getBoundingClientRect();
|
|
return [
|
|
event.clientX - rect.left - node.clientLeft,
|
|
event.clientY - rect.top - node.clientTop
|
|
];
|
|
}
|
|
}
|
|
return [
|
|
event.pageX,
|
|
event.pageY
|
|
];
|
|
}
|
|
function nopropagation(event) {
|
|
event.stopImmediatePropagation();
|
|
}
|
|
function noevent(event) {
|
|
event.preventDefault(), event.stopImmediatePropagation();
|
|
}
|
|
function dragDisable(view) {
|
|
var root = view.document.documentElement, selection = select(view).on("dragstart.drag", noevent, !0);
|
|
"onselectstart" in root ? selection.on("selectstart.drag", noevent, !0) : (root.__noselect = root.style.MozUserSelect, root.style.MozUserSelect = "none");
|
|
}
|
|
function yesdrag(view, noclick) {
|
|
var root = view.document.documentElement, selection = select(view).on("dragstart.drag", null);
|
|
noclick && (selection.on("click.drag", noevent, !0), setTimeout(function() {
|
|
selection.on("click.drag", null);
|
|
}, 0)), "onselectstart" in root ? selection.on("selectstart.drag", null) : (root.style.MozUserSelect = root.__noselect, delete root.__noselect);
|
|
}
|
|
Local.prototype = local.prototype = {
|
|
constructor: Local,
|
|
get: function(node) {
|
|
for(var id = this._; !(id in node);)if (!(node = node.parentNode)) return;
|
|
return node[id];
|
|
},
|
|
set: function(node, value) {
|
|
return node[this._] = value;
|
|
},
|
|
remove: function(node) {
|
|
return this._ in node && delete node[this._];
|
|
},
|
|
toString: function() {
|
|
return this._;
|
|
}
|
|
};
|
|
var constant$2 = (x)=>()=>x;
|
|
function DragEvent(type, { sourceEvent , subject , target , identifier , active , x , y , dx , dy , dispatch }) {
|
|
Object.defineProperties(this, {
|
|
type: {
|
|
value: type,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
sourceEvent: {
|
|
value: sourceEvent,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
subject: {
|
|
value: subject,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
target: {
|
|
value: target,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
identifier: {
|
|
value: identifier,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
active: {
|
|
value: active,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
x: {
|
|
value: x,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
y: {
|
|
value: y,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
dx: {
|
|
value: dx,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
dy: {
|
|
value: dy,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
_: {
|
|
value: dispatch
|
|
}
|
|
});
|
|
}
|
|
function defaultFilter(event) {
|
|
return !event.ctrlKey && !event.button;
|
|
}
|
|
function defaultContainer() {
|
|
return this.parentNode;
|
|
}
|
|
function defaultSubject(event, d) {
|
|
return null == d ? {
|
|
x: event.x,
|
|
y: event.y
|
|
} : d;
|
|
}
|
|
function defaultTouchable() {
|
|
return navigator.maxTouchPoints || "ontouchstart" in this;
|
|
}
|
|
function define1(constructor, factory, prototype) {
|
|
constructor.prototype = factory.prototype = prototype, prototype.constructor = constructor;
|
|
}
|
|
function extend(parent, definition) {
|
|
var prototype = Object.create(parent.prototype);
|
|
for(var key in definition)prototype[key] = definition[key];
|
|
return prototype;
|
|
}
|
|
function Color() {}
|
|
DragEvent.prototype.on = function() {
|
|
var value = this._.on.apply(this._, arguments);
|
|
return value === this._ ? this : value;
|
|
};
|
|
var reI = "\\s*([+-]?\\d+)\\s*", reN = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*", reP = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*", reHex = /^#([0-9a-f]{3,8})$/, reRgbInteger = RegExp("^rgb\\(" + [
|
|
reI,
|
|
reI,
|
|
reI
|
|
] + "\\)$"), reRgbPercent = RegExp("^rgb\\(" + [
|
|
reP,
|
|
reP,
|
|
reP
|
|
] + "\\)$"), reRgbaInteger = RegExp("^rgba\\(" + [
|
|
reI,
|
|
reI,
|
|
reI,
|
|
reN
|
|
] + "\\)$"), reRgbaPercent = RegExp("^rgba\\(" + [
|
|
reP,
|
|
reP,
|
|
reP,
|
|
reN
|
|
] + "\\)$"), reHslPercent = RegExp("^hsl\\(" + [
|
|
reN,
|
|
reP,
|
|
reP
|
|
] + "\\)$"), reHslaPercent = RegExp("^hsla\\(" + [
|
|
reN,
|
|
reP,
|
|
reP,
|
|
reN
|
|
] + "\\)$"), named = {
|
|
aliceblue: 0xf0f8ff,
|
|
antiquewhite: 0xfaebd7,
|
|
aqua: 0x00ffff,
|
|
aquamarine: 0x7fffd4,
|
|
azure: 0xf0ffff,
|
|
beige: 0xf5f5dc,
|
|
bisque: 0xffe4c4,
|
|
black: 0x000000,
|
|
blanchedalmond: 0xffebcd,
|
|
blue: 0x0000ff,
|
|
blueviolet: 0x8a2be2,
|
|
brown: 0xa52a2a,
|
|
burlywood: 0xdeb887,
|
|
cadetblue: 0x5f9ea0,
|
|
chartreuse: 0x7fff00,
|
|
chocolate: 0xd2691e,
|
|
coral: 0xff7f50,
|
|
cornflowerblue: 0x6495ed,
|
|
cornsilk: 0xfff8dc,
|
|
crimson: 0xdc143c,
|
|
cyan: 0x00ffff,
|
|
darkblue: 0x00008b,
|
|
darkcyan: 0x008b8b,
|
|
darkgoldenrod: 0xb8860b,
|
|
darkgray: 0xa9a9a9,
|
|
darkgreen: 0x006400,
|
|
darkgrey: 0xa9a9a9,
|
|
darkkhaki: 0xbdb76b,
|
|
darkmagenta: 0x8b008b,
|
|
darkolivegreen: 0x556b2f,
|
|
darkorange: 0xff8c00,
|
|
darkorchid: 0x9932cc,
|
|
darkred: 0x8b0000,
|
|
darksalmon: 0xe9967a,
|
|
darkseagreen: 0x8fbc8f,
|
|
darkslateblue: 0x483d8b,
|
|
darkslategray: 0x2f4f4f,
|
|
darkslategrey: 0x2f4f4f,
|
|
darkturquoise: 0x00ced1,
|
|
darkviolet: 0x9400d3,
|
|
deeppink: 0xff1493,
|
|
deepskyblue: 0x00bfff,
|
|
dimgray: 0x696969,
|
|
dimgrey: 0x696969,
|
|
dodgerblue: 0x1e90ff,
|
|
firebrick: 0xb22222,
|
|
floralwhite: 0xfffaf0,
|
|
forestgreen: 0x228b22,
|
|
fuchsia: 0xff00ff,
|
|
gainsboro: 0xdcdcdc,
|
|
ghostwhite: 0xf8f8ff,
|
|
gold: 0xffd700,
|
|
goldenrod: 0xdaa520,
|
|
gray: 0x808080,
|
|
green: 0x008000,
|
|
greenyellow: 0xadff2f,
|
|
grey: 0x808080,
|
|
honeydew: 0xf0fff0,
|
|
hotpink: 0xff69b4,
|
|
indianred: 0xcd5c5c,
|
|
indigo: 0x4b0082,
|
|
ivory: 0xfffff0,
|
|
khaki: 0xf0e68c,
|
|
lavender: 0xe6e6fa,
|
|
lavenderblush: 0xfff0f5,
|
|
lawngreen: 0x7cfc00,
|
|
lemonchiffon: 0xfffacd,
|
|
lightblue: 0xadd8e6,
|
|
lightcoral: 0xf08080,
|
|
lightcyan: 0xe0ffff,
|
|
lightgoldenrodyellow: 0xfafad2,
|
|
lightgray: 0xd3d3d3,
|
|
lightgreen: 0x90ee90,
|
|
lightgrey: 0xd3d3d3,
|
|
lightpink: 0xffb6c1,
|
|
lightsalmon: 0xffa07a,
|
|
lightseagreen: 0x20b2aa,
|
|
lightskyblue: 0x87cefa,
|
|
lightslategray: 0x778899,
|
|
lightslategrey: 0x778899,
|
|
lightsteelblue: 0xb0c4de,
|
|
lightyellow: 0xffffe0,
|
|
lime: 0x00ff00,
|
|
limegreen: 0x32cd32,
|
|
linen: 0xfaf0e6,
|
|
magenta: 0xff00ff,
|
|
maroon: 0x800000,
|
|
mediumaquamarine: 0x66cdaa,
|
|
mediumblue: 0x0000cd,
|
|
mediumorchid: 0xba55d3,
|
|
mediumpurple: 0x9370db,
|
|
mediumseagreen: 0x3cb371,
|
|
mediumslateblue: 0x7b68ee,
|
|
mediumspringgreen: 0x00fa9a,
|
|
mediumturquoise: 0x48d1cc,
|
|
mediumvioletred: 0xc71585,
|
|
midnightblue: 0x191970,
|
|
mintcream: 0xf5fffa,
|
|
mistyrose: 0xffe4e1,
|
|
moccasin: 0xffe4b5,
|
|
navajowhite: 0xffdead,
|
|
navy: 0x000080,
|
|
oldlace: 0xfdf5e6,
|
|
olive: 0x808000,
|
|
olivedrab: 0x6b8e23,
|
|
orange: 0xffa500,
|
|
orangered: 0xff4500,
|
|
orchid: 0xda70d6,
|
|
palegoldenrod: 0xeee8aa,
|
|
palegreen: 0x98fb98,
|
|
paleturquoise: 0xafeeee,
|
|
palevioletred: 0xdb7093,
|
|
papayawhip: 0xffefd5,
|
|
peachpuff: 0xffdab9,
|
|
peru: 0xcd853f,
|
|
pink: 0xffc0cb,
|
|
plum: 0xdda0dd,
|
|
powderblue: 0xb0e0e6,
|
|
purple: 0x800080,
|
|
rebeccapurple: 0x663399,
|
|
red: 0xff0000,
|
|
rosybrown: 0xbc8f8f,
|
|
royalblue: 0x4169e1,
|
|
saddlebrown: 0x8b4513,
|
|
salmon: 0xfa8072,
|
|
sandybrown: 0xf4a460,
|
|
seagreen: 0x2e8b57,
|
|
seashell: 0xfff5ee,
|
|
sienna: 0xa0522d,
|
|
silver: 0xc0c0c0,
|
|
skyblue: 0x87ceeb,
|
|
slateblue: 0x6a5acd,
|
|
slategray: 0x708090,
|
|
slategrey: 0x708090,
|
|
snow: 0xfffafa,
|
|
springgreen: 0x00ff7f,
|
|
steelblue: 0x4682b4,
|
|
tan: 0xd2b48c,
|
|
teal: 0x008080,
|
|
thistle: 0xd8bfd8,
|
|
tomato: 0xff6347,
|
|
turquoise: 0x40e0d0,
|
|
violet: 0xee82ee,
|
|
wheat: 0xf5deb3,
|
|
white: 0xffffff,
|
|
whitesmoke: 0xf5f5f5,
|
|
yellow: 0xffff00,
|
|
yellowgreen: 0x9acd32
|
|
};
|
|
function color_formatHex() {
|
|
return this.rgb().formatHex();
|
|
}
|
|
function color_formatRgb() {
|
|
return this.rgb().formatRgb();
|
|
}
|
|
function color(format) {
|
|
var m, l;
|
|
return format = (format + "").trim().toLowerCase(), (m = reHex.exec(format)) ? (l = m[1].length, m = parseInt(m[1], 16), 6 === l ? rgbn(m) : 3 === l ? new Rgb(m >> 8 & 0xf | m >> 4 & 0xf0, m >> 4 & 0xf | 0xf0 & m, (0xf & m) << 4 | 0xf & m, 1) : 8 === l ? rgba(m >> 24 & 0xff, m >> 16 & 0xff, m >> 8 & 0xff, (0xff & m) / 0xff) : 4 === l ? rgba(m >> 12 & 0xf | m >> 8 & 0xf0, m >> 8 & 0xf | m >> 4 & 0xf0, m >> 4 & 0xf | 0xf0 & m, ((0xf & m) << 4 | 0xf & m) / 0xff) : null) : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) : (m = reRgbPercent.exec(format)) ? new Rgb(255 * m[1] / 100, 255 * m[2] / 100, 255 * m[3] / 100, 1) : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) : (m = reRgbaPercent.exec(format)) ? rgba(255 * m[1] / 100, 255 * m[2] / 100, 255 * m[3] / 100, m[4]) : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) : named.hasOwnProperty(format) ? rgbn(named[format]) : "transparent" === format ? new Rgb(NaN, NaN, NaN, 0) : null;
|
|
}
|
|
function rgbn(n) {
|
|
return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, 0xff & n, 1);
|
|
}
|
|
function rgba(r, g, b, a) {
|
|
return a <= 0 && (r = g = b = NaN), new Rgb(r, g, b, a);
|
|
}
|
|
function rgbConvert(o) {
|
|
return (o instanceof Color || (o = color(o)), o) ? (o = o.rgb(), new Rgb(o.r, o.g, o.b, o.opacity)) : new Rgb;
|
|
}
|
|
function rgb(r, g, b, opacity) {
|
|
return 1 === arguments.length ? rgbConvert(r) : new Rgb(r, g, b, null == opacity ? 1 : opacity);
|
|
}
|
|
function Rgb(r, g, b, opacity) {
|
|
this.r = +r, this.g = +g, this.b = +b, this.opacity = +opacity;
|
|
}
|
|
function rgb_formatHex() {
|
|
return "#" + hex(this.r) + hex(this.g) + hex(this.b);
|
|
}
|
|
function rgb_formatRgb() {
|
|
var a = this.opacity;
|
|
return (1 === (a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a))) ? "rgb(" : "rgba(") + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", " + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", " + Math.max(0, Math.min(255, Math.round(this.b) || 0)) + (1 === a ? ")" : ", " + a + ")");
|
|
}
|
|
function hex(value) {
|
|
return ((value = Math.max(0, Math.min(255, Math.round(value) || 0))) < 16 ? "0" : "") + value.toString(16);
|
|
}
|
|
function hsla(h, s, l, a) {
|
|
return a <= 0 ? h = s = l = NaN : l <= 0 || l >= 1 ? h = s = NaN : s <= 0 && (h = NaN), new Hsl(h, s, l, a);
|
|
}
|
|
function hslConvert(o) {
|
|
if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);
|
|
if (o instanceof Color || (o = color(o)), !o) return new Hsl;
|
|
if (o instanceof Hsl) return o;
|
|
var r = (o = o.rgb()).r / 255, g = o.g / 255, b = o.b / 255, min = Math.min(r, g, b), max = Math.max(r, g, b), h = NaN, s = max - min, l = (max + min) / 2;
|
|
return s ? (h = r === max ? (g - b) / s + (g < b) * 6 : g === max ? (b - r) / s + 2 : (r - g) / s + 4, s /= l < 0.5 ? max + min : 2 - max - min, h *= 60) : s = l > 0 && l < 1 ? 0 : h, new Hsl(h, s, l, o.opacity);
|
|
}
|
|
function hsl(h, s, l, opacity) {
|
|
return 1 === arguments.length ? hslConvert(h) : new Hsl(h, s, l, null == opacity ? 1 : opacity);
|
|
}
|
|
function Hsl(h, s, l, opacity) {
|
|
this.h = +h, this.s = +s, this.l = +l, this.opacity = +opacity;
|
|
}
|
|
function hsl2rgb(h, m1, m2) {
|
|
return (h < 60 ? m1 + (m2 - m1) * h / 60 : h < 180 ? m2 : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60 : m1) * 255;
|
|
}
|
|
define1(Color, color, {
|
|
copy: function(channels) {
|
|
return Object.assign(new this.constructor, this, channels);
|
|
},
|
|
displayable: function() {
|
|
return this.rgb().displayable();
|
|
},
|
|
hex: color_formatHex,
|
|
formatHex: color_formatHex,
|
|
formatHsl: function() {
|
|
return hslConvert(this).formatHsl();
|
|
},
|
|
formatRgb: color_formatRgb,
|
|
toString: color_formatRgb
|
|
}), define1(Rgb, rgb, extend(Color, {
|
|
brighter: function(k) {
|
|
return k = null == k ? 1.4285714285714286 : Math.pow(1.4285714285714286, k), new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
|
|
},
|
|
darker: function(k) {
|
|
return k = null == k ? 0.7 : Math.pow(0.7, k), new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
|
|
},
|
|
rgb: function() {
|
|
return this;
|
|
},
|
|
displayable: function() {
|
|
return -0.5 <= this.r && this.r < 255.5 && -0.5 <= this.g && this.g < 255.5 && -0.5 <= this.b && this.b < 255.5 && 0 <= this.opacity && this.opacity <= 1;
|
|
},
|
|
hex: rgb_formatHex,
|
|
formatHex: rgb_formatHex,
|
|
formatRgb: rgb_formatRgb,
|
|
toString: rgb_formatRgb
|
|
})), define1(Hsl, hsl, extend(Color, {
|
|
brighter: function(k) {
|
|
return k = null == k ? 1.4285714285714286 : Math.pow(1.4285714285714286, k), new Hsl(this.h, this.s, this.l * k, this.opacity);
|
|
},
|
|
darker: function(k) {
|
|
return k = null == k ? 0.7 : Math.pow(0.7, k), new Hsl(this.h, this.s, this.l * k, this.opacity);
|
|
},
|
|
rgb: function() {
|
|
var h = this.h % 360 + (this.h < 0) * 360, s = isNaN(h) || isNaN(this.s) ? 0 : this.s, l = this.l, m2 = l + (l < 0.5 ? l : 1 - l) * s, m1 = 2 * l - m2;
|
|
return new Rgb(hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2), hsl2rgb(h, m1, m2), hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2), this.opacity);
|
|
},
|
|
displayable: function() {
|
|
return (0 <= this.s && this.s <= 1 || isNaN(this.s)) && 0 <= this.l && this.l <= 1 && 0 <= this.opacity && this.opacity <= 1;
|
|
},
|
|
formatHsl: function() {
|
|
var a = this.opacity;
|
|
return (1 === (a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a))) ? "hsl(" : "hsla(") + (this.h || 0) + ", " + 100 * (this.s || 0) + "%, " + 100 * (this.l || 0) + "%" + (1 === a ? ")" : ", " + a + ")");
|
|
}
|
|
}));
|
|
const radians = Math.PI / 180, degrees = 180 / Math.PI, t0 = 4 / 29, t1 = 6 / 29, t2 = 3 * t1 * t1, t3 = t1 * t1 * t1;
|
|
function labConvert(o) {
|
|
if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity);
|
|
if (o instanceof Hcl) return hcl2lab(o);
|
|
o instanceof Rgb || (o = rgbConvert(o));
|
|
var x, z, r = rgb2lrgb(o.r), g = rgb2lrgb(o.g), b = rgb2lrgb(o.b), y = xyz2lab((0.2225045 * r + 0.7168786 * g + 0.0606169 * b) / 1);
|
|
return r === g && g === b ? x = z = y : (x = xyz2lab((0.4360747 * r + 0.3850649 * g + 0.1430804 * b) / 0.96422), z = xyz2lab((0.0139322 * r + 0.0971045 * g + 0.7141733 * b) / 0.82521)), new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity);
|
|
}
|
|
function lab(l, a, b, opacity) {
|
|
return 1 === arguments.length ? labConvert(l) : new Lab(l, a, b, null == opacity ? 1 : opacity);
|
|
}
|
|
function Lab(l, a, b, opacity) {
|
|
this.l = +l, this.a = +a, this.b = +b, this.opacity = +opacity;
|
|
}
|
|
function xyz2lab(t) {
|
|
return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;
|
|
}
|
|
function lab2xyz(t) {
|
|
return t > t1 ? t * t * t : t2 * (t - t0);
|
|
}
|
|
function lrgb2rgb(x) {
|
|
return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055);
|
|
}
|
|
function rgb2lrgb(x) {
|
|
return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);
|
|
}
|
|
function hclConvert(o) {
|
|
if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity);
|
|
if (o instanceof Lab || (o = labConvert(o)), 0 === o.a && 0 === o.b) return new Hcl(NaN, 0 < o.l && o.l < 100 ? 0 : NaN, o.l, o.opacity);
|
|
var h = Math.atan2(o.b, o.a) * degrees;
|
|
return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity);
|
|
}
|
|
function hcl(h, c, l, opacity) {
|
|
return 1 === arguments.length ? hclConvert(h) : new Hcl(h, c, l, null == opacity ? 1 : opacity);
|
|
}
|
|
function Hcl(h, c, l, opacity) {
|
|
this.h = +h, this.c = +c, this.l = +l, this.opacity = +opacity;
|
|
}
|
|
function hcl2lab(o) {
|
|
if (isNaN(o.h)) return new Lab(o.l, 0, 0, o.opacity);
|
|
var h = o.h * radians;
|
|
return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity);
|
|
}
|
|
define1(Lab, lab, extend(Color, {
|
|
brighter: function(k) {
|
|
return new Lab(this.l + 18 * (null == k ? 1 : k), this.a, this.b, this.opacity);
|
|
},
|
|
darker: function(k) {
|
|
return new Lab(this.l - 18 * (null == k ? 1 : k), this.a, this.b, this.opacity);
|
|
},
|
|
rgb: function() {
|
|
var y = (this.l + 16) / 116, x = isNaN(this.a) ? y : y + this.a / 500, z = isNaN(this.b) ? y : y - this.b / 200;
|
|
return x = 0.96422 * lab2xyz(x), y = 1 * lab2xyz(y), z = 0.82521 * lab2xyz(z), new Rgb(lrgb2rgb(3.1338561 * x - 1.6168667 * y - 0.4906146 * z), lrgb2rgb(-0.9787684 * x + 1.9161415 * y + 0.0334540 * z), lrgb2rgb(0.0719453 * x - 0.2289914 * y + 1.4052427 * z), this.opacity);
|
|
}
|
|
})), define1(Hcl, hcl, extend(Color, {
|
|
brighter: function(k) {
|
|
return new Hcl(this.h, this.c, this.l + 18 * (null == k ? 1 : k), this.opacity);
|
|
},
|
|
darker: function(k) {
|
|
return new Hcl(this.h, this.c, this.l - 18 * (null == k ? 1 : k), this.opacity);
|
|
},
|
|
rgb: function() {
|
|
return hcl2lab(this).rgb();
|
|
}
|
|
}));
|
|
var BC_DA = -1.78277 * 0.29227 - 0.1347134789;
|
|
function cubehelix(h, s, l, opacity) {
|
|
return 1 === arguments.length ? function(o) {
|
|
if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity);
|
|
o instanceof Rgb || (o = rgbConvert(o));
|
|
var r = o.r / 255, g = o.g / 255, b = o.b / 255, l = (BC_DA * b + -1.7884503806 * r - 3.5172982438 * g) / (BC_DA + -1.7884503806 - 3.5172982438), bl = b - l, k = -((1.97294 * (g - l) - -0.29227 * bl) / 0.90649), s = Math.sqrt(k * k + bl * bl) / (1.97294 * l * (1 - l)), h = s ? Math.atan2(k, bl) * degrees - 120 : NaN;
|
|
return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity);
|
|
}(h) : new Cubehelix(h, s, l, null == opacity ? 1 : opacity);
|
|
}
|
|
function Cubehelix(h, s, l, opacity) {
|
|
this.h = +h, this.s = +s, this.l = +l, this.opacity = +opacity;
|
|
}
|
|
function basis(t1, v0, v1, v2, v3) {
|
|
var t2 = t1 * t1, t3 = t2 * t1;
|
|
return ((1 - 3 * t1 + 3 * t2 - t3) * v0 + (4 - 6 * t2 + 3 * t3) * v1 + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2 + t3 * v3) / 6;
|
|
}
|
|
function basis$1(values) {
|
|
var n = values.length - 1;
|
|
return function(t) {
|
|
var i = t <= 0 ? t = 0 : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n), v1 = values[i], v2 = values[i + 1], v0 = i > 0 ? values[i - 1] : 2 * v1 - v2, v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;
|
|
return basis((t - i / n) * n, v0, v1, v2, v3);
|
|
};
|
|
}
|
|
function basisClosed(values) {
|
|
var n = values.length;
|
|
return function(t) {
|
|
var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n), v0 = values[(i + n - 1) % n], v1 = values[i % n], v2 = values[(i + 1) % n], v3 = values[(i + 2) % n];
|
|
return basis((t - i / n) * n, v0, v1, v2, v3);
|
|
};
|
|
}
|
|
define1(Cubehelix, cubehelix, extend(Color, {
|
|
brighter: function(k) {
|
|
return k = null == k ? 1.4285714285714286 : Math.pow(1.4285714285714286, k), new Cubehelix(this.h, this.s, this.l * k, this.opacity);
|
|
},
|
|
darker: function(k) {
|
|
return k = null == k ? 0.7 : Math.pow(0.7, k), new Cubehelix(this.h, this.s, this.l * k, this.opacity);
|
|
},
|
|
rgb: function() {
|
|
var h = isNaN(this.h) ? 0 : (this.h + 120) * radians, l = +this.l, a = isNaN(this.s) ? 0 : this.s * l * (1 - l), cosh = Math.cos(h), sinh = Math.sin(h);
|
|
return new Rgb(255 * (l + a * (-0.14861 * cosh + 1.78277 * sinh)), 255 * (l + a * (-0.29227 * cosh + -0.90649 * sinh)), 255 * (l + a * (1.97294 * cosh)), this.opacity);
|
|
}
|
|
}));
|
|
var constant$3 = (x)=>()=>x;
|
|
function linear(a, d) {
|
|
return function(t) {
|
|
return a + t * d;
|
|
};
|
|
}
|
|
function hue(a, b) {
|
|
var d = b - a;
|
|
return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant$3(isNaN(a) ? b : a);
|
|
}
|
|
function nogamma(a, b) {
|
|
var d = b - a;
|
|
return d ? linear(a, d) : constant$3(isNaN(a) ? b : a);
|
|
}
|
|
var interpolateRgb = function rgbGamma(y) {
|
|
var y1, color = 1 == (y1 = +(y1 = y)) ? nogamma : function(a, b) {
|
|
var a1, b1, y;
|
|
return b - a ? (a1 = a, b1 = b, a1 = Math.pow(a1, y = y1), b1 = Math.pow(b1, y) - a1, y = 1 / y, function(t) {
|
|
return Math.pow(a1 + t * b1, y);
|
|
}) : constant$3(isNaN(a) ? b : a);
|
|
};
|
|
function rgb$1(start, end) {
|
|
var r = color((start = rgb(start)).r, (end = rgb(end)).r), g = color(start.g, end.g), b = color(start.b, end.b), opacity = nogamma(start.opacity, end.opacity);
|
|
return function(t) {
|
|
return start.r = r(t), start.g = g(t), start.b = b(t), start.opacity = opacity(t), start + "";
|
|
};
|
|
}
|
|
return rgb$1.gamma = rgbGamma, rgb$1;
|
|
}(1);
|
|
function rgbSpline(spline) {
|
|
return function(colors) {
|
|
var i, color, n = colors.length, r = Array(n), g = Array(n), b = Array(n);
|
|
for(i = 0; i < n; ++i)color = rgb(colors[i]), r[i] = color.r || 0, g[i] = color.g || 0, b[i] = color.b || 0;
|
|
return r = spline(r), g = spline(g), b = spline(b), color.opacity = 1, function(t) {
|
|
return color.r = r(t), color.g = g(t), color.b = b(t), color + "";
|
|
};
|
|
};
|
|
}
|
|
var rgbBasis = rgbSpline(basis$1), rgbBasisClosed = rgbSpline(basisClosed);
|
|
function numberArray(a, b) {
|
|
b || (b = []);
|
|
var i, n = a ? Math.min(b.length, a.length) : 0, c = b.slice();
|
|
return function(t) {
|
|
for(i = 0; i < n; ++i)c[i] = a[i] * (1 - t) + b[i] * t;
|
|
return c;
|
|
};
|
|
}
|
|
function isNumberArray(x) {
|
|
return ArrayBuffer.isView(x) && !(x instanceof DataView);
|
|
}
|
|
function genericArray(a, b) {
|
|
var i, nb = b ? b.length : 0, na = a ? Math.min(nb, a.length) : 0, x = Array(na), c = Array(nb);
|
|
for(i = 0; i < na; ++i)x[i] = interpolate(a[i], b[i]);
|
|
for(; i < nb; ++i)c[i] = b[i];
|
|
return function(t) {
|
|
for(i = 0; i < na; ++i)c[i] = x[i](t);
|
|
return c;
|
|
};
|
|
}
|
|
function date(a, b) {
|
|
var d = new Date;
|
|
return a = +a, b = +b, function(t) {
|
|
return d.setTime(a * (1 - t) + b * t), d;
|
|
};
|
|
}
|
|
function interpolateNumber(a, b) {
|
|
return a = +a, b = +b, function(t) {
|
|
return a * (1 - t) + b * t;
|
|
};
|
|
}
|
|
function object(a, b) {
|
|
var k, i = {}, c = {};
|
|
for(k in (null === a || "object" != typeof a) && (a = {}), (null === b || "object" != typeof b) && (b = {}), b)k in a ? i[k] = interpolate(a[k], b[k]) : c[k] = b[k];
|
|
return function(t) {
|
|
for(k in i)c[k] = i[k](t);
|
|
return c;
|
|
};
|
|
}
|
|
var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, reB = RegExp(reA.source, "g");
|
|
function interpolateString(a, b) {
|
|
var b1, b2, am, bm, bs, bi = reA.lastIndex = reB.lastIndex = 0, i = -1, s = [], q = [];
|
|
for(a += "", b += ""; (am = reA.exec(a)) && (bm = reB.exec(b));)(bs = bm.index) > bi && (bs = b.slice(bi, bs), s[i] ? s[i] += bs : s[++i] = bs), (am = am[0]) === (bm = bm[0]) ? s[i] ? s[i] += bm : s[++i] = bm : (s[++i] = null, q.push({
|
|
i: i,
|
|
x: interpolateNumber(am, bm)
|
|
})), bi = reB.lastIndex;
|
|
return bi < b.length && (bs = b.slice(bi), s[i] ? s[i] += bs : s[++i] = bs), s.length < 2 ? q[0] ? (b1 = q[0].x, function(t) {
|
|
return b1(t) + "";
|
|
}) : (b2 = b, function() {
|
|
return b2;
|
|
}) : (b = q.length, function(t) {
|
|
for(var o, i = 0; i < b; ++i)s[(o = q[i]).i] = o.x(t);
|
|
return s.join("");
|
|
});
|
|
}
|
|
function interpolate(a, b) {
|
|
var c, t = typeof b;
|
|
return null == b || "boolean" === t ? constant$3(b) : ("number" === t ? interpolateNumber : "string" === t ? (c = color(b)) ? (b = c, interpolateRgb) : interpolateString : b instanceof color ? interpolateRgb : b instanceof Date ? date : isNumberArray(b) ? numberArray : Array.isArray(b) ? genericArray : "function" != typeof b.valueOf && "function" != typeof b.toString || isNaN(b) ? object : interpolateNumber)(a, b);
|
|
}
|
|
function interpolateRound(a, b) {
|
|
return a = +a, b = +b, function(t) {
|
|
return Math.round(a * (1 - t) + b * t);
|
|
};
|
|
}
|
|
var degrees$1 = 180 / Math.PI, identity$2 = {
|
|
translateX: 0,
|
|
translateY: 0,
|
|
rotate: 0,
|
|
skewX: 0,
|
|
scaleX: 1,
|
|
scaleY: 1
|
|
};
|
|
function decompose(a, b, c, d, e, f) {
|
|
var scaleX, scaleY, skewX;
|
|
return (scaleX = Math.sqrt(a * a + b * b)) && (a /= scaleX, b /= scaleX), (skewX = a * c + b * d) && (c -= a * skewX, d -= b * skewX), (scaleY = Math.sqrt(c * c + d * d)) && (c /= scaleY, d /= scaleY, skewX /= scaleY), a * d < b * c && (a = -a, b = -b, skewX = -skewX, scaleX = -scaleX), {
|
|
translateX: e,
|
|
translateY: f,
|
|
rotate: Math.atan2(b, a) * degrees$1,
|
|
skewX: Math.atan(skewX) * degrees$1,
|
|
scaleX: scaleX,
|
|
scaleY: scaleY
|
|
};
|
|
}
|
|
function interpolateTransform(parse, pxComma, pxParen, degParen) {
|
|
function pop(s) {
|
|
return s.length ? s.pop() + " " : "";
|
|
}
|
|
return function(a, b) {
|
|
var a1, b1, s, q, a2, b2, s1, q1, s2 = [], q2 = [];
|
|
return a = parse(a), b = parse(b), !function(xa, ya, xb, yb, s, q) {
|
|
if (xa !== xb || ya !== yb) {
|
|
var i = s.push("translate(", null, pxComma, null, pxParen);
|
|
q.push({
|
|
i: i - 4,
|
|
x: interpolateNumber(xa, xb)
|
|
}, {
|
|
i: i - 2,
|
|
x: interpolateNumber(ya, yb)
|
|
});
|
|
} else (xb || yb) && s.push("translate(" + xb + pxComma + yb + pxParen);
|
|
}(a.translateX, a.translateY, b.translateX, b.translateY, s2, q2), a1 = a.rotate, a1 !== (b1 = b.rotate) ? (a1 - b1 > 180 ? b1 += 360 : b1 - a1 > 180 && (a1 += 360), q2.push({
|
|
i: s2.push(pop(s2) + "rotate(", null, degParen) - 2,
|
|
x: interpolateNumber(a1, b1)
|
|
})) : b1 && s2.push(pop(s2) + "rotate(" + b1 + degParen), a2 = a.skewX, a2 !== (b2 = b.skewX) ? q2.push({
|
|
i: s2.push(pop(s2) + "skewX(", null, degParen) - 2,
|
|
x: interpolateNumber(a2, b2)
|
|
}) : b2 && s2.push(pop(s2) + "skewX(" + b2 + degParen), !function(xa, ya, xb, yb, s, q) {
|
|
if (xa !== xb || ya !== yb) {
|
|
var i = s.push(pop(s) + "scale(", null, ",", null, ")");
|
|
q.push({
|
|
i: i - 4,
|
|
x: interpolateNumber(xa, xb)
|
|
}, {
|
|
i: i - 2,
|
|
x: interpolateNumber(ya, yb)
|
|
});
|
|
} else (1 !== xb || 1 !== yb) && s.push(pop(s) + "scale(" + xb + "," + yb + ")");
|
|
}(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s2, q2), a = b = null, function(t) {
|
|
for(var o, i = -1, n = q2.length; ++i < n;)s2[(o = q2[i]).i] = o.x(t);
|
|
return s2.join("");
|
|
};
|
|
};
|
|
}
|
|
var interpolateTransformCss = interpolateTransform(function(value) {
|
|
const m = new ("function" == typeof DOMMatrix ? DOMMatrix : WebKitCSSMatrix)(value + "");
|
|
return m.isIdentity ? identity$2 : decompose(m.a, m.b, m.c, m.d, m.e, m.f);
|
|
}, "px, ", "px)", "deg)"), interpolateTransformSvg = interpolateTransform(function(value) {
|
|
return null == value ? identity$2 : (svgNode || (svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g")), svgNode.setAttribute("transform", value), value = svgNode.transform.baseVal.consolidate()) ? decompose((value = value.matrix).a, value.b, value.c, value.d, value.e, value.f) : identity$2;
|
|
}, ", ", ")", ")");
|
|
function cosh(x) {
|
|
return ((x = Math.exp(x)) + 1 / x) / 2;
|
|
}
|
|
var interpolateZoom = function zoomRho(rho, rho2, rho4) {
|
|
function zoom(p0, p1) {
|
|
var i, S, ux0 = p0[0], uy0 = p0[1], w0 = p0[2], ux1 = p1[0], uy1 = p1[1], w1 = p1[2], dx = ux1 - ux0, dy = uy1 - uy0, d2 = dx * dx + dy * dy;
|
|
if (d2 < 1e-12) S = Math.log(w1 / w0) / rho, i = function(t) {
|
|
return [
|
|
ux0 + t * dx,
|
|
uy0 + t * dy,
|
|
w0 * Math.exp(rho * t * S)
|
|
];
|
|
};
|
|
else {
|
|
var d1 = Math.sqrt(d2), b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1), b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1), r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0);
|
|
S = (Math.log(Math.sqrt(b1 * b1 + 1) - b1) - r0) / rho, i = function(t) {
|
|
var x, x1, s = t * S, coshr0 = cosh(r0), u = w0 / (rho2 * d1) * (coshr0 * (((x = Math.exp(2 * (x = rho * s + r0))) - 1) / (x + 1)) - ((x1 = Math.exp(x1 = r0)) - 1 / x1) / 2);
|
|
return [
|
|
ux0 + u * dx,
|
|
uy0 + u * dy,
|
|
w0 * coshr0 / cosh(rho * s + r0)
|
|
];
|
|
};
|
|
}
|
|
return i.duration = 1000 * S * rho / Math.SQRT2, i;
|
|
}
|
|
return zoom.rho = function(_) {
|
|
var _1 = Math.max(1e-3, +_), _2 = _1 * _1;
|
|
return zoomRho(_1, _2, _2 * _2);
|
|
}, zoom;
|
|
}(Math.SQRT2, 2, 4);
|
|
function hsl$1(hue) {
|
|
return function(start, end) {
|
|
var h = hue((start = hsl(start)).h, (end = hsl(end)).h), s = nogamma(start.s, end.s), l = nogamma(start.l, end.l), opacity = nogamma(start.opacity, end.opacity);
|
|
return function(t) {
|
|
return start.h = h(t), start.s = s(t), start.l = l(t), start.opacity = opacity(t), start + "";
|
|
};
|
|
};
|
|
}
|
|
var hsl$2 = hsl$1(hue), hslLong = hsl$1(nogamma);
|
|
function hcl$1(hue) {
|
|
return function(start, end) {
|
|
var h = hue((start = hcl(start)).h, (end = hcl(end)).h), c = nogamma(start.c, end.c), l = nogamma(start.l, end.l), opacity = nogamma(start.opacity, end.opacity);
|
|
return function(t) {
|
|
return start.h = h(t), start.c = c(t), start.l = l(t), start.opacity = opacity(t), start + "";
|
|
};
|
|
};
|
|
}
|
|
var hcl$2 = hcl$1(hue), hclLong = hcl$1(nogamma);
|
|
function cubehelix$1(hue) {
|
|
return function cubehelixGamma(y) {
|
|
function cubehelix$1(start, end) {
|
|
var h = hue((start = cubehelix(start)).h, (end = cubehelix(end)).h), s = nogamma(start.s, end.s), l = nogamma(start.l, end.l), opacity = nogamma(start.opacity, end.opacity);
|
|
return function(t) {
|
|
return start.h = h(t), start.s = s(t), start.l = l(Math.pow(t, y)), start.opacity = opacity(t), start + "";
|
|
};
|
|
}
|
|
return y = +y, cubehelix$1.gamma = cubehelixGamma, cubehelix$1;
|
|
}(1);
|
|
}
|
|
var cubehelix$2 = cubehelix$1(hue), cubehelixLong = cubehelix$1(nogamma);
|
|
function piecewise(interpolate$1, values) {
|
|
void 0 === values && (values = interpolate$1, interpolate$1 = interpolate);
|
|
for(var i = 0, n = values.length - 1, v = values[0], I = Array(n < 0 ? 0 : n); i < n;)I[i] = interpolate$1(v, v = values[++i]);
|
|
return function(t) {
|
|
var i = Math.max(0, Math.min(n - 1, Math.floor(t *= n)));
|
|
return I[i](t - i);
|
|
};
|
|
}
|
|
var locale$1, svgNode, taskHead, taskTail, frame = 0, timeout = 0, interval = 0, clockLast = 0, clockNow = 0, clockSkew = 0, clock = "object" == typeof performance && performance.now ? performance : Date, setFrame = "object" == typeof window && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f) {
|
|
setTimeout(f, 17);
|
|
};
|
|
function now() {
|
|
return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);
|
|
}
|
|
function clearNow() {
|
|
clockNow = 0;
|
|
}
|
|
function Timer() {
|
|
this._call = this._time = this._next = null;
|
|
}
|
|
function timer(callback, delay, time) {
|
|
var t = new Timer;
|
|
return t.restart(callback, delay, time), t;
|
|
}
|
|
function timerFlush() {
|
|
now(), ++frame;
|
|
for(var e, t = taskHead; t;)(e = clockNow - t._time) >= 0 && t._call.call(null, e), t = t._next;
|
|
--frame;
|
|
}
|
|
function wake() {
|
|
clockNow = (clockLast = clock.now()) + clockSkew, frame = timeout = 0;
|
|
try {
|
|
timerFlush();
|
|
} finally{
|
|
frame = 0, function() {
|
|
for(var t0, t2, t1 = taskHead, time = 1 / 0; t1;)t1._call ? (time > t1._time && (time = t1._time), t0 = t1, t1 = t1._next) : (t2 = t1._next, t1._next = null, t1 = t0 ? t0._next = t2 : taskHead = t2);
|
|
taskTail = t0, sleep(time);
|
|
}(), clockNow = 0;
|
|
}
|
|
}
|
|
function poke() {
|
|
var now = clock.now(), delay = now - clockLast;
|
|
delay > 1000 && (clockSkew -= delay, clockLast = now);
|
|
}
|
|
function sleep(time) {
|
|
!frame && (timeout && (timeout = clearTimeout(timeout)), time - clockNow > 24 ? (time < 1 / 0 && (timeout = setTimeout(wake, time - clock.now() - clockSkew)), interval && (interval = clearInterval(interval))) : (interval || (clockLast = clock.now(), interval = setInterval(poke, 1000)), frame = 1, setFrame(wake)));
|
|
}
|
|
function timeout$1(callback, delay, time) {
|
|
var t = new Timer;
|
|
return delay = null == delay ? 0 : +delay, t.restart((elapsed)=>{
|
|
t.stop(), callback(elapsed + delay);
|
|
}, delay, time), t;
|
|
}
|
|
Timer.prototype = timer.prototype = {
|
|
constructor: Timer,
|
|
restart: function(callback, delay, time) {
|
|
if ("function" != typeof callback) throw TypeError("callback is not a function");
|
|
time = (null == time ? now() : +time) + (null == delay ? 0 : +delay), this._next || taskTail === this || (taskTail ? taskTail._next = this : taskHead = this, taskTail = this), this._call = callback, this._time = time, sleep();
|
|
},
|
|
stop: function() {
|
|
this._call && (this._call = null, this._time = 1 / 0, sleep());
|
|
}
|
|
};
|
|
var emptyOn = dispatch("start", "end", "cancel", "interrupt"), emptyTween = [];
|
|
function schedule(node, name, id, index, group, timing) {
|
|
var schedules = node.__transition;
|
|
if (schedules) {
|
|
if (id in schedules) return;
|
|
} else node.__transition = {};
|
|
!function(node, id, self1) {
|
|
var tween, schedules = node.__transition;
|
|
function start(elapsed) {
|
|
var i, j, n, o;
|
|
if (1 !== self1.state) return stop();
|
|
for(i in schedules)if ((o = schedules[i]).name === self1.name) {
|
|
if (3 === o.state) return timeout$1(start);
|
|
4 === o.state ? (o.state = 6, o.timer.stop(), o.on.call("interrupt", node, node.__data__, o.index, o.group), delete schedules[i]) : +i < id && (o.state = 6, o.timer.stop(), o.on.call("cancel", node, node.__data__, o.index, o.group), delete schedules[i]);
|
|
}
|
|
if (timeout$1(function() {
|
|
3 === self1.state && (self1.state = 4, self1.timer.restart(tick, self1.delay, self1.time), tick(elapsed));
|
|
}), self1.state = 2, self1.on.call("start", node, node.__data__, self1.index, self1.group), 2 === self1.state) {
|
|
for(i = 0, self1.state = 3, tween = Array(n = self1.tween.length), j = -1; i < n; ++i)(o = self1.tween[i].value.call(node, node.__data__, self1.index, self1.group)) && (tween[++j] = o);
|
|
tween.length = j + 1;
|
|
}
|
|
}
|
|
function tick(elapsed) {
|
|
for(var t = elapsed < self1.duration ? self1.ease.call(null, elapsed / self1.duration) : (self1.timer.restart(stop), self1.state = 5, 1), i = -1, n = tween.length; ++i < n;)tween[i].call(node, t);
|
|
5 === self1.state && (self1.on.call("end", node, node.__data__, self1.index, self1.group), stop());
|
|
}
|
|
function stop() {
|
|
for(var i in self1.state = 6, self1.timer.stop(), delete schedules[id], schedules)return;
|
|
delete node.__transition;
|
|
}
|
|
schedules[id] = self1, self1.timer = timer(function(elapsed) {
|
|
self1.state = 1, self1.timer.restart(start, self1.delay, self1.time), self1.delay <= elapsed && start(elapsed - self1.delay);
|
|
}, 0, self1.time);
|
|
}(node, id, {
|
|
name: name,
|
|
index: index,
|
|
group: group,
|
|
on: emptyOn,
|
|
tween: emptyTween,
|
|
time: timing.time,
|
|
delay: timing.delay,
|
|
duration: timing.duration,
|
|
ease: timing.ease,
|
|
timer: null,
|
|
state: 0
|
|
});
|
|
}
|
|
function init(node, id) {
|
|
var schedule = get$1(node, id);
|
|
if (schedule.state > 0) throw Error("too late; already scheduled");
|
|
return schedule;
|
|
}
|
|
function set$2(node, id) {
|
|
var schedule = get$1(node, id);
|
|
if (schedule.state > 3) throw Error("too late; already running");
|
|
return schedule;
|
|
}
|
|
function get$1(node, id) {
|
|
var schedule = node.__transition;
|
|
if (!schedule || !(schedule = schedule[id])) throw Error("transition not found");
|
|
return schedule;
|
|
}
|
|
function interrupt(node, name) {
|
|
var schedule, active, i, schedules = node.__transition, empty = !0;
|
|
if (schedules) {
|
|
for(i in name = null == name ? null : name + "", schedules){
|
|
if ((schedule = schedules[i]).name !== name) {
|
|
empty = !1;
|
|
continue;
|
|
}
|
|
active = schedule.state > 2 && schedule.state < 5, schedule.state = 6, schedule.timer.stop(), schedule.on.call(active ? "interrupt" : "cancel", node, node.__data__, schedule.index, schedule.group), delete schedules[i];
|
|
}
|
|
empty && delete node.__transition;
|
|
}
|
|
}
|
|
function tweenRemove(id, name) {
|
|
var tween0, tween1;
|
|
return function() {
|
|
var schedule = set$2(this, id), tween = schedule.tween;
|
|
if (tween !== tween0) {
|
|
tween1 = tween0 = tween;
|
|
for(var i = 0, n = tween1.length; i < n; ++i)if (tween1[i].name === name) {
|
|
(tween1 = tween1.slice()).splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
schedule.tween = tween1;
|
|
};
|
|
}
|
|
function tweenFunction(id, name, value) {
|
|
var tween0, tween1;
|
|
if ("function" != typeof value) throw Error();
|
|
return function() {
|
|
var schedule = set$2(this, id), tween = schedule.tween;
|
|
if (tween !== tween0) {
|
|
tween1 = (tween0 = tween).slice();
|
|
for(var t = {
|
|
name: name,
|
|
value: value
|
|
}, i = 0, n = tween1.length; i < n; ++i)if (tween1[i].name === name) {
|
|
tween1[i] = t;
|
|
break;
|
|
}
|
|
i === n && tween1.push(t);
|
|
}
|
|
schedule.tween = tween1;
|
|
};
|
|
}
|
|
function tweenValue(transition, name, value) {
|
|
var id = transition._id;
|
|
return transition.each(function() {
|
|
var schedule = set$2(this, id);
|
|
(schedule.value || (schedule.value = {}))[name] = value.apply(this, arguments);
|
|
}), function(node) {
|
|
return get$1(node, id).value[name];
|
|
};
|
|
}
|
|
function interpolate$1(a, b) {
|
|
var c;
|
|
return ("number" == typeof b ? interpolateNumber : b instanceof color ? interpolateRgb : (c = color(b)) ? (b = c, interpolateRgb) : interpolateString)(a, b);
|
|
}
|
|
function attrRemove$1(name) {
|
|
return function() {
|
|
this.removeAttribute(name);
|
|
};
|
|
}
|
|
function attrRemoveNS$1(fullname) {
|
|
return function() {
|
|
this.removeAttributeNS(fullname.space, fullname.local);
|
|
};
|
|
}
|
|
function attrConstant$1(name, interpolate, value1) {
|
|
var string00, interpolate0, string1 = value1 + "";
|
|
return function() {
|
|
var string0 = this.getAttribute(name);
|
|
return string0 === string1 ? null : string0 === string00 ? interpolate0 : interpolate0 = interpolate(string00 = string0, value1);
|
|
};
|
|
}
|
|
function attrConstantNS$1(fullname, interpolate, value1) {
|
|
var string00, interpolate0, string1 = value1 + "";
|
|
return function() {
|
|
var string0 = this.getAttributeNS(fullname.space, fullname.local);
|
|
return string0 === string1 ? null : string0 === string00 ? interpolate0 : interpolate0 = interpolate(string00 = string0, value1);
|
|
};
|
|
}
|
|
function attrFunction$1(name, interpolate, value) {
|
|
var string00, string10, interpolate0;
|
|
return function() {
|
|
var string0, string1, value1 = value(this);
|
|
return null == value1 ? void this.removeAttribute(name) : (string0 = this.getAttribute(name)) === (string1 = value1 + "") ? null : string0 === string00 && string1 === string10 ? interpolate0 : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1));
|
|
};
|
|
}
|
|
function attrFunctionNS$1(fullname, interpolate, value) {
|
|
var string00, string10, interpolate0;
|
|
return function() {
|
|
var string0, string1, value1 = value(this);
|
|
return null == value1 ? void this.removeAttributeNS(fullname.space, fullname.local) : (string0 = this.getAttributeNS(fullname.space, fullname.local)) === (string1 = value1 + "") ? null : string0 === string00 && string1 === string10 ? interpolate0 : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1));
|
|
};
|
|
}
|
|
function attrTweenNS(fullname, value) {
|
|
var t0, i0;
|
|
function tween() {
|
|
var fullname1, i, i1 = value.apply(this, arguments);
|
|
return i1 !== i0 && (t0 = (i0 = i1) && (fullname1 = fullname, i = i1, function(t) {
|
|
this.setAttributeNS(fullname1.space, fullname1.local, i.call(this, t));
|
|
})), t0;
|
|
}
|
|
return tween._value = value, tween;
|
|
}
|
|
function attrTween(name, value) {
|
|
var t0, i0;
|
|
function tween() {
|
|
var name1, i, i1 = value.apply(this, arguments);
|
|
return i1 !== i0 && (t0 = (i0 = i1) && (name1 = name, i = i1, function(t) {
|
|
this.setAttribute(name1, i.call(this, t));
|
|
})), t0;
|
|
}
|
|
return tween._value = value, tween;
|
|
}
|
|
function delayFunction(id, value) {
|
|
return function() {
|
|
init(this, id).delay = +value.apply(this, arguments);
|
|
};
|
|
}
|
|
function delayConstant(id, value) {
|
|
return value = +value, function() {
|
|
init(this, id).delay = value;
|
|
};
|
|
}
|
|
function durationFunction(id, value) {
|
|
return function() {
|
|
set$2(this, id).duration = +value.apply(this, arguments);
|
|
};
|
|
}
|
|
function durationConstant(id, value) {
|
|
return value = +value, function() {
|
|
set$2(this, id).duration = value;
|
|
};
|
|
}
|
|
var Selection$1 = selection.prototype.constructor;
|
|
function styleRemove$1(name) {
|
|
return function() {
|
|
this.style.removeProperty(name);
|
|
};
|
|
}
|
|
var id = 0;
|
|
function Transition(groups, parents, name, id) {
|
|
this._groups = groups, this._parents = parents, this._name = name, this._id = id;
|
|
}
|
|
function transition(name) {
|
|
return selection().transition(name);
|
|
}
|
|
function newId() {
|
|
return ++id;
|
|
}
|
|
var selection_prototype = selection.prototype;
|
|
function quadInOut(t) {
|
|
return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2;
|
|
}
|
|
function cubicInOut(t) {
|
|
return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2;
|
|
}
|
|
Transition.prototype = transition.prototype = {
|
|
constructor: Transition,
|
|
select: function(select) {
|
|
var name = this._name, id = this._id;
|
|
"function" != typeof select && (select = selector(select));
|
|
for(var groups = this._groups, m = groups.length, subgroups = Array(m), j = 0; j < m; ++j)for(var node, subnode, group = groups[j], n = group.length, subgroup = subgroups[j] = Array(n), i = 0; i < n; ++i)(node = group[i]) && (subnode = select.call(node, node.__data__, i, group)) && ("__data__" in node && (subnode.__data__ = node.__data__), subgroup[i] = subnode, schedule(subgroup[i], name, id, i, subgroup, get$1(node, id)));
|
|
return new Transition(subgroups, this._parents, name, id);
|
|
},
|
|
selectAll: function(select) {
|
|
var name = this._name, id = this._id;
|
|
"function" != typeof select && (select = selectorAll(select));
|
|
for(var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j)for(var node, group = groups[j], n = group.length, i = 0; i < n; ++i)if (node = group[i]) {
|
|
for(var child, children = select.call(node, node.__data__, i, group), inherit = get$1(node, id), k = 0, l = children.length; k < l; ++k)(child = children[k]) && schedule(child, name, id, k, children, inherit);
|
|
subgroups.push(children), parents.push(node);
|
|
}
|
|
return new Transition(subgroups, parents, name, id);
|
|
},
|
|
filter: function(match) {
|
|
"function" != typeof match && (match = matcher(match));
|
|
for(var groups = this._groups, m = groups.length, subgroups = Array(m), j = 0; j < m; ++j)for(var node, group = groups[j], n = group.length, subgroup = subgroups[j] = [], i = 0; i < n; ++i)(node = group[i]) && match.call(node, node.__data__, i, group) && subgroup.push(node);
|
|
return new Transition(subgroups, this._parents, this._name, this._id);
|
|
},
|
|
merge: function(transition) {
|
|
if (transition._id !== this._id) throw Error();
|
|
for(var groups0 = this._groups, groups1 = transition._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = Array(m0), j = 0; j < m; ++j)for(var node, group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = Array(n), i = 0; i < n; ++i)(node = group0[i] || group1[i]) && (merge[i] = node);
|
|
for(; j < m0; ++j)merges[j] = groups0[j];
|
|
return new Transition(merges, this._parents, this._name, this._id);
|
|
},
|
|
selection: function() {
|
|
return new Selection$1(this._groups, this._parents);
|
|
},
|
|
transition: function() {
|
|
for(var name = this._name, id0 = this._id, id1 = newId(), groups = this._groups, m = groups.length, j = 0; j < m; ++j)for(var node, group = groups[j], n = group.length, i = 0; i < n; ++i)if (node = group[i]) {
|
|
var inherit = get$1(node, id0);
|
|
schedule(node, name, id1, i, group, {
|
|
time: inherit.time + inherit.delay + inherit.duration,
|
|
delay: 0,
|
|
duration: inherit.duration,
|
|
ease: inherit.ease
|
|
});
|
|
}
|
|
return new Transition(groups, this._parents, name, id1);
|
|
},
|
|
call: selection_prototype.call,
|
|
nodes: selection_prototype.nodes,
|
|
node: selection_prototype.node,
|
|
size: selection_prototype.size,
|
|
empty: selection_prototype.empty,
|
|
each: selection_prototype.each,
|
|
on: function(name, listener) {
|
|
var id, name1, listener1, on0, on1, sit, id1 = this._id;
|
|
return arguments.length < 2 ? get$1(this.node(), id1).on.on(name) : this.each((id = id1, name1 = name, listener1 = listener, sit = (name1 + "").trim().split(/^|\s+/).every(function(t) {
|
|
var i = t.indexOf(".");
|
|
return i >= 0 && (t = t.slice(0, i)), !t || "start" === t;
|
|
}) ? init : set$2, function() {
|
|
var schedule = sit(this, id), on = schedule.on;
|
|
on !== on0 && (on1 = (on0 = on).copy()).on(name1, listener1), schedule.on = on1;
|
|
}));
|
|
},
|
|
attr: function(name, value) {
|
|
var fullname = namespace(name), i = "transform" === fullname ? interpolateTransformSvg : interpolate$1;
|
|
return this.attrTween(name, "function" == typeof value ? (fullname.local ? attrFunctionNS$1 : attrFunction$1)(fullname, i, tweenValue(this, "attr." + name, value)) : null == value ? (fullname.local ? attrRemoveNS$1 : attrRemove$1)(fullname) : (fullname.local ? attrConstantNS$1 : attrConstant$1)(fullname, i, value));
|
|
},
|
|
attrTween: function(name, value) {
|
|
var key = "attr." + name;
|
|
if (arguments.length < 2) return (key = this.tween(key)) && key._value;
|
|
if (null == value) return this.tween(key, null);
|
|
if ("function" != typeof value) throw Error();
|
|
var fullname = namespace(name);
|
|
return this.tween(key, (fullname.local ? attrTweenNS : attrTween)(fullname, value));
|
|
},
|
|
style: function(name, value, priority) {
|
|
var name1, interpolate, string00, string10, interpolate0, name2, interpolate1, value1, string001, string101, interpolate01, id, name3, on0, on1, listener0, remove, key, event, name4, interpolate2, value11, string002, interpolate02, string1, i = "transform" == (name += "") ? interpolateTransformCss : interpolate$1;
|
|
return null == value ? this.styleTween(name, (name1 = name, function() {
|
|
var string0 = styleValue(this, name1), string1 = (this.style.removeProperty(name1), styleValue(this, name1));
|
|
return string0 === string1 ? null : string0 === string00 && string1 === string10 ? interpolate0 : interpolate0 = i(string00 = string0, string10 = string1);
|
|
})).on("end.style." + name, styleRemove$1(name)) : "function" == typeof value ? this.styleTween(name, (name2 = name, value1 = tweenValue(this, "style." + name, value), function() {
|
|
var string0 = styleValue(this, name2), value11 = value1(this), string1 = value11 + "";
|
|
return null == value11 && (this.style.removeProperty(name2), string1 = value11 = styleValue(this, name2)), string0 === string1 ? null : string0 === string001 && string1 === string101 ? interpolate01 : (string101 = string1, interpolate01 = i(string001 = string0, value11));
|
|
})).each((id = this._id, event = "end." + (key = "style." + (name3 = name)), function() {
|
|
var schedule = set$2(this, id), on = schedule.on, listener = null == schedule.value[key] ? remove || (remove = styleRemove$1(name3)) : void 0;
|
|
(on !== on0 || listener0 !== listener) && (on1 = (on0 = on).copy()).on(event, listener0 = listener), schedule.on = on1;
|
|
})) : this.styleTween(name, (name4 = name, string1 = value + "", function() {
|
|
var string0 = styleValue(this, name4);
|
|
return string0 === string1 ? null : string0 === string002 ? interpolate02 : interpolate02 = i(string002 = string0, value);
|
|
}), priority).on("end.style." + name, null);
|
|
},
|
|
styleTween: function(name, value, priority) {
|
|
var key = "style." + (name += "");
|
|
if (arguments.length < 2) return (key = this.tween(key)) && key._value;
|
|
if (null == value) return this.tween(key, null);
|
|
if ("function" != typeof value) throw Error();
|
|
return this.tween(key, function(name, value, priority) {
|
|
var t, i0;
|
|
function tween() {
|
|
var name1, i, priority1, i1 = value.apply(this, arguments);
|
|
return i1 !== i0 && (t = (i0 = i1) && (name1 = name, i = i1, priority1 = priority, function(t) {
|
|
this.style.setProperty(name1, i.call(this, t), priority1);
|
|
})), t;
|
|
}
|
|
return tween._value = value, tween;
|
|
}(name, value, null == priority ? "" : priority));
|
|
},
|
|
text: function(value) {
|
|
var value1, value2;
|
|
return this.tween("text", "function" == typeof value ? (value1 = tweenValue(this, "text", value), function() {
|
|
var value11 = value1(this);
|
|
this.textContent = null == value11 ? "" : value11;
|
|
}) : (value2 = null == value ? "" : value + "", function() {
|
|
this.textContent = value2;
|
|
}));
|
|
},
|
|
textTween: function(value) {
|
|
var key = "text";
|
|
if (arguments.length < 1) return (key = this.tween(key)) && key._value;
|
|
if (null == value) return this.tween(key, null);
|
|
if ("function" != typeof value) throw Error();
|
|
return this.tween(key, function(value) {
|
|
var t0, i0;
|
|
function tween() {
|
|
var i, i1 = value.apply(this, arguments);
|
|
return i1 !== i0 && (t0 = (i0 = i1) && (i = i1, function(t) {
|
|
this.textContent = i.call(this, t);
|
|
})), t0;
|
|
}
|
|
return tween._value = value, tween;
|
|
}(value));
|
|
},
|
|
remove: function() {
|
|
var id;
|
|
return this.on("end.remove", (id = this._id, function() {
|
|
var parent = this.parentNode;
|
|
for(var i in this.__transition)if (+i !== id) return;
|
|
parent && parent.removeChild(this);
|
|
}));
|
|
},
|
|
tween: function(name, value) {
|
|
var id = this._id;
|
|
if (name += "", arguments.length < 2) {
|
|
for(var t, tween = get$1(this.node(), id).tween, i = 0, n = tween.length; i < n; ++i)if ((t = tween[i]).name === name) return t.value;
|
|
return null;
|
|
}
|
|
return this.each((null == value ? tweenRemove : tweenFunction)(id, name, value));
|
|
},
|
|
delay: function(value) {
|
|
var id = this._id;
|
|
return arguments.length ? this.each(("function" == typeof value ? delayFunction : delayConstant)(id, value)) : get$1(this.node(), id).delay;
|
|
},
|
|
duration: function(value) {
|
|
var id = this._id;
|
|
return arguments.length ? this.each(("function" == typeof value ? durationFunction : durationConstant)(id, value)) : get$1(this.node(), id).duration;
|
|
},
|
|
ease: function(value) {
|
|
var id = this._id;
|
|
return arguments.length ? this.each(function(id, value) {
|
|
if ("function" != typeof value) throw Error();
|
|
return function() {
|
|
set$2(this, id).ease = value;
|
|
};
|
|
}(id, value)) : get$1(this.node(), id).ease;
|
|
},
|
|
easeVarying: function(value) {
|
|
var id, value1;
|
|
if ("function" != typeof value) throw Error();
|
|
return this.each((id = this._id, function() {
|
|
var v = value.apply(this, arguments);
|
|
if ("function" != typeof v) throw Error();
|
|
set$2(this, id).ease = v;
|
|
}));
|
|
},
|
|
end: function() {
|
|
var on0, on1, that = this, id = that._id, size = that.size();
|
|
return new Promise(function(resolve, reject) {
|
|
var cancel = {
|
|
value: reject
|
|
}, end = {
|
|
value: function() {
|
|
0 == --size && resolve();
|
|
}
|
|
};
|
|
that.each(function() {
|
|
var schedule = set$2(this, id), on = schedule.on;
|
|
on !== on0 && ((on1 = (on0 = on).copy())._.cancel.push(cancel), on1._.interrupt.push(cancel), on1._.end.push(end)), schedule.on = on1;
|
|
}), 0 === size && resolve();
|
|
});
|
|
},
|
|
[Symbol.iterator]: selection_prototype[Symbol.iterator]
|
|
};
|
|
var polyIn = function custom(e) {
|
|
function polyIn(t) {
|
|
return Math.pow(t, e);
|
|
}
|
|
return e = +e, polyIn.exponent = custom, polyIn;
|
|
}(3), polyOut = function custom(e) {
|
|
function polyOut(t) {
|
|
return 1 - Math.pow(1 - t, e);
|
|
}
|
|
return e = +e, polyOut.exponent = custom, polyOut;
|
|
}(3), polyInOut = function custom(e) {
|
|
function polyInOut(t) {
|
|
return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2;
|
|
}
|
|
return e = +e, polyInOut.exponent = custom, polyInOut;
|
|
}(3), pi = Math.PI, halfPi = pi / 2;
|
|
function sinInOut(t) {
|
|
return (1 - Math.cos(pi * t)) / 2;
|
|
}
|
|
function tpmt(x) {
|
|
return (Math.pow(2, -10 * x) - 0.0009765625) * 1.0009775171065494;
|
|
}
|
|
function expInOut(t) {
|
|
return ((t *= 2) <= 1 ? tpmt(1 - t) : 2 - tpmt(t - 1)) / 2;
|
|
}
|
|
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 / (4 / 11) / (4 / 11);
|
|
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;
|
|
}
|
|
var backIn = function custom(s) {
|
|
function backIn(t) {
|
|
return (t = +t) * t * (s * (t - 1) + t);
|
|
}
|
|
return s = +s, backIn.overshoot = custom, backIn;
|
|
}(1.70158), backOut = function custom(s) {
|
|
function backOut(t) {
|
|
return --t * t * ((t + 1) * s + t) + 1;
|
|
}
|
|
return s = +s, backOut.overshoot = custom, backOut;
|
|
}(1.70158), backInOut = function custom(s) {
|
|
function backInOut(t) {
|
|
return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2;
|
|
}
|
|
return s = +s, backInOut.overshoot = custom, backInOut;
|
|
}(1.70158), tau = 2 * Math.PI, 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);
|
|
}
|
|
return elasticIn.amplitude = function(a) {
|
|
return custom(a, p * tau);
|
|
}, elasticIn.period = function(p) {
|
|
return custom(a, p);
|
|
}, elasticIn;
|
|
}(1, 0.3), 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);
|
|
}
|
|
return elasticOut.amplitude = function(a) {
|
|
return custom(a, p * tau);
|
|
}, elasticOut.period = function(p) {
|
|
return custom(a, p);
|
|
}, elasticOut;
|
|
}(1, 0.3), elasticInOut = function custom(a, p) {
|
|
var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);
|
|
function elasticInOut(t) {
|
|
return ((t = 2 * t - 1) < 0 ? a * tpmt(-t) * Math.sin((s - t) / p) : 2 - a * tpmt(t) * Math.sin((s + t) / p)) / 2;
|
|
}
|
|
return elasticInOut.amplitude = function(a) {
|
|
return custom(a, p * tau);
|
|
}, elasticInOut.period = function(p) {
|
|
return custom(a, p);
|
|
}, elasticInOut;
|
|
}(1, 0.3), defaultTiming = {
|
|
time: null,
|
|
delay: 0,
|
|
duration: 250,
|
|
ease: cubicInOut
|
|
};
|
|
selection.prototype.interrupt = function(name) {
|
|
return this.each(function() {
|
|
interrupt(this, name);
|
|
});
|
|
}, selection.prototype.transition = function(name) {
|
|
var id, timing;
|
|
name instanceof Transition ? (id = name._id, name = name._name) : (id = newId(), (timing = defaultTiming).time = now(), name = null == name ? null : name + "");
|
|
for(var groups = this._groups, m = groups.length, j = 0; j < m; ++j)for(var node, group = groups[j], n = group.length, i = 0; i < n; ++i)(node = group[i]) && schedule(node, name, id, i, group, timing || function(node, id) {
|
|
for(var timing; !(timing = node.__transition) || !(timing = timing[id]);)if (!(node = node.parentNode)) throw Error(`transition ${id} not found`);
|
|
return timing;
|
|
}(node, id));
|
|
return new Transition(groups, this._parents, name, id);
|
|
};
|
|
var root$1 = [
|
|
null
|
|
], constant$4 = (x)=>()=>x;
|
|
function BrushEvent(type, { sourceEvent , target , selection , mode , dispatch }) {
|
|
Object.defineProperties(this, {
|
|
type: {
|
|
value: type,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
sourceEvent: {
|
|
value: sourceEvent,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
target: {
|
|
value: target,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
selection: {
|
|
value: selection,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
mode: {
|
|
value: mode,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
_: {
|
|
value: dispatch
|
|
}
|
|
});
|
|
}
|
|
function noevent$1(event) {
|
|
event.preventDefault(), event.stopImmediatePropagation();
|
|
}
|
|
var MODE_DRAG = {
|
|
name: "drag"
|
|
}, MODE_SPACE = {
|
|
name: "space"
|
|
}, MODE_HANDLE = {
|
|
name: "handle"
|
|
}, MODE_CENTER = {
|
|
name: "center"
|
|
};
|
|
const { abs , max: max$1 , min: min$1 } = Math;
|
|
function number1(e) {
|
|
return [
|
|
+e[0],
|
|
+e[1]
|
|
];
|
|
}
|
|
function number2(e) {
|
|
return [
|
|
number1(e[0]),
|
|
number1(e[1])
|
|
];
|
|
}
|
|
var X = {
|
|
name: "x",
|
|
handles: [
|
|
"w",
|
|
"e"
|
|
].map(type),
|
|
input: function(x, e) {
|
|
return null == x ? null : [
|
|
[
|
|
+x[0],
|
|
e[0][1]
|
|
],
|
|
[
|
|
+x[1],
|
|
e[1][1]
|
|
]
|
|
];
|
|
},
|
|
output: function(xy) {
|
|
return xy && [
|
|
xy[0][0],
|
|
xy[1][0]
|
|
];
|
|
}
|
|
}, Y = {
|
|
name: "y",
|
|
handles: [
|
|
"n",
|
|
"s"
|
|
].map(type),
|
|
input: function(y, e) {
|
|
return null == y ? null : [
|
|
[
|
|
e[0][0],
|
|
+y[0]
|
|
],
|
|
[
|
|
e[1][0],
|
|
+y[1]
|
|
]
|
|
];
|
|
},
|
|
output: function(xy) {
|
|
return xy && [
|
|
xy[0][1],
|
|
xy[1][1]
|
|
];
|
|
}
|
|
}, XY = {
|
|
name: "xy",
|
|
handles: [
|
|
"n",
|
|
"w",
|
|
"e",
|
|
"s",
|
|
"nw",
|
|
"ne",
|
|
"sw",
|
|
"se"
|
|
].map(type),
|
|
input: function(xy) {
|
|
return null == xy ? null : number2(xy);
|
|
},
|
|
output: function(xy) {
|
|
return xy;
|
|
}
|
|
}, cursors = {
|
|
overlay: "crosshair",
|
|
selection: "move",
|
|
n: "ns-resize",
|
|
e: "ew-resize",
|
|
s: "ns-resize",
|
|
w: "ew-resize",
|
|
nw: "nwse-resize",
|
|
ne: "nesw-resize",
|
|
se: "nwse-resize",
|
|
sw: "nesw-resize"
|
|
}, flipX = {
|
|
e: "w",
|
|
w: "e",
|
|
nw: "ne",
|
|
ne: "nw",
|
|
se: "sw",
|
|
sw: "se"
|
|
}, flipY = {
|
|
n: "s",
|
|
s: "n",
|
|
nw: "sw",
|
|
ne: "se",
|
|
se: "ne",
|
|
sw: "nw"
|
|
}, signsX = {
|
|
overlay: 1,
|
|
selection: 1,
|
|
n: null,
|
|
e: 1,
|
|
s: null,
|
|
w: -1,
|
|
nw: -1,
|
|
ne: 1,
|
|
se: 1,
|
|
sw: -1
|
|
}, signsY = {
|
|
overlay: 1,
|
|
selection: 1,
|
|
n: -1,
|
|
e: null,
|
|
s: 1,
|
|
w: null,
|
|
nw: -1,
|
|
ne: -1,
|
|
se: 1,
|
|
sw: 1
|
|
};
|
|
function type(t) {
|
|
return {
|
|
type: t
|
|
};
|
|
}
|
|
function defaultFilter$1(event) {
|
|
return !event.ctrlKey && !event.button;
|
|
}
|
|
function defaultExtent() {
|
|
var svg = this.ownerSVGElement || this;
|
|
return svg.hasAttribute("viewBox") ? [
|
|
[
|
|
(svg = svg.viewBox.baseVal).x,
|
|
svg.y
|
|
],
|
|
[
|
|
svg.x + svg.width,
|
|
svg.y + svg.height
|
|
]
|
|
] : [
|
|
[
|
|
0,
|
|
0
|
|
],
|
|
[
|
|
svg.width.baseVal.value,
|
|
svg.height.baseVal.value
|
|
]
|
|
];
|
|
}
|
|
function defaultTouchable$1() {
|
|
return navigator.maxTouchPoints || "ontouchstart" in this;
|
|
}
|
|
function local$1(node) {
|
|
for(; !node.__brush;)if (!(node = node.parentNode)) return;
|
|
return node.__brush;
|
|
}
|
|
function brush$1(dim) {
|
|
var touchending, extent = defaultExtent, filter = defaultFilter$1, touchable = defaultTouchable$1, keys = !0, listeners = dispatch("start", "brush", "end"), handleSize = 6;
|
|
function brush(group) {
|
|
var overlay = group.property("__brush", initialize).selectAll(".overlay").data([
|
|
type("overlay")
|
|
]);
|
|
overlay.enter().append("rect").attr("class", "overlay").attr("pointer-events", "all").attr("cursor", cursors.overlay).merge(overlay).each(function() {
|
|
var extent = local$1(this).extent;
|
|
select(this).attr("x", extent[0][0]).attr("y", extent[0][1]).attr("width", extent[1][0] - extent[0][0]).attr("height", extent[1][1] - extent[0][1]);
|
|
}), group.selectAll(".selection").data([
|
|
type("selection")
|
|
]).enter().append("rect").attr("class", "selection").attr("cursor", cursors.selection).attr("fill", "#777").attr("fill-opacity", 0.3).attr("stroke", "#fff").attr("shape-rendering", "crispEdges");
|
|
var handle = group.selectAll(".handle").data(dim.handles, function(d) {
|
|
return d.type;
|
|
});
|
|
handle.exit().remove(), handle.enter().append("rect").attr("class", function(d) {
|
|
return "handle handle--" + d.type;
|
|
}).attr("cursor", function(d) {
|
|
return cursors[d.type];
|
|
}), group.each(redraw).attr("fill", "none").attr("pointer-events", "all").on("mousedown.brush", started).filter(touchable).on("touchstart.brush", started).on("touchmove.brush", touchmoved).on("touchend.brush touchcancel.brush", touchended).style("touch-action", "none").style("-webkit-tap-highlight-color", "rgba(0,0,0,0)");
|
|
}
|
|
function redraw() {
|
|
var group = select(this), selection = local$1(this).selection;
|
|
selection ? (group.selectAll(".selection").style("display", null).attr("x", selection[0][0]).attr("y", selection[0][1]).attr("width", selection[1][0] - selection[0][0]).attr("height", selection[1][1] - selection[0][1]), group.selectAll(".handle").style("display", null).attr("x", function(d) {
|
|
return "e" === d.type[d.type.length - 1] ? selection[1][0] - handleSize / 2 : selection[0][0] - handleSize / 2;
|
|
}).attr("y", function(d) {
|
|
return "s" === d.type[0] ? selection[1][1] - handleSize / 2 : selection[0][1] - handleSize / 2;
|
|
}).attr("width", function(d) {
|
|
return "n" === d.type || "s" === d.type ? selection[1][0] - selection[0][0] + handleSize : handleSize;
|
|
}).attr("height", function(d) {
|
|
return "e" === d.type || "w" === d.type ? selection[1][1] - selection[0][1] + handleSize : handleSize;
|
|
})) : group.selectAll(".selection,.handle").style("display", "none").attr("x", null).attr("y", null).attr("width", null).attr("height", null);
|
|
}
|
|
function emitter(that, args, clean) {
|
|
var emit = that.__brush.emitter;
|
|
return !emit || clean && emit.clean ? new Emitter(that, args, clean) : emit;
|
|
}
|
|
function Emitter(that, args, clean) {
|
|
this.that = that, this.args = args, this.state = that.__brush, this.active = 0, this.clean = clean;
|
|
}
|
|
function started(event) {
|
|
if ((!touchending || event.touches) && filter.apply(this, arguments)) {
|
|
var w0, w1, n0, n1, e0, e1, s0, s1, moving, lockX, lockY, that = this, type = event.target.__data__.type, mode = (keys && event.metaKey ? type = "overlay" : type) === "selection" ? MODE_DRAG : keys && event.altKey ? MODE_CENTER : MODE_HANDLE, signX = dim === Y ? null : signsX[type], signY = dim === X ? null : signsY[type], state = local$1(that), extent = state.extent, selection = state.selection, W = extent[0][0], N = extent[0][1], E = extent[1][0], S = extent[1][1], dx = 0, dy = 0, shifting = signX && signY && keys && event.shiftKey, points = Array.from(event.touches || [
|
|
event
|
|
], (t)=>{
|
|
const i = t.identifier;
|
|
return (t = pointer(t, that)).point0 = t.slice(), t.identifier = i, t;
|
|
});
|
|
if ("overlay" === type) {
|
|
selection && (moving = !0);
|
|
const pts = [
|
|
points[0],
|
|
points[1] || points[0]
|
|
];
|
|
state.selection = selection = [
|
|
[
|
|
w0 = dim === Y ? W : min$1(pts[0][0], pts[1][0]),
|
|
n0 = dim === X ? N : min$1(pts[0][1], pts[1][1])
|
|
],
|
|
[
|
|
e0 = dim === Y ? E : max$1(pts[0][0], pts[1][0]),
|
|
s0 = dim === X ? S : max$1(pts[0][1], pts[1][1])
|
|
]
|
|
], points.length > 1 && move();
|
|
} else w0 = selection[0][0], n0 = selection[0][1], e0 = selection[1][0], s0 = selection[1][1];
|
|
w1 = w0, n1 = n0, e1 = e0, s1 = s0;
|
|
var group = select(that).attr("pointer-events", "none"), overlay = group.selectAll(".overlay").attr("cursor", cursors[type]);
|
|
interrupt(that);
|
|
var emit = emitter(that, arguments, !0).beforestart();
|
|
if (event.touches) emit.moved = moved, emit.ended = ended;
|
|
else {
|
|
var view = select(event.view).on("mousemove.brush", moved, !0).on("mouseup.brush", ended, !0);
|
|
keys && view.on("keydown.brush", function(event) {
|
|
switch(event.keyCode){
|
|
case 16:
|
|
shifting = signX && signY;
|
|
break;
|
|
case 18:
|
|
mode === MODE_HANDLE && (signX && (e0 = e1 - dx * signX, w0 = w1 + dx * signX), signY && (s0 = s1 - dy * signY, n0 = n1 + dy * signY), mode = MODE_CENTER, move());
|
|
break;
|
|
case 32:
|
|
(mode === MODE_HANDLE || mode === MODE_CENTER) && (signX < 0 ? e0 = e1 - dx : signX > 0 && (w0 = w1 - dx), signY < 0 ? s0 = s1 - dy : signY > 0 && (n0 = n1 - dy), mode = MODE_SPACE, overlay.attr("cursor", cursors.selection), move());
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
noevent$1(event);
|
|
}, !0).on("keyup.brush", function(event) {
|
|
switch(event.keyCode){
|
|
case 16:
|
|
shifting && (lockX = lockY = shifting = !1, move());
|
|
break;
|
|
case 18:
|
|
mode === MODE_CENTER && (signX < 0 ? e0 = e1 : signX > 0 && (w0 = w1), signY < 0 ? s0 = s1 : signY > 0 && (n0 = n1), mode = MODE_HANDLE, move());
|
|
break;
|
|
case 32:
|
|
mode === MODE_SPACE && (event.altKey ? (signX && (e0 = e1 - dx * signX, w0 = w1 + dx * signX), signY && (s0 = s1 - dy * signY, n0 = n1 + dy * signY), mode = MODE_CENTER) : (signX < 0 ? e0 = e1 : signX > 0 && (w0 = w1), signY < 0 ? s0 = s1 : signY > 0 && (n0 = n1), mode = MODE_HANDLE), overlay.attr("cursor", cursors[type]), move());
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
noevent$1(event);
|
|
}, !0), dragDisable(event.view);
|
|
}
|
|
redraw.call(that), emit.start(event, mode.name);
|
|
}
|
|
function moved(event) {
|
|
for (const p of event.changedTouches || [
|
|
event
|
|
])for (const d of points)d.identifier === p.identifier && (d.cur = pointer(p, that));
|
|
if (shifting && !lockX && !lockY && 1 === points.length) {
|
|
const point = points[0];
|
|
abs(point.cur[0] - point[0]) > abs(point.cur[1] - point[1]) ? lockY = !0 : lockX = !0;
|
|
}
|
|
for (const point1 of points)point1.cur && (point1[0] = point1.cur[0], point1[1] = point1.cur[1]);
|
|
moving = !0, noevent$1(event), move(event);
|
|
}
|
|
function move(event) {
|
|
var t;
|
|
const point = points[0], point0 = point.point0;
|
|
switch(dx = point[0] - point0[0], dy = point[1] - point0[1], mode){
|
|
case MODE_SPACE:
|
|
case MODE_DRAG:
|
|
signX && (dx = max$1(W - w0, min$1(E - e0, dx)), w1 = w0 + dx, e1 = e0 + dx), signY && (dy = max$1(N - n0, min$1(S - s0, dy)), n1 = n0 + dy, s1 = s0 + dy);
|
|
break;
|
|
case MODE_HANDLE:
|
|
points[1] ? (signX && (w1 = max$1(W, min$1(E, points[0][0])), e1 = max$1(W, min$1(E, points[1][0])), signX = 1), signY && (n1 = max$1(N, min$1(S, points[0][1])), s1 = max$1(N, min$1(S, points[1][1])), signY = 1)) : (signX < 0 ? (dx = max$1(W - w0, min$1(E - w0, dx)), w1 = w0 + dx, e1 = e0) : signX > 0 && (dx = max$1(W - e0, min$1(E - e0, dx)), w1 = w0, e1 = e0 + dx), signY < 0 ? (dy = max$1(N - n0, min$1(S - n0, dy)), n1 = n0 + dy, s1 = s0) : signY > 0 && (dy = max$1(N - s0, min$1(S - s0, dy)), n1 = n0, s1 = s0 + dy));
|
|
break;
|
|
case MODE_CENTER:
|
|
signX && (w1 = max$1(W, min$1(E, w0 - dx * signX)), e1 = max$1(W, min$1(E, e0 + dx * signX))), signY && (n1 = max$1(N, min$1(S, n0 - dy * signY)), s1 = max$1(N, min$1(S, s0 + dy * signY)));
|
|
}
|
|
e1 < w1 && (signX *= -1, t = w0, w0 = e0, e0 = t, t = w1, w1 = e1, e1 = t, type in flipX && overlay.attr("cursor", cursors[type = flipX[type]])), s1 < n1 && (signY *= -1, t = n0, n0 = s0, s0 = t, t = n1, n1 = s1, s1 = t, type in flipY && overlay.attr("cursor", cursors[type = flipY[type]])), state.selection && (selection = state.selection), lockX && (w1 = selection[0][0], e1 = selection[1][0]), lockY && (n1 = selection[0][1], s1 = selection[1][1]), (selection[0][0] !== w1 || selection[0][1] !== n1 || selection[1][0] !== e1 || selection[1][1] !== s1) && (state.selection = [
|
|
[
|
|
w1,
|
|
n1
|
|
],
|
|
[
|
|
e1,
|
|
s1
|
|
]
|
|
], redraw.call(that), emit.brush(event, mode.name));
|
|
}
|
|
function ended(event) {
|
|
var extent;
|
|
if (!function(event) {
|
|
event.stopImmediatePropagation();
|
|
}(event), event.touches) {
|
|
if (event.touches.length) return;
|
|
touchending && clearTimeout(touchending), touchending = setTimeout(function() {
|
|
touchending = null;
|
|
}, 500);
|
|
} else yesdrag(event.view, moving), view.on("keydown.brush keyup.brush mousemove.brush mouseup.brush", null);
|
|
group.attr("pointer-events", "all"), overlay.attr("cursor", cursors.overlay), state.selection && (selection = state.selection), ((extent = selection)[0][0] === extent[1][0] || extent[0][1] === extent[1][1]) && (state.selection = null, redraw.call(that)), emit.end(event, mode.name);
|
|
}
|
|
}
|
|
function touchmoved(event) {
|
|
emitter(this, arguments).moved(event);
|
|
}
|
|
function touchended(event) {
|
|
emitter(this, arguments).ended(event);
|
|
}
|
|
function initialize() {
|
|
var state = this.__brush || {
|
|
selection: null
|
|
};
|
|
return state.extent = number2(extent.apply(this, arguments)), state.dim = dim, state;
|
|
}
|
|
return brush.move = function(group, selection) {
|
|
group.tween ? group.on("start.brush", function(event) {
|
|
emitter(this, arguments).beforestart().start(event);
|
|
}).on("interrupt.brush end.brush", function(event) {
|
|
emitter(this, arguments).end(event);
|
|
}).tween("brush", function() {
|
|
var that = this, state = that.__brush, emit = emitter(that, arguments), selection0 = state.selection, selection1 = dim.input("function" == typeof selection ? selection.apply(this, arguments) : selection, state.extent), i = interpolate(selection0, selection1);
|
|
function tween(t) {
|
|
state.selection = 1 === t && null === selection1 ? null : i(t), redraw.call(that), emit.brush();
|
|
}
|
|
return null !== selection0 && null !== selection1 ? tween : tween(1);
|
|
}) : group.each(function() {
|
|
var args = arguments, state = this.__brush, selection1 = dim.input("function" == typeof selection ? selection.apply(this, args) : selection, state.extent), emit = emitter(this, args).beforestart();
|
|
interrupt(this), state.selection = null === selection1 ? null : selection1, redraw.call(this), emit.start().brush().end();
|
|
});
|
|
}, brush.clear = function(group) {
|
|
brush.move(group, null);
|
|
}, Emitter.prototype = {
|
|
beforestart: function() {
|
|
return 1 == ++this.active && (this.state.emitter = this, this.starting = !0), this;
|
|
},
|
|
start: function(event, mode) {
|
|
return this.starting ? (this.starting = !1, this.emit("start", event, mode)) : this.emit("brush", event), this;
|
|
},
|
|
brush: function(event, mode) {
|
|
return this.emit("brush", event, mode), this;
|
|
},
|
|
end: function(event, mode) {
|
|
return 0 == --this.active && (delete this.state.emitter, this.emit("end", event, mode)), this;
|
|
},
|
|
emit: function(type, event, mode) {
|
|
var d = select(this.that).datum();
|
|
listeners.call(type, this.that, new BrushEvent(type, {
|
|
sourceEvent: event,
|
|
target: brush,
|
|
selection: dim.output(this.state.selection),
|
|
mode,
|
|
dispatch: listeners
|
|
}), d);
|
|
}
|
|
}, brush.extent = function(_) {
|
|
return arguments.length ? (extent = "function" == typeof _ ? _ : constant$4(number2(_)), brush) : extent;
|
|
}, brush.filter = function(_) {
|
|
return arguments.length ? (filter = "function" == typeof _ ? _ : constant$4(!!_), brush) : filter;
|
|
}, brush.touchable = function(_) {
|
|
return arguments.length ? (touchable = "function" == typeof _ ? _ : constant$4(!!_), brush) : touchable;
|
|
}, brush.handleSize = function(_) {
|
|
return arguments.length ? (handleSize = +_, brush) : handleSize;
|
|
}, brush.keyModifiers = function(_) {
|
|
return arguments.length ? (keys = !!_, brush) : keys;
|
|
}, brush.on = function() {
|
|
var value = listeners.on.apply(listeners, arguments);
|
|
return value === listeners ? brush : value;
|
|
}, brush;
|
|
}
|
|
var abs$1 = Math.abs, cos = Math.cos, sin = Math.sin, pi$1 = Math.PI, halfPi$1 = pi$1 / 2, tau$1 = 2 * pi$1, max$2 = Math.max;
|
|
function range(i, j) {
|
|
return Array.from({
|
|
length: j - i
|
|
}, (_, k)=>i + k);
|
|
}
|
|
function chord$1(directed, transpose) {
|
|
var padAngle = 0, sortGroups = null, sortSubgroups = null, sortChords = null;
|
|
function chord(matrix) {
|
|
var dx, n = matrix.length, groupSums = Array(n), groupIndex = range(0, n), chords = Array(n * n), groups = Array(n), k = 0;
|
|
matrix = Float64Array.from({
|
|
length: n * n
|
|
}, transpose ? (_, i)=>matrix[i % n][i / n | 0] : (_, i)=>matrix[i / n | 0][i % n]);
|
|
for(let i = 0; i < n; ++i){
|
|
let x = 0;
|
|
for(let j = 0; j < n; ++j)x += matrix[i * n + j] + directed * matrix[j * n + i];
|
|
k += groupSums[i] = x;
|
|
}
|
|
dx = (k = max$2(0, tau$1 - padAngle * n) / k) ? padAngle : tau$1 / n;
|
|
{
|
|
let x1 = 0;
|
|
for (const i1 of (sortGroups && groupIndex.sort((a, b)=>sortGroups(groupSums[a], groupSums[b])), groupIndex)){
|
|
const x0 = x1;
|
|
if (directed) {
|
|
const subgroupIndex = range(~n + 1, n).filter((j)=>j < 0 ? matrix[~j * n + i1] : matrix[i1 * n + j]);
|
|
for (const j1 of (sortSubgroups && subgroupIndex.sort((a, b)=>sortSubgroups(a < 0 ? -matrix[~a * n + i1] : matrix[i1 * n + a], b < 0 ? -matrix[~b * n + i1] : matrix[i1 * n + b])), subgroupIndex))if (j1 < 0) {
|
|
const chord = chords[~j1 * n + i1] || (chords[~j1 * n + i1] = {
|
|
source: null,
|
|
target: null
|
|
});
|
|
chord.target = {
|
|
index: i1,
|
|
startAngle: x1,
|
|
endAngle: x1 += matrix[~j1 * n + i1] * k,
|
|
value: matrix[~j1 * n + i1]
|
|
};
|
|
} else {
|
|
const chord1 = chords[i1 * n + j1] || (chords[i1 * n + j1] = {
|
|
source: null,
|
|
target: null
|
|
});
|
|
chord1.source = {
|
|
index: i1,
|
|
startAngle: x1,
|
|
endAngle: x1 += matrix[i1 * n + j1] * k,
|
|
value: matrix[i1 * n + j1]
|
|
};
|
|
}
|
|
groups[i1] = {
|
|
index: i1,
|
|
startAngle: x0,
|
|
endAngle: x1,
|
|
value: groupSums[i1]
|
|
};
|
|
} else {
|
|
const subgroupIndex1 = range(0, n).filter((j)=>matrix[i1 * n + j] || matrix[j * n + i1]);
|
|
for (const j2 of (sortSubgroups && subgroupIndex1.sort((a, b)=>sortSubgroups(matrix[i1 * n + a], matrix[i1 * n + b])), subgroupIndex1)){
|
|
let chord2;
|
|
if (i1 < j2 ? (chord2 = chords[i1 * n + j2] || (chords[i1 * n + j2] = {
|
|
source: null,
|
|
target: null
|
|
})).source = {
|
|
index: i1,
|
|
startAngle: x1,
|
|
endAngle: x1 += matrix[i1 * n + j2] * k,
|
|
value: matrix[i1 * n + j2]
|
|
} : ((chord2 = chords[j2 * n + i1] || (chords[j2 * n + i1] = {
|
|
source: null,
|
|
target: null
|
|
})).target = {
|
|
index: i1,
|
|
startAngle: x1,
|
|
endAngle: x1 += matrix[i1 * n + j2] * k,
|
|
value: matrix[i1 * n + j2]
|
|
}, i1 === j2 && (chord2.source = chord2.target)), chord2.source && chord2.target && chord2.source.value < chord2.target.value) {
|
|
const source = chord2.source;
|
|
chord2.source = chord2.target, chord2.target = source;
|
|
}
|
|
}
|
|
groups[i1] = {
|
|
index: i1,
|
|
startAngle: x0,
|
|
endAngle: x1,
|
|
value: groupSums[i1]
|
|
};
|
|
}
|
|
x1 += dx;
|
|
}
|
|
}
|
|
return (chords = Object.values(chords)).groups = groups, sortChords ? chords.sort(sortChords) : chords;
|
|
}
|
|
return chord.padAngle = function(_) {
|
|
return arguments.length ? (padAngle = max$2(0, _), chord) : padAngle;
|
|
}, chord.sortGroups = function(_) {
|
|
return arguments.length ? (sortGroups = _, chord) : sortGroups;
|
|
}, chord.sortSubgroups = function(_) {
|
|
return arguments.length ? (sortSubgroups = _, chord) : sortSubgroups;
|
|
}, chord.sortChords = function(_) {
|
|
var compare;
|
|
return arguments.length ? (null == _ ? sortChords = null : (sortChords = function(a, b) {
|
|
return _(a.source.value + a.target.value, b.source.value + b.target.value);
|
|
})._ = _, chord) : sortChords && sortChords._;
|
|
}, chord;
|
|
}
|
|
const pi$2 = Math.PI, tau$2 = 2 * pi$2, tauEpsilon = tau$2 - 1e-6;
|
|
function Path() {
|
|
this._x0 = this._y0 = this._x1 = this._y1 = null, this._ = "";
|
|
}
|
|
function path() {
|
|
return new Path;
|
|
}
|
|
Path.prototype = path.prototype = {
|
|
constructor: Path,
|
|
moveTo: function(x, y) {
|
|
this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y);
|
|
},
|
|
closePath: function() {
|
|
null !== this._x1 && (this._x1 = this._x0, this._y1 = this._y0, this._ += "Z");
|
|
},
|
|
lineTo: function(x, y) {
|
|
this._ += "L" + (this._x1 = +x) + "," + (this._y1 = +y);
|
|
},
|
|
quadraticCurveTo: function(x1, y1, x, y) {
|
|
this._ += "Q" + +x1 + "," + +y1 + "," + (this._x1 = +x) + "," + (this._y1 = +y);
|
|
},
|
|
bezierCurveTo: function(x1, y1, x2, y2, x, y) {
|
|
this._ += "C" + +x1 + "," + +y1 + "," + +x2 + "," + +y2 + "," + (this._x1 = +x) + "," + (this._y1 = +y);
|
|
},
|
|
arcTo: function(x1, y1, x2, y2, r) {
|
|
x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;
|
|
var x0 = this._x1, y0 = this._y1, x21 = x2 - x1, y21 = y2 - y1, x01 = x0 - x1, y01 = y0 - y1, l01_2 = x01 * x01 + y01 * y01;
|
|
if (r < 0) throw Error("negative radius: " + r);
|
|
if (null === this._x1) this._ += "M" + (this._x1 = x1) + "," + (this._y1 = y1);
|
|
else if (l01_2 > 1e-6) {
|
|
if (Math.abs(y01 * x21 - y21 * x01) > 1e-6 && r) {
|
|
var x20 = x2 - x0, y20 = y2 - y0, l21_2 = x21 * x21 + y21 * y21, l21 = Math.sqrt(l21_2), l01 = Math.sqrt(l01_2), l = r * Math.tan((pi$2 - Math.acos((l21_2 + l01_2 - (x20 * x20 + y20 * y20)) / (2 * l21 * l01))) / 2), t01 = l / l01, t21 = l / l21;
|
|
Math.abs(t01 - 1) > 1e-6 && (this._ += "L" + (x1 + t01 * x01) + "," + (y1 + t01 * y01)), this._ += "A" + r + "," + r + ",0,0," + +(y01 * x20 > x01 * y20) + "," + (this._x1 = x1 + t21 * x21) + "," + (this._y1 = y1 + t21 * y21);
|
|
} else this._ += "L" + (this._x1 = x1) + "," + (this._y1 = y1);
|
|
}
|
|
},
|
|
arc: function(x, y, r, a0, a1, ccw) {
|
|
x = +x, y = +y, r = +r, ccw = !!ccw;
|
|
var dx = r * Math.cos(a0), dy = r * Math.sin(a0), x0 = x + dx, y0 = y + dy, cw = 1 ^ ccw, da = ccw ? a0 - a1 : a1 - a0;
|
|
if (r < 0) throw Error("negative radius: " + r);
|
|
null === this._x1 ? this._ += "M" + x0 + "," + y0 : (Math.abs(this._x1 - x0) > 1e-6 || Math.abs(this._y1 - y0) > 1e-6) && (this._ += "L" + x0 + "," + y0), r && (da < 0 && (da = da % tau$2 + tau$2), da > tauEpsilon ? this._ += "A" + r + "," + r + ",0,1," + cw + "," + (x - dx) + "," + (y - dy) + "A" + r + "," + r + ",0,1," + cw + "," + (this._x1 = x0) + "," + (this._y1 = y0) : da > 1e-6 && (this._ += "A" + r + "," + r + ",0," + +(da >= pi$2) + "," + cw + "," + (this._x1 = x + r * Math.cos(a1)) + "," + (this._y1 = y + r * Math.sin(a1))));
|
|
},
|
|
rect: function(x, y, w, h) {
|
|
this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y) + "h" + +w + "v" + +h + "h" + -w + "Z";
|
|
},
|
|
toString: function() {
|
|
return this._;
|
|
}
|
|
};
|
|
var slice$2 = Array.prototype.slice;
|
|
function constant$5(x) {
|
|
return function() {
|
|
return x;
|
|
};
|
|
}
|
|
function defaultSource(d) {
|
|
return d.source;
|
|
}
|
|
function defaultTarget(d) {
|
|
return d.target;
|
|
}
|
|
function defaultRadius(d) {
|
|
return d.radius;
|
|
}
|
|
function defaultStartAngle(d) {
|
|
return d.startAngle;
|
|
}
|
|
function defaultEndAngle(d) {
|
|
return d.endAngle;
|
|
}
|
|
function defaultPadAngle() {
|
|
return 0;
|
|
}
|
|
function defaultArrowheadRadius() {
|
|
return 10;
|
|
}
|
|
function ribbon(headRadius) {
|
|
var source = defaultSource, target = defaultTarget, sourceRadius = defaultRadius, targetRadius = defaultRadius, startAngle = defaultStartAngle, endAngle = defaultEndAngle, padAngle = defaultPadAngle, context = null;
|
|
function ribbon() {
|
|
var buffer, s = source.apply(this, arguments), t = target.apply(this, arguments), ap = padAngle.apply(this, arguments) / 2, argv = slice$2.call(arguments), sr = +sourceRadius.apply(this, (argv[0] = s, argv)), sa0 = startAngle.apply(this, argv) - halfPi$1, sa1 = endAngle.apply(this, argv) - halfPi$1, tr = +targetRadius.apply(this, (argv[0] = t, argv)), ta0 = startAngle.apply(this, argv) - halfPi$1, ta1 = endAngle.apply(this, argv) - halfPi$1;
|
|
if (context || (context = buffer = path()), ap > 1e-12 && (abs$1(sa1 - sa0) > 2 * ap + 1e-12 ? sa1 > sa0 ? (sa0 += ap, sa1 -= ap) : (sa0 -= ap, sa1 += ap) : sa0 = sa1 = (sa0 + sa1) / 2, abs$1(ta1 - ta0) > 2 * ap + 1e-12 ? ta1 > ta0 ? (ta0 += ap, ta1 -= ap) : (ta0 -= ap, ta1 += ap) : ta0 = ta1 = (ta0 + ta1) / 2), context.moveTo(sr * cos(sa0), sr * sin(sa0)), context.arc(0, 0, sr, sa0, sa1), sa0 !== ta0 || sa1 !== ta1) {
|
|
if (headRadius) {
|
|
var hr = +headRadius.apply(this, arguments), tr2 = tr - hr, ta2 = (ta0 + ta1) / 2;
|
|
context.quadraticCurveTo(0, 0, tr2 * cos(ta0), tr2 * sin(ta0)), context.lineTo(tr * cos(ta2), tr * sin(ta2)), context.lineTo(tr2 * cos(ta1), tr2 * sin(ta1));
|
|
} else context.quadraticCurveTo(0, 0, tr * cos(ta0), tr * sin(ta0)), context.arc(0, 0, tr, ta0, ta1);
|
|
}
|
|
if (context.quadraticCurveTo(0, 0, sr * cos(sa0), sr * sin(sa0)), context.closePath(), buffer) return context = null, buffer + "" || null;
|
|
}
|
|
return headRadius && (ribbon.headRadius = function(_) {
|
|
return arguments.length ? (headRadius = "function" == typeof _ ? _ : constant$5(+_), ribbon) : headRadius;
|
|
}), ribbon.radius = function(_) {
|
|
return arguments.length ? (sourceRadius = targetRadius = "function" == typeof _ ? _ : constant$5(+_), ribbon) : sourceRadius;
|
|
}, ribbon.sourceRadius = function(_) {
|
|
return arguments.length ? (sourceRadius = "function" == typeof _ ? _ : constant$5(+_), ribbon) : sourceRadius;
|
|
}, ribbon.targetRadius = function(_) {
|
|
return arguments.length ? (targetRadius = "function" == typeof _ ? _ : constant$5(+_), ribbon) : targetRadius;
|
|
}, ribbon.startAngle = function(_) {
|
|
return arguments.length ? (startAngle = "function" == typeof _ ? _ : constant$5(+_), ribbon) : startAngle;
|
|
}, ribbon.endAngle = function(_) {
|
|
return arguments.length ? (endAngle = "function" == typeof _ ? _ : constant$5(+_), ribbon) : endAngle;
|
|
}, ribbon.padAngle = function(_) {
|
|
return arguments.length ? (padAngle = "function" == typeof _ ? _ : constant$5(+_), ribbon) : padAngle;
|
|
}, ribbon.source = function(_) {
|
|
return arguments.length ? (source = _, ribbon) : source;
|
|
}, ribbon.target = function(_) {
|
|
return arguments.length ? (target = _, ribbon) : target;
|
|
}, ribbon.context = function(_) {
|
|
return arguments.length ? (context = null == _ ? null : _, ribbon) : context;
|
|
}, ribbon;
|
|
}
|
|
var slice$3 = Array.prototype.slice;
|
|
function ascending$2(a, b) {
|
|
return a - b;
|
|
}
|
|
var constant$6 = (x)=>()=>x;
|
|
function noop$1() {}
|
|
var cases = [
|
|
[],
|
|
[
|
|
[
|
|
[
|
|
1.0,
|
|
1.5
|
|
],
|
|
[
|
|
0.5,
|
|
1.0
|
|
]
|
|
]
|
|
],
|
|
[
|
|
[
|
|
[
|
|
1.5,
|
|
1.0
|
|
],
|
|
[
|
|
1.0,
|
|
1.5
|
|
]
|
|
]
|
|
],
|
|
[
|
|
[
|
|
[
|
|
1.5,
|
|
1.0
|
|
],
|
|
[
|
|
0.5,
|
|
1.0
|
|
]
|
|
]
|
|
],
|
|
[
|
|
[
|
|
[
|
|
1.0,
|
|
0.5
|
|
],
|
|
[
|
|
1.5,
|
|
1.0
|
|
]
|
|
]
|
|
],
|
|
[
|
|
[
|
|
[
|
|
1.0,
|
|
1.5
|
|
],
|
|
[
|
|
0.5,
|
|
1.0
|
|
]
|
|
],
|
|
[
|
|
[
|
|
1.0,
|
|
0.5
|
|
],
|
|
[
|
|
1.5,
|
|
1.0
|
|
]
|
|
]
|
|
],
|
|
[
|
|
[
|
|
[
|
|
1.0,
|
|
0.5
|
|
],
|
|
[
|
|
1.0,
|
|
1.5
|
|
]
|
|
]
|
|
],
|
|
[
|
|
[
|
|
[
|
|
1.0,
|
|
0.5
|
|
],
|
|
[
|
|
0.5,
|
|
1.0
|
|
]
|
|
]
|
|
],
|
|
[
|
|
[
|
|
[
|
|
0.5,
|
|
1.0
|
|
],
|
|
[
|
|
1.0,
|
|
0.5
|
|
]
|
|
]
|
|
],
|
|
[
|
|
[
|
|
[
|
|
1.0,
|
|
1.5
|
|
],
|
|
[
|
|
1.0,
|
|
0.5
|
|
]
|
|
]
|
|
],
|
|
[
|
|
[
|
|
[
|
|
0.5,
|
|
1.0
|
|
],
|
|
[
|
|
1.0,
|
|
0.5
|
|
]
|
|
],
|
|
[
|
|
[
|
|
1.5,
|
|
1.0
|
|
],
|
|
[
|
|
1.0,
|
|
1.5
|
|
]
|
|
]
|
|
],
|
|
[
|
|
[
|
|
[
|
|
1.5,
|
|
1.0
|
|
],
|
|
[
|
|
1.0,
|
|
0.5
|
|
]
|
|
]
|
|
],
|
|
[
|
|
[
|
|
[
|
|
0.5,
|
|
1.0
|
|
],
|
|
[
|
|
1.5,
|
|
1.0
|
|
]
|
|
]
|
|
],
|
|
[
|
|
[
|
|
[
|
|
1.0,
|
|
1.5
|
|
],
|
|
[
|
|
1.5,
|
|
1.0
|
|
]
|
|
]
|
|
],
|
|
[
|
|
[
|
|
[
|
|
0.5,
|
|
1.0
|
|
],
|
|
[
|
|
1.0,
|
|
1.5
|
|
]
|
|
]
|
|
],
|
|
[]
|
|
];
|
|
function contours() {
|
|
var dx = 1, dy = 1, threshold = thresholdSturges, smooth = smoothLinear;
|
|
function contours(values) {
|
|
var tz = threshold(values);
|
|
if (Array.isArray(tz)) tz = tz.slice().sort(ascending$2);
|
|
else {
|
|
var domain = extent(values), start = domain[0], stop = domain[1];
|
|
tz = tickStep(start, stop, tz), tz = sequence(Math.floor(start / tz) * tz, Math.floor(stop / tz) * tz, tz);
|
|
}
|
|
return tz.map(function(value) {
|
|
return contour(values, value);
|
|
});
|
|
}
|
|
function contour(values, value) {
|
|
var polygons = [], holes = [];
|
|
return function(values, value, callback) {
|
|
var x, y, t0, t1, t2, t3, fragmentByStart = [], fragmentByEnd = [];
|
|
for(x = y = -1, cases[(t1 = values[0] >= value) << 1].forEach(stitch); ++x < dx - 1;)cases[(t0 = t1) | (t1 = values[x + 1] >= value) << 1].forEach(stitch);
|
|
for(cases[t1 << 0].forEach(stitch); ++y < dy - 1;){
|
|
for(x = -1, cases[(t1 = values[y * dx + dx] >= value) << 1 | (t2 = values[y * dx] >= value) << 2].forEach(stitch); ++x < dx - 1;)t0 = t1, t1 = values[y * dx + dx + x + 1] >= value, t3 = t2, cases[t0 | t1 << 1 | (t2 = values[y * dx + x + 1] >= value) << 2 | t3 << 3].forEach(stitch);
|
|
cases[t1 | t2 << 3].forEach(stitch);
|
|
}
|
|
for(x = -1, cases[(t2 = values[y * dx] >= value) << 2].forEach(stitch); ++x < dx - 1;)t3 = t2, cases[(t2 = values[y * dx + x + 1] >= value) << 2 | t3 << 3].forEach(stitch);
|
|
function stitch(line) {
|
|
var f, g, start = [
|
|
line[0][0] + x,
|
|
line[0][1] + y
|
|
], end = [
|
|
line[1][0] + x,
|
|
line[1][1] + y
|
|
], startIndex = index(start), endIndex = index(end);
|
|
(f = fragmentByEnd[startIndex]) ? (g = fragmentByStart[endIndex]) ? (delete fragmentByEnd[f.end], delete fragmentByStart[g.start], f === g ? (f.ring.push(end), callback(f.ring)) : fragmentByStart[f.start] = fragmentByEnd[g.end] = {
|
|
start: f.start,
|
|
end: g.end,
|
|
ring: f.ring.concat(g.ring)
|
|
}) : (delete fragmentByEnd[f.end], f.ring.push(end), fragmentByEnd[f.end = endIndex] = f) : (f = fragmentByStart[endIndex]) ? (g = fragmentByEnd[startIndex]) ? (delete fragmentByStart[f.start], delete fragmentByEnd[g.end], f === g ? (f.ring.push(end), callback(f.ring)) : fragmentByStart[g.start] = fragmentByEnd[f.end] = {
|
|
start: g.start,
|
|
end: f.end,
|
|
ring: g.ring.concat(f.ring)
|
|
}) : (delete fragmentByStart[f.start], f.ring.unshift(start), fragmentByStart[f.start = startIndex] = f) : fragmentByStart[startIndex] = fragmentByEnd[endIndex] = {
|
|
start: startIndex,
|
|
end: endIndex,
|
|
ring: [
|
|
start,
|
|
end
|
|
]
|
|
};
|
|
}
|
|
cases[t2 << 3].forEach(stitch);
|
|
}(values, value, function(ring) {
|
|
smooth(ring, values, value), function(ring) {
|
|
for(var i = 0, n = ring.length, area = ring[n - 1][1] * ring[0][0] - ring[n - 1][0] * ring[0][1]; ++i < n;)area += ring[i - 1][1] * ring[i][0] - ring[i - 1][0] * ring[i][1];
|
|
return area;
|
|
}(ring) > 0 ? polygons.push([
|
|
ring
|
|
]) : holes.push(ring);
|
|
}), holes.forEach(function(hole) {
|
|
for(var polygon, i = 0, n = polygons.length; i < n; ++i)if (-1 !== function(ring, hole) {
|
|
for(var c, i = -1, n = hole.length; ++i < n;)if (c = function(ring, point) {
|
|
for(var x = point[0], y = point[1], contains = -1, i = 0, n = ring.length, j = n - 1; i < n; j = i++){
|
|
var pi = ring[i], xi = pi[0], yi = pi[1], pj = ring[j], xj = pj[0], yj = pj[1];
|
|
if (function(a, b, c) {
|
|
var i, a1, b1, c1, p, q, r;
|
|
return a1 = a, b1 = b, c1 = c, (b1[0] - a1[0]) * (c1[1] - a1[1]) == (c1[0] - a1[0]) * (b1[1] - a1[1]) && (p = a[i = +(a[0] === b[0])], q = c[i], r = b[i], p <= q && q <= r || r <= q && q <= p);
|
|
}(pi, pj, point)) return 0;
|
|
yi > y != yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi && (contains = -contains);
|
|
}
|
|
return contains;
|
|
}(ring, hole[i])) return c;
|
|
return 0;
|
|
}((polygon = polygons[i])[0], hole)) {
|
|
polygon.push(hole);
|
|
return;
|
|
}
|
|
}), {
|
|
type: "MultiPolygon",
|
|
value: value,
|
|
coordinates: polygons
|
|
};
|
|
}
|
|
function index(point) {
|
|
return 2 * point[0] + point[1] * (dx + 1) * 4;
|
|
}
|
|
function smoothLinear(ring, values, value) {
|
|
ring.forEach(function(point) {
|
|
var v0, x = point[0], y = point[1], xt = 0 | x, yt = 0 | y, v1 = values[yt * dx + xt];
|
|
x > 0 && x < dx && xt === x && (v0 = values[yt * dx + xt - 1], point[0] = x + (value - v0) / (v1 - v0) - 0.5), y > 0 && y < dy && yt === y && (v0 = values[(yt - 1) * dx + xt], point[1] = y + (value - v0) / (v1 - v0) - 0.5);
|
|
});
|
|
}
|
|
return contours.contour = contour, contours.size = function(_) {
|
|
if (!arguments.length) return [
|
|
dx,
|
|
dy
|
|
];
|
|
var _0 = Math.floor(_[0]), _1 = Math.floor(_[1]);
|
|
if (!(_0 >= 0 && _1 >= 0)) throw Error("invalid size");
|
|
return dx = _0, dy = _1, contours;
|
|
}, contours.thresholds = function(_) {
|
|
return arguments.length ? (threshold = "function" == typeof _ ? _ : Array.isArray(_) ? constant$6(slice$3.call(_)) : constant$6(_), contours) : threshold;
|
|
}, contours.smooth = function(_) {
|
|
return arguments.length ? (smooth = _ ? smoothLinear : noop$1, contours) : smooth === smoothLinear;
|
|
}, contours;
|
|
}
|
|
function blurX(source, target, r) {
|
|
for(var n = source.width, m = source.height, w = (r << 1) + 1, j = 0; j < m; ++j)for(var i = 0, sr = 0; i < n + r; ++i)i < n && (sr += source.data[i + j * n]), i >= r && (i >= w && (sr -= source.data[i - w + j * n]), target.data[i - r + j * n] = sr / Math.min(i + 1, n - 1 + w - i, w));
|
|
}
|
|
function blurY(source, target, r) {
|
|
for(var n = source.width, m = source.height, w = (r << 1) + 1, i = 0; i < n; ++i)for(var j = 0, sr = 0; j < m + r; ++j)j < m && (sr += source.data[i + j * n]), j >= r && (j >= w && (sr -= source.data[i + (j - w) * n]), target.data[i + (j - r) * n] = sr / Math.min(j + 1, m - 1 + w - j, w));
|
|
}
|
|
function defaultX(d) {
|
|
return d[0];
|
|
}
|
|
function defaultY(d) {
|
|
return d[1];
|
|
}
|
|
function defaultWeight() {
|
|
return 1;
|
|
}
|
|
const EDGE_STACK = new Uint32Array(512);
|
|
class Delaunator {
|
|
static from(points, getX = defaultGetX, getY = defaultGetY) {
|
|
const n = points.length, coords = new Float64Array(2 * n);
|
|
for(let i = 0; i < n; i++){
|
|
const p = points[i];
|
|
coords[2 * i] = getX(p), coords[2 * i + 1] = getY(p);
|
|
}
|
|
return new Delaunator(coords);
|
|
}
|
|
constructor(coords){
|
|
const n = coords.length >> 1;
|
|
if (n > 0 && 'number' != typeof coords[0]) throw Error('Expected coords to contain numbers.');
|
|
this.coords = coords;
|
|
const maxTriangles = Math.max(2 * n - 5, 0);
|
|
this._triangles = new Uint32Array(3 * maxTriangles), this._halfedges = new Int32Array(3 * maxTriangles), this._hashSize = Math.ceil(Math.sqrt(n)), this._hullPrev = new Uint32Array(n), this._hullNext = new Uint32Array(n), this._hullTri = new Uint32Array(n), this._hullHash = new Int32Array(this._hashSize).fill(-1), this._ids = new Uint32Array(n), this._dists = new Float64Array(n), this.update();
|
|
}
|
|
update() {
|
|
const { coords , _hullPrev: hullPrev , _hullNext: hullNext , _hullTri: hullTri , _hullHash: hullHash } = this, n = coords.length >> 1;
|
|
let minX = 1 / 0, minY = 1 / 0, maxX = -1 / 0, maxY = -1 / 0;
|
|
for(let i = 0; i < n; i++){
|
|
const x = coords[2 * i], y = coords[2 * i + 1];
|
|
x < minX && (minX = x), y < minY && (minY = y), x > maxX && (maxX = x), y > maxY && (maxY = y), this._ids[i] = i;
|
|
}
|
|
const cx = (minX + maxX) / 2, cy = (minY + maxY) / 2;
|
|
let minDist = 1 / 0;
|
|
for(let i1 = 0; i1 < n; i1++){
|
|
const d = dist(cx, cy, coords[2 * i1], coords[2 * i1 + 1]);
|
|
d < minDist && (i0 = i1, minDist = d);
|
|
}
|
|
const i0x = coords[2 * i0], i0y = coords[2 * i0 + 1];
|
|
minDist = 1 / 0;
|
|
for(let i2 = 0; i2 < n; i2++){
|
|
if (i2 === i0) continue;
|
|
const d1 = dist(i0x, i0y, coords[2 * i2], coords[2 * i2 + 1]);
|
|
d1 < minDist && d1 > 0 && (i11 = i2, minDist = d1);
|
|
}
|
|
let i1x = coords[2 * i11], i1y = coords[2 * i11 + 1], minRadius = 1 / 0;
|
|
for(let i3 = 0; i3 < n; i3++){
|
|
if (i3 === i0 || i3 === i11) continue;
|
|
const r = function(ax, ay, bx, by, cx, cy) {
|
|
const dx = bx - ax, dy = by - ay, ex = cx - ax, ey = cy - ay, bl = dx * dx + dy * dy, cl = ex * ex + ey * ey, d = 0.5 / (dx * ey - dy * ex), x = (ey * bl - dy * cl) * d, y = (dx * cl - ex * bl) * d;
|
|
return x * x + y * y;
|
|
}(i0x, i0y, i1x, i1y, coords[2 * i3], coords[2 * i3 + 1]);
|
|
r < minRadius && (i21 = i3, minRadius = r);
|
|
}
|
|
let i2x = coords[2 * i21], i2y = coords[2 * i21 + 1];
|
|
if (minRadius === 1 / 0) {
|
|
for(let i4 = 0; i4 < n; i4++)this._dists[i4] = coords[2 * i4] - coords[0] || coords[2 * i4 + 1] - coords[1];
|
|
quicksort(this._ids, this._dists, 0, n - 1);
|
|
const hull = new Uint32Array(n);
|
|
let j = 0;
|
|
for(let i5 = 0, d0 = -1 / 0; i5 < n; i5++){
|
|
const id = this._ids[i5];
|
|
this._dists[id] > d0 && (hull[j++] = id, d0 = this._dists[id]);
|
|
}
|
|
this.hull = hull.subarray(0, j), this.triangles = new Uint32Array(0), this.halfedges = new Uint32Array(0);
|
|
return;
|
|
}
|
|
if (orient(i0x, i0y, i1x, i1y, i2x, i2y)) {
|
|
const i6 = i11, x1 = i1x, y1 = i1y;
|
|
i11 = i21, i1x = i2x, i1y = i2y, i21 = i6, i2x = x1, i2y = y1;
|
|
}
|
|
const center = function(ax, ay, bx, by, cx, cy) {
|
|
const dx = bx - ax, dy = by - ay, ex = cx - ax, ey = cy - ay, bl = dx * dx + dy * dy, cl = ex * ex + ey * ey, d = 0.5 / (dx * ey - dy * ex);
|
|
return {
|
|
x: ax + (ey * bl - dy * cl) * d,
|
|
y: ay + (dx * cl - ex * bl) * d
|
|
};
|
|
}(i0x, i0y, i1x, i1y, i2x, i2y);
|
|
this._cx = center.x, this._cy = center.y;
|
|
for(let i7 = 0; i7 < n; i7++)this._dists[i7] = dist(coords[2 * i7], coords[2 * i7 + 1], center.x, center.y);
|
|
quicksort(this._ids, this._dists, 0, n - 1), this._hullStart = i0;
|
|
let hullSize = 3;
|
|
hullNext[i0] = hullPrev[i21] = i11, hullNext[i11] = hullPrev[i0] = i21, hullNext[i21] = hullPrev[i11] = i0, hullTri[i0] = 0, hullTri[i11] = 1, hullTri[i21] = 2, hullHash.fill(-1), hullHash[this._hashKey(i0x, i0y)] = i0, hullHash[this._hashKey(i1x, i1y)] = i11, hullHash[this._hashKey(i2x, i2y)] = i21, this.trianglesLen = 0, this._addTriangle(i0, i11, i21, -1, -1, -1);
|
|
for(let i0, i11, i21, xp, yp, k = 0; k < this._ids.length; k++){
|
|
const i8 = this._ids[k], x2 = coords[2 * i8], y2 = coords[2 * i8 + 1];
|
|
if (k > 0 && 0.0000000000000002220446049250313 >= Math.abs(x2 - xp) && 0.0000000000000002220446049250313 >= Math.abs(y2 - yp) || (xp = x2, yp = y2, i8 === i0 || i8 === i11 || i8 === i21)) continue;
|
|
let start = 0;
|
|
for(let j1 = 0, key = this._hashKey(x2, y2); j1 < this._hashSize && (-1 === (start = hullHash[(key + j1) % this._hashSize]) || start === hullNext[start]); j1++);
|
|
let e = start = hullPrev[start], q;
|
|
for(; q = hullNext[e], !orient(x2, y2, coords[2 * e], coords[2 * e + 1], coords[2 * q], coords[2 * q + 1]);)if ((e = q) === start) {
|
|
e = -1;
|
|
break;
|
|
}
|
|
if (-1 === e) continue;
|
|
let t = this._addTriangle(e, i8, hullNext[e], -1, -1, hullTri[e]);
|
|
hullTri[i8] = this._legalize(t + 2), hullTri[e] = t, hullSize++;
|
|
let n1 = hullNext[e];
|
|
for(; q = hullNext[n1], orient(x2, y2, coords[2 * n1], coords[2 * n1 + 1], coords[2 * q], coords[2 * q + 1]);)t = this._addTriangle(n1, i8, q, hullTri[i8], -1, hullTri[n1]), hullTri[i8] = this._legalize(t + 2), hullNext[n1] = n1, hullSize--, n1 = q;
|
|
if (e === start) for(; orient(x2, y2, coords[2 * (q = hullPrev[e])], coords[2 * q + 1], coords[2 * e], coords[2 * e + 1]);)t = this._addTriangle(q, i8, e, -1, hullTri[e], hullTri[q]), this._legalize(t + 2), hullTri[q] = t, hullNext[e] = e, hullSize--, e = q;
|
|
this._hullStart = hullPrev[i8] = e, hullNext[e] = hullPrev[n1] = i8, hullNext[i8] = n1, hullHash[this._hashKey(x2, y2)] = i8, hullHash[this._hashKey(coords[2 * e], coords[2 * e + 1])] = e;
|
|
}
|
|
this.hull = new Uint32Array(hullSize);
|
|
for(let i9 = 0, e1 = this._hullStart; i9 < hullSize; i9++)this.hull[i9] = e1, e1 = hullNext[e1];
|
|
this.triangles = this._triangles.subarray(0, this.trianglesLen), this.halfedges = this._halfedges.subarray(0, this.trianglesLen);
|
|
}
|
|
_hashKey(x, y) {
|
|
return Math.floor(function(dx, dy) {
|
|
const p = dx / (Math.abs(dx) + Math.abs(dy));
|
|
return (dy > 0 ? 3 - p : 1 + p) / 4;
|
|
}(x - this._cx, y - this._cy) * this._hashSize) % this._hashSize;
|
|
}
|
|
_legalize(a) {
|
|
const { _triangles: triangles , _halfedges: halfedges , coords } = this;
|
|
let i = 0, ar = 0;
|
|
for(;;){
|
|
const b = halfedges[a], a0 = a - a % 3;
|
|
if (ar = a0 + (a + 2) % 3, -1 === b) {
|
|
if (0 === i) break;
|
|
a = EDGE_STACK[--i];
|
|
continue;
|
|
}
|
|
const b0 = b - b % 3, al = a0 + (a + 1) % 3, bl = b0 + (b + 2) % 3, p0 = triangles[ar], pr = triangles[a], pl = triangles[al], p1 = triangles[bl], illegal = function(ax, ay, bx, by, cx, cy, px, py) {
|
|
const dx = ax - px, dy = ay - py, ex = bx - px, ey = by - py, fx = cx - px, fy = cy - py, bp = ex * ex + ey * ey, cp = fx * fx + fy * fy;
|
|
return dx * (ey * cp - bp * fy) - dy * (ex * cp - bp * fx) + (dx * dx + dy * dy) * (ex * fy - ey * fx) < 0;
|
|
}(coords[2 * p0], coords[2 * p0 + 1], coords[2 * pr], coords[2 * pr + 1], coords[2 * pl], coords[2 * pl + 1], coords[2 * p1], coords[2 * p1 + 1]);
|
|
if (illegal) {
|
|
triangles[a] = p1, triangles[b] = p0;
|
|
const hbl = halfedges[bl];
|
|
if (-1 === hbl) {
|
|
let e = this._hullStart;
|
|
do {
|
|
if (this._hullTri[e] === bl) {
|
|
this._hullTri[e] = a;
|
|
break;
|
|
}
|
|
e = this._hullPrev[e];
|
|
}while (e !== this._hullStart)
|
|
}
|
|
this._link(a, hbl), this._link(b, halfedges[ar]), this._link(ar, bl);
|
|
const br = b0 + (b + 1) % 3;
|
|
i < EDGE_STACK.length && (EDGE_STACK[i++] = br);
|
|
} else {
|
|
if (0 === i) break;
|
|
a = EDGE_STACK[--i];
|
|
}
|
|
}
|
|
return ar;
|
|
}
|
|
_link(a, b) {
|
|
this._halfedges[a] = b, -1 !== b && (this._halfedges[b] = a);
|
|
}
|
|
_addTriangle(i0, i1, i2, a, b, c) {
|
|
const t = this.trianglesLen;
|
|
return this._triangles[t] = i0, this._triangles[t + 1] = i1, this._triangles[t + 2] = i2, this._link(t, a), this._link(t + 1, b), this._link(t + 2, c), this.trianglesLen += 3, t;
|
|
}
|
|
}
|
|
function dist(ax, ay, bx, by) {
|
|
const dx = ax - bx, dy = ay - by;
|
|
return dx * dx + dy * dy;
|
|
}
|
|
function orientIfSure(px, py, rx, ry, qx, qy) {
|
|
const l = (ry - py) * (qx - px), r = (rx - px) * (qy - py);
|
|
return Math.abs(l - r) >= 3.3306690738754716e-16 * Math.abs(l + r) ? l - r : 0;
|
|
}
|
|
function orient(rx, ry, qx, qy, px, py) {
|
|
const sign = orientIfSure(px, py, rx, ry, qx, qy) || orientIfSure(rx, ry, qx, qy, px, py) || orientIfSure(qx, qy, px, py, rx, ry);
|
|
return sign < 0;
|
|
}
|
|
function quicksort(ids, dists, left, right) {
|
|
if (right - left <= 20) for(let i = left + 1; i <= right; i++){
|
|
const temp = ids[i], tempDist = dists[temp];
|
|
let j = i - 1;
|
|
for(; j >= left && dists[ids[j]] > tempDist;)ids[j + 1] = ids[j--];
|
|
ids[j + 1] = temp;
|
|
}
|
|
else {
|
|
let i1 = left + 1, j1 = right;
|
|
swap$1(ids, left + right >> 1, i1), dists[ids[left]] > dists[ids[right]] && swap$1(ids, left, right), dists[ids[i1]] > dists[ids[right]] && swap$1(ids, i1, right), dists[ids[left]] > dists[ids[i1]] && swap$1(ids, left, i1);
|
|
const temp1 = ids[i1], tempDist1 = dists[temp1];
|
|
for(;;){
|
|
do i1++;
|
|
while (dists[ids[i1]] < tempDist1)
|
|
do j1--;
|
|
while (dists[ids[j1]] > tempDist1)
|
|
if (j1 < i1) break;
|
|
swap$1(ids, i1, j1);
|
|
}
|
|
ids[left + 1] = ids[j1], ids[j1] = temp1, right - i1 + 1 >= j1 - left ? (quicksort(ids, dists, i1, right), quicksort(ids, dists, left, j1 - 1)) : (quicksort(ids, dists, left, j1 - 1), quicksort(ids, dists, i1, right));
|
|
}
|
|
}
|
|
function swap$1(arr, i, j) {
|
|
const tmp = arr[i];
|
|
arr[i] = arr[j], arr[j] = tmp;
|
|
}
|
|
function defaultGetX(p) {
|
|
return p[0];
|
|
}
|
|
function defaultGetY(p) {
|
|
return p[1];
|
|
}
|
|
class Path$1 {
|
|
constructor(){
|
|
this._x0 = this._y0 = this._x1 = this._y1 = null, this._ = "";
|
|
}
|
|
moveTo(x, y) {
|
|
this._ += `M${this._x0 = this._x1 = +x},${this._y0 = this._y1 = +y}`;
|
|
}
|
|
closePath() {
|
|
null !== this._x1 && (this._x1 = this._x0, this._y1 = this._y0, this._ += "Z");
|
|
}
|
|
lineTo(x, y) {
|
|
this._ += `L${this._x1 = +x},${this._y1 = +y}`;
|
|
}
|
|
arc(x, y, r) {
|
|
x = +x, y = +y, r = +r;
|
|
const x0 = x + r, y0 = y;
|
|
if (r < 0) throw Error("negative radius");
|
|
null === this._x1 ? this._ += `M${x0},${y0}` : (Math.abs(this._x1 - x0) > 1e-6 || Math.abs(this._y1 - y0) > 1e-6) && (this._ += "L" + x0 + "," + y0), r && (this._ += `A${r},${r},0,1,1,${x - r},${y}A${r},${r},0,1,1,${this._x1 = x0},${this._y1 = y0}`);
|
|
}
|
|
rect(x, y, w, h) {
|
|
this._ += `M${this._x0 = this._x1 = +x},${this._y0 = this._y1 = +y}h${+w}v${+h}h${-w}Z`;
|
|
}
|
|
value() {
|
|
return this._ || null;
|
|
}
|
|
}
|
|
class Polygon {
|
|
constructor(){
|
|
this._ = [];
|
|
}
|
|
moveTo(x, y) {
|
|
this._.push([
|
|
x,
|
|
y
|
|
]);
|
|
}
|
|
closePath() {
|
|
this._.push(this._[0].slice());
|
|
}
|
|
lineTo(x, y) {
|
|
this._.push([
|
|
x,
|
|
y
|
|
]);
|
|
}
|
|
value() {
|
|
return this._.length ? this._ : null;
|
|
}
|
|
}
|
|
class Voronoi {
|
|
constructor(delaunay, [xmin, ymin, xmax, ymax] = [
|
|
0,
|
|
0,
|
|
960,
|
|
500
|
|
]){
|
|
if (!((xmax = +xmax) >= (xmin = +xmin)) || !((ymax = +ymax) >= (ymin = +ymin))) throw Error("invalid bounds");
|
|
this.delaunay = delaunay, this._circumcenters = new Float64Array(2 * delaunay.points.length), this.vectors = new Float64Array(2 * delaunay.points.length), this.xmax = xmax, this.xmin = xmin, this.ymax = ymax, this.ymin = ymin, this._init();
|
|
}
|
|
update() {
|
|
return this.delaunay.update(), this._init(), this;
|
|
}
|
|
_init() {
|
|
const { delaunay: { points , hull , triangles } , vectors } = this, circumcenters = this.circumcenters = this._circumcenters.subarray(0, triangles.length / 3 * 2);
|
|
for(let i = 0, j = 0, n = triangles.length, x, y; i < n; i += 3, j += 2){
|
|
const t1 = 2 * triangles[i], t2 = 2 * triangles[i + 1], t3 = 2 * triangles[i + 2], x1 = points[t1], y1 = points[t1 + 1], x2 = points[t2], y2 = points[t2 + 1], x3 = points[t3], y3 = points[t3 + 1], dx = x2 - x1, dy = y2 - y1, ex = x3 - x1, ey = y3 - y1, bl = dx * dx + dy * dy, cl = ex * ex + ey * ey, ab = (dx * ey - dy * ex) * 2;
|
|
if (ab) {
|
|
if (1e-8 > Math.abs(ab)) x = (x1 + x3) / 2, y = (y1 + y3) / 2;
|
|
else {
|
|
const d = 1 / ab;
|
|
x = x1 + (ey * bl - dy * cl) * d, y = y1 + (dx * cl - ex * bl) * d;
|
|
}
|
|
} else x = (x1 + x3) / 2 - 1e8 * ey, y = (y1 + y3) / 2 + 1e8 * ex;
|
|
circumcenters[j] = x, circumcenters[j + 1] = y;
|
|
}
|
|
let h = hull[hull.length - 1], p0, p1 = 4 * h, x0, x11 = points[2 * h], y0, y11 = points[2 * h + 1];
|
|
vectors.fill(0);
|
|
for(let i1 = 0; i1 < hull.length; ++i1)h = hull[i1], p0 = p1, x0 = x11, y0 = y11, p1 = 4 * h, x11 = points[2 * h], y11 = points[2 * h + 1], vectors[p0 + 2] = vectors[p1] = y0 - y11, vectors[p0 + 3] = vectors[p1 + 1] = x11 - x0;
|
|
}
|
|
render(context) {
|
|
const buffer = null == context ? context = new Path$1 : void 0, { delaunay: { halfedges , inedges , hull } , circumcenters , vectors } = this;
|
|
if (hull.length <= 1) return null;
|
|
for(let i = 0, n = halfedges.length; i < n; ++i){
|
|
const j = halfedges[i];
|
|
if (j < i) continue;
|
|
const ti = 2 * Math.floor(i / 3), tj = 2 * Math.floor(j / 3), xi = circumcenters[ti], yi = circumcenters[ti + 1], xj = circumcenters[tj], yj = circumcenters[tj + 1];
|
|
this._renderSegment(xi, yi, xj, yj, context);
|
|
}
|
|
let h0, h1 = hull[hull.length - 1];
|
|
for(let i1 = 0; i1 < hull.length; ++i1){
|
|
h0 = h1, h1 = hull[i1];
|
|
const t = 2 * Math.floor(inedges[h1] / 3), x = circumcenters[t], y = circumcenters[t + 1], v = 4 * h0, p = this._project(x, y, vectors[v + 2], vectors[v + 3]);
|
|
p && this._renderSegment(x, y, p[0], p[1], context);
|
|
}
|
|
return buffer && buffer.value();
|
|
}
|
|
renderBounds(context) {
|
|
const buffer = null == context ? context = new Path$1 : void 0;
|
|
return context.rect(this.xmin, this.ymin, this.xmax - this.xmin, this.ymax - this.ymin), buffer && buffer.value();
|
|
}
|
|
renderCell(i, context) {
|
|
const buffer = null == context ? context = new Path$1 : void 0, points = this._clip(i);
|
|
if (null === points || !points.length) return;
|
|
context.moveTo(points[0], points[1]);
|
|
let n = points.length;
|
|
for(; points[0] === points[n - 2] && points[1] === points[n - 1] && n > 1;)n -= 2;
|
|
for(let i1 = 2; i1 < n; i1 += 2)(points[i1] !== points[i1 - 2] || points[i1 + 1] !== points[i1 - 1]) && context.lineTo(points[i1], points[i1 + 1]);
|
|
return context.closePath(), buffer && buffer.value();
|
|
}
|
|
*cellPolygons() {
|
|
const { delaunay: { points } } = this;
|
|
for(let i = 0, n = points.length / 2; i < n; ++i){
|
|
const cell = this.cellPolygon(i);
|
|
cell && (cell.index = i, yield cell);
|
|
}
|
|
}
|
|
cellPolygon(i) {
|
|
const polygon = new Polygon;
|
|
return this.renderCell(i, polygon), polygon.value();
|
|
}
|
|
_renderSegment(x0, y0, x1, y1, context) {
|
|
let S;
|
|
const c0 = this._regioncode(x0, y0), c1 = this._regioncode(x1, y1);
|
|
0 === c0 && 0 === c1 ? (context.moveTo(x0, y0), context.lineTo(x1, y1)) : (S = this._clipSegment(x0, y0, x1, y1, c0, c1)) && (context.moveTo(S[0], S[1]), context.lineTo(S[2], S[3]));
|
|
}
|
|
contains(i, x, y) {
|
|
return (x = +x) == x && (y = +y) == y && this.delaunay._step(i, x, y) === i;
|
|
}
|
|
*neighbors(i) {
|
|
const ci = this._clip(i);
|
|
if (ci) for (const j of this.delaunay.neighbors(i)){
|
|
const cj = this._clip(j);
|
|
if (cj) {
|
|
loop: for(let ai = 0, li = ci.length; ai < li; ai += 2)for(let aj = 0, lj = cj.length; aj < lj; aj += 2)if (ci[ai] == cj[aj] && ci[ai + 1] == cj[aj + 1] && ci[(ai + 2) % li] == cj[(aj + lj - 2) % lj] && ci[(ai + 3) % li] == cj[(aj + lj - 1) % lj]) {
|
|
yield j;
|
|
break loop;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_cell(i) {
|
|
const { circumcenters , delaunay: { inedges , halfedges , triangles } } = this, e0 = inedges[i];
|
|
if (-1 === e0) return null;
|
|
const points = [];
|
|
let e = e0;
|
|
do {
|
|
const t = Math.floor(e / 3);
|
|
if (points.push(circumcenters[2 * t], circumcenters[2 * t + 1]), triangles[e = e % 3 == 2 ? e - 2 : e + 1] !== i) break;
|
|
e = halfedges[e];
|
|
}while (e !== e0 && -1 !== e)
|
|
return points;
|
|
}
|
|
_clip(i) {
|
|
if (0 === i && 1 === this.delaunay.hull.length) return [
|
|
this.xmax,
|
|
this.ymin,
|
|
this.xmax,
|
|
this.ymax,
|
|
this.xmin,
|
|
this.ymax,
|
|
this.xmin,
|
|
this.ymin
|
|
];
|
|
const points = this._cell(i);
|
|
if (null === points) return null;
|
|
const { vectors: V } = this, v = 4 * i;
|
|
return V[v] || V[v + 1] ? this._clipInfinite(i, points, V[v], V[v + 1], V[v + 2], V[v + 3]) : this._clipFinite(i, points);
|
|
}
|
|
_clipFinite(i, points) {
|
|
const n = points.length;
|
|
let P = null, e0, e1, x0, y0, x1 = points[n - 2], y1 = points[n - 1], c0, c1 = this._regioncode(x1, y1);
|
|
for(let j = 0; j < n; j += 2)if (x0 = x1, y0 = y1, x1 = points[j], y1 = points[j + 1], c0 = c1, c1 = this._regioncode(x1, y1), 0 === c0 && 0 === c1) e0 = e1, e1 = 0, P ? P.push(x1, y1) : P = [
|
|
x1,
|
|
y1
|
|
];
|
|
else {
|
|
let S, sx0, sy0, sx1, sy1;
|
|
if (0 === c0) {
|
|
if (null === (S = this._clipSegment(x0, y0, x1, y1, c0, c1))) continue;
|
|
[sx0, sy0, sx1, sy1] = S;
|
|
} else {
|
|
if (null === (S = this._clipSegment(x1, y1, x0, y0, c1, c0))) continue;
|
|
[sx1, sy1, sx0, sy0] = S, e0 = e1, e1 = this._edgecode(sx0, sy0), e0 && e1 && this._edge(i, e0, e1, P, P.length), P ? P.push(sx0, sy0) : P = [
|
|
sx0,
|
|
sy0
|
|
];
|
|
}
|
|
e0 = e1, e1 = this._edgecode(sx1, sy1), e0 && e1 && this._edge(i, e0, e1, P, P.length), P ? P.push(sx1, sy1) : P = [
|
|
sx1,
|
|
sy1
|
|
];
|
|
}
|
|
if (P) e0 = e1, e1 = this._edgecode(P[0], P[1]), e0 && e1 && this._edge(i, e0, e1, P, P.length);
|
|
else if (this.contains(i, (this.xmin + this.xmax) / 2, (this.ymin + this.ymax) / 2)) return [
|
|
this.xmax,
|
|
this.ymin,
|
|
this.xmax,
|
|
this.ymax,
|
|
this.xmin,
|
|
this.ymax,
|
|
this.xmin,
|
|
this.ymin
|
|
];
|
|
return P;
|
|
}
|
|
_clipSegment(x0, y0, x1, y1, c0, c1) {
|
|
for(;;){
|
|
if (0 === c0 && 0 === c1) return [
|
|
x0,
|
|
y0,
|
|
x1,
|
|
y1
|
|
];
|
|
if (c0 & c1) return null;
|
|
let x, y, c = c0 || c1;
|
|
0b1000 & c ? (x = x0 + (x1 - x0) * (this.ymax - y0) / (y1 - y0), y = this.ymax) : 0b0100 & c ? (x = x0 + (x1 - x0) * (this.ymin - y0) / (y1 - y0), y = this.ymin) : 0b0010 & c ? (y = y0 + (y1 - y0) * (this.xmax - x0) / (x1 - x0), x = this.xmax) : (y = y0 + (y1 - y0) * (this.xmin - x0) / (x1 - x0), x = this.xmin), c0 ? (x0 = x, y0 = y, c0 = this._regioncode(x0, y0)) : (x1 = x, y1 = y, c1 = this._regioncode(x1, y1));
|
|
}
|
|
}
|
|
_clipInfinite(i, points, vx0, vy0, vxn, vyn) {
|
|
let P = Array.from(points), p;
|
|
if ((p = this._project(P[0], P[1], vx0, vy0)) && P.unshift(p[0], p[1]), (p = this._project(P[P.length - 2], P[P.length - 1], vxn, vyn)) && P.push(p[0], p[1]), P = this._clipFinite(i, P)) for(let j = 0, n = P.length, c0, c1 = this._edgecode(P[n - 2], P[n - 1]); j < n; j += 2)c0 = c1, c1 = this._edgecode(P[j], P[j + 1]), c0 && c1 && (j = this._edge(i, c0, c1, P, j), n = P.length);
|
|
else this.contains(i, (this.xmin + this.xmax) / 2, (this.ymin + this.ymax) / 2) && (P = [
|
|
this.xmin,
|
|
this.ymin,
|
|
this.xmax,
|
|
this.ymin,
|
|
this.xmax,
|
|
this.ymax,
|
|
this.xmin,
|
|
this.ymax
|
|
]);
|
|
return P;
|
|
}
|
|
_edge(i, e0, e1, P, j) {
|
|
for(; e0 !== e1;){
|
|
let x, y;
|
|
switch(e0){
|
|
case 0b0101:
|
|
e0 = 0b0100;
|
|
continue;
|
|
case 0b0100:
|
|
e0 = 0b0110, x = this.xmax, y = this.ymin;
|
|
break;
|
|
case 0b0110:
|
|
e0 = 0b0010;
|
|
continue;
|
|
case 0b0010:
|
|
e0 = 0b1010, x = this.xmax, y = this.ymax;
|
|
break;
|
|
case 0b1010:
|
|
e0 = 0b1000;
|
|
continue;
|
|
case 0b1000:
|
|
e0 = 0b1001, x = this.xmin, y = this.ymax;
|
|
break;
|
|
case 0b1001:
|
|
e0 = 0b0001;
|
|
continue;
|
|
case 0b0001:
|
|
e0 = 0b0101, x = this.xmin, y = this.ymin;
|
|
}
|
|
(P[j] !== x || P[j + 1] !== y) && this.contains(i, x, y) && (P.splice(j, 0, x, y), j += 2);
|
|
}
|
|
if (P.length > 4) for(let i1 = 0; i1 < P.length; i1 += 2){
|
|
const j1 = (i1 + 2) % P.length, k = (i1 + 4) % P.length;
|
|
(P[i1] === P[j1] && P[j1] === P[k] || P[i1 + 1] === P[j1 + 1] && P[j1 + 1] === P[k + 1]) && (P.splice(j1, 2), i1 -= 2);
|
|
}
|
|
return j;
|
|
}
|
|
_project(x0, y0, vx, vy) {
|
|
let t = 1 / 0, c, x, y;
|
|
if (vy < 0) {
|
|
if (y0 <= this.ymin) return null;
|
|
(c = (this.ymin - y0) / vy) < t && (y = this.ymin, x = x0 + (t = c) * vx);
|
|
} else if (vy > 0) {
|
|
if (y0 >= this.ymax) return null;
|
|
(c = (this.ymax - y0) / vy) < t && (y = this.ymax, x = x0 + (t = c) * vx);
|
|
}
|
|
if (vx > 0) {
|
|
if (x0 >= this.xmax) return null;
|
|
(c = (this.xmax - x0) / vx) < t && (x = this.xmax, y = y0 + (t = c) * vy);
|
|
} else if (vx < 0) {
|
|
if (x0 <= this.xmin) return null;
|
|
(c = (this.xmin - x0) / vx) < t && (x = this.xmin, y = y0 + (t = c) * vy);
|
|
}
|
|
return [
|
|
x,
|
|
y
|
|
];
|
|
}
|
|
_edgecode(x, y) {
|
|
return (x === this.xmin ? 0b0001 : x === this.xmax ? 0b0010 : 0b0000) | (y === this.ymin ? 0b0100 : y === this.ymax ? 0b1000 : 0b0000);
|
|
}
|
|
_regioncode(x, y) {
|
|
return (x < this.xmin ? 0b0001 : x > this.xmax ? 0b0010 : 0b0000) | (y < this.ymin ? 0b0100 : y > this.ymax ? 0b1000 : 0b0000);
|
|
}
|
|
}
|
|
const tau$3 = 2 * Math.PI, pow = Math.pow;
|
|
function pointX(p) {
|
|
return p[0];
|
|
}
|
|
function pointY(p) {
|
|
return p[1];
|
|
}
|
|
class Delaunay {
|
|
static from(points, fx = pointX, fy = pointY, that) {
|
|
return new Delaunay("length" in points ? function(points, fx, fy, that) {
|
|
const n = points.length, array = new Float64Array(2 * n);
|
|
for(let i = 0; i < n; ++i){
|
|
const p = points[i];
|
|
array[2 * i] = fx.call(that, p, i, points), array[2 * i + 1] = fy.call(that, p, i, points);
|
|
}
|
|
return array;
|
|
}(points, fx, fy, that) : Float64Array.from(function*(points, fx, fy, that) {
|
|
let i = 0;
|
|
for (const p of points)yield fx.call(that, p, i, points), yield fy.call(that, p, i, points), ++i;
|
|
}(points, fx, fy, that)));
|
|
}
|
|
constructor(points){
|
|
this._delaunator = new Delaunator(points), this.inedges = new Int32Array(points.length / 2), this._hullIndex = new Int32Array(points.length / 2), this.points = this._delaunator.coords, this._init();
|
|
}
|
|
update() {
|
|
return this._delaunator.update(), this._init(), this;
|
|
}
|
|
_init() {
|
|
const d = this._delaunator, points = this.points;
|
|
if (d.hull && d.hull.length > 2 && function(d) {
|
|
const { triangles , coords } = d;
|
|
for(let i = 0; i < triangles.length; i += 3){
|
|
const a = 2 * triangles[i], b = 2 * triangles[i + 1], c = 2 * triangles[i + 2], cross = (coords[c] - coords[a]) * (coords[b + 1] - coords[a + 1]) - (coords[b] - coords[a]) * (coords[c + 1] - coords[a + 1]);
|
|
if (cross > 1e-10) return !1;
|
|
}
|
|
return !0;
|
|
}(d)) {
|
|
this.collinear = Int32Array.from({
|
|
length: points.length / 2
|
|
}, (_, i)=>i).sort((i, j)=>points[2 * i] - points[2 * j] || points[2 * i + 1] - points[2 * j + 1]);
|
|
const e = this.collinear[0], f = this.collinear[this.collinear.length - 1], bounds = [
|
|
points[2 * e],
|
|
points[2 * e + 1],
|
|
points[2 * f],
|
|
points[2 * f + 1]
|
|
], r = 1e-8 * Math.hypot(bounds[3] - bounds[1], bounds[2] - bounds[0]);
|
|
for(let i = 0, n = points.length / 2; i < n; ++i){
|
|
var x, y, r1;
|
|
const p = (x = points[2 * i], [
|
|
x + Math.sin(x + (y = points[2 * i + 1])) * r,
|
|
y + Math.cos(x - y) * r
|
|
]);
|
|
points[2 * i] = p[0], points[2 * i + 1] = p[1];
|
|
}
|
|
this._delaunator = new Delaunator(points);
|
|
} else delete this.collinear;
|
|
const halfedges = this.halfedges = this._delaunator.halfedges, hull = this.hull = this._delaunator.hull, triangles = this.triangles = this._delaunator.triangles, inedges = this.inedges.fill(-1), hullIndex = this._hullIndex.fill(-1);
|
|
for(let e1 = 0, n1 = halfedges.length; e1 < n1; ++e1){
|
|
const p1 = triangles[e1 % 3 == 2 ? e1 - 2 : e1 + 1];
|
|
(-1 === halfedges[e1] || -1 === inedges[p1]) && (inedges[p1] = e1);
|
|
}
|
|
for(let i1 = 0, n2 = hull.length; i1 < n2; ++i1)hullIndex[hull[i1]] = i1;
|
|
hull.length <= 2 && hull.length > 0 && (this.triangles = new Int32Array(3).fill(-1), this.halfedges = new Int32Array(3).fill(-1), this.triangles[0] = hull[0], this.triangles[1] = hull[1], this.triangles[2] = hull[1], inedges[hull[0]] = 1, 2 === hull.length && (inedges[hull[1]] = 0));
|
|
}
|
|
voronoi(bounds) {
|
|
return new Voronoi(this, bounds);
|
|
}
|
|
*neighbors(i) {
|
|
const { inedges , hull , _hullIndex , halfedges , triangles , collinear } = this;
|
|
if (collinear) {
|
|
const l = collinear.indexOf(i);
|
|
l > 0 && (yield collinear[l - 1]), l < collinear.length - 1 && (yield collinear[l + 1]);
|
|
return;
|
|
}
|
|
const e0 = inedges[i];
|
|
if (-1 === e0) return;
|
|
let e = e0, p0 = -1;
|
|
do {
|
|
if (yield p0 = triangles[e], triangles[e = e % 3 == 2 ? e - 2 : e + 1] !== i) return;
|
|
if (-1 === (e = halfedges[e])) {
|
|
const p = hull[(_hullIndex[i] + 1) % hull.length];
|
|
p !== p0 && (yield p);
|
|
return;
|
|
}
|
|
}while (e !== e0)
|
|
}
|
|
find(x, y, i = 0) {
|
|
let c;
|
|
if ((x = +x) != x || (y = +y) != y) return -1;
|
|
const i0 = i;
|
|
for(; (c = this._step(i, x, y)) >= 0 && c !== i && c !== i0;)i = c;
|
|
return c;
|
|
}
|
|
_step(i, x, y) {
|
|
const { inedges , hull , _hullIndex , halfedges , triangles , points } = this;
|
|
if (-1 === inedges[i] || !points.length) return (i + 1) % (points.length >> 1);
|
|
let c = i, dc = pow(x - points[2 * i], 2) + pow(y - points[2 * i + 1], 2);
|
|
const e0 = inedges[i];
|
|
let e = e0;
|
|
do {
|
|
let t = triangles[e];
|
|
const dt = pow(x - points[2 * t], 2) + pow(y - points[2 * t + 1], 2);
|
|
if (dt < dc && (dc = dt, c = t), triangles[e = e % 3 == 2 ? e - 2 : e + 1] !== i) break;
|
|
if (-1 === (e = halfedges[e])) {
|
|
if ((e = hull[(_hullIndex[i] + 1) % hull.length]) !== t && pow(x - points[2 * e], 2) + pow(y - points[2 * e + 1], 2) < dc) return e;
|
|
break;
|
|
}
|
|
}while (e !== e0)
|
|
return c;
|
|
}
|
|
render(context) {
|
|
const buffer = null == context ? context = new Path$1 : void 0, { points , halfedges , triangles } = this;
|
|
for(let i = 0, n = halfedges.length; i < n; ++i){
|
|
const j = halfedges[i];
|
|
if (j < i) continue;
|
|
const ti = 2 * triangles[i], tj = 2 * triangles[j];
|
|
context.moveTo(points[ti], points[ti + 1]), context.lineTo(points[tj], points[tj + 1]);
|
|
}
|
|
return this.renderHull(context), buffer && buffer.value();
|
|
}
|
|
renderPoints(context, r = 2) {
|
|
const buffer = null == context ? context = new Path$1 : void 0, { points } = this;
|
|
for(let i = 0, n = points.length; i < n; i += 2){
|
|
const x = points[i], y = points[i + 1];
|
|
context.moveTo(x + r, y), context.arc(x, y, r, 0, tau$3);
|
|
}
|
|
return buffer && buffer.value();
|
|
}
|
|
renderHull(context) {
|
|
const buffer = null == context ? context = new Path$1 : void 0, { hull , points } = this, h = 2 * hull[0], n = hull.length;
|
|
context.moveTo(points[h], points[h + 1]);
|
|
for(let i = 1; i < n; ++i){
|
|
const h1 = 2 * hull[i];
|
|
context.lineTo(points[h1], points[h1 + 1]);
|
|
}
|
|
return context.closePath(), buffer && buffer.value();
|
|
}
|
|
hullPolygon() {
|
|
const polygon = new Polygon;
|
|
return this.renderHull(polygon), polygon.value();
|
|
}
|
|
renderTriangle(i, context) {
|
|
const buffer = null == context ? context = new Path$1 : void 0, { points , triangles } = this, t0 = 2 * triangles[i *= 3], t1 = 2 * triangles[i + 1], t2 = 2 * triangles[i + 2];
|
|
return context.moveTo(points[t0], points[t0 + 1]), context.lineTo(points[t1], points[t1 + 1]), context.lineTo(points[t2], points[t2 + 1]), context.closePath(), buffer && buffer.value();
|
|
}
|
|
*trianglePolygons() {
|
|
const { triangles } = this;
|
|
for(let i = 0, n = triangles.length / 3; i < n; ++i)yield this.trianglePolygon(i);
|
|
}
|
|
trianglePolygon(i) {
|
|
const polygon = new Polygon;
|
|
return this.renderTriangle(i, polygon), polygon.value();
|
|
}
|
|
}
|
|
var EOL = {}, EOF = {};
|
|
function objectConverter(columns) {
|
|
return Function("d", "return {" + columns.map(function(name, i) {
|
|
return JSON.stringify(name) + ": d[" + i + "] || \"\"";
|
|
}).join(",") + "}");
|
|
}
|
|
function inferColumns(rows) {
|
|
var columnSet = Object.create(null), columns = [];
|
|
return rows.forEach(function(row) {
|
|
for(var column in row)column in columnSet || columns.push(columnSet[column] = column);
|
|
}), columns;
|
|
}
|
|
function pad(value, width) {
|
|
var s = value + "", length = s.length;
|
|
return length < width ? Array(width - length + 1).join(0) + s : s;
|
|
}
|
|
function dsvFormat(delimiter) {
|
|
var reFormat = RegExp("[\"" + delimiter + "\n\r]"), DELIMITER = delimiter.charCodeAt(0);
|
|
function parseRows(text, f) {
|
|
var t, rows = [], N = text.length, I = 0, n = 0, eof = N <= 0, eol = !1;
|
|
function token() {
|
|
if (eof) return EOF;
|
|
if (eol) return eol = !1, EOL;
|
|
var i, c, j = I;
|
|
if (34 === text.charCodeAt(j)) {
|
|
for(; I++ < N && 34 !== text.charCodeAt(I) || 34 === text.charCodeAt(++I););
|
|
return (i = I) >= N ? eof = !0 : 10 === (c = text.charCodeAt(I++)) ? eol = !0 : 13 === c && (eol = !0, 10 === text.charCodeAt(I) && ++I), text.slice(j + 1, i - 1).replace(/""/g, "\"");
|
|
}
|
|
for(; I < N;){
|
|
if (10 === (c = text.charCodeAt(i = I++))) eol = !0;
|
|
else if (13 === c) eol = !0, 10 === text.charCodeAt(I) && ++I;
|
|
else if (c !== DELIMITER) continue;
|
|
return text.slice(j, i);
|
|
}
|
|
return eof = !0, text.slice(j, N);
|
|
}
|
|
for(10 === text.charCodeAt(N - 1) && --N, 13 === text.charCodeAt(N - 1) && --N; (t = token()) !== EOF;){
|
|
for(var row = []; t !== EOL && t !== EOF;)row.push(t), t = token();
|
|
(!f || null != (row = f(row, n++))) && rows.push(row);
|
|
}
|
|
return rows;
|
|
}
|
|
function preformatBody(rows, columns) {
|
|
return rows.map(function(row) {
|
|
return columns.map(function(column) {
|
|
return formatValue(row[column]);
|
|
}).join(delimiter);
|
|
});
|
|
}
|
|
function formatRow(row) {
|
|
return row.map(formatValue).join(delimiter);
|
|
}
|
|
function formatValue(value) {
|
|
var date, hours, minutes, seconds, milliseconds, year;
|
|
return null == value ? "" : value instanceof Date ? (hours = (date = value).getUTCHours(), minutes = date.getUTCMinutes(), seconds = date.getUTCSeconds(), milliseconds = date.getUTCMilliseconds(), isNaN(date) ? "Invalid Date" : ((year = date.getUTCFullYear()) < 0 ? "-" + pad(-year, 6) : year > 9999 ? "+" + pad(year, 6) : pad(year, 4)) + "-" + pad(date.getUTCMonth() + 1, 2) + "-" + pad(date.getUTCDate(), 2) + (milliseconds ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + ":" + pad(seconds, 2) + "." + pad(milliseconds, 3) + "Z" : seconds ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + ":" + pad(seconds, 2) + "Z" : minutes || hours ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + "Z" : "")) : reFormat.test(value += "") ? "\"" + value.replace(/"/g, "\"\"") + "\"" : value;
|
|
}
|
|
return {
|
|
parse: function(text, f) {
|
|
var convert, columns, rows = parseRows(text, function(row, i) {
|
|
var columns1, f1, object;
|
|
if (convert) return convert(row, i - 1);
|
|
columns = row, convert = f ? (object = objectConverter(row), function(row1, i) {
|
|
return f(object(row1), i, row);
|
|
}) : objectConverter(row);
|
|
});
|
|
return rows.columns = columns || [], rows;
|
|
},
|
|
parseRows: parseRows,
|
|
format: function(rows, columns) {
|
|
return null == columns && (columns = inferColumns(rows)), [
|
|
columns.map(formatValue).join(delimiter)
|
|
].concat(preformatBody(rows, columns)).join("\n");
|
|
},
|
|
formatBody: function(rows, columns) {
|
|
return null == columns && (columns = inferColumns(rows)), preformatBody(rows, columns).join("\n");
|
|
},
|
|
formatRows: function(rows) {
|
|
return rows.map(formatRow).join("\n");
|
|
},
|
|
formatRow: formatRow,
|
|
formatValue: formatValue
|
|
};
|
|
}
|
|
var csv = dsvFormat(","), csvParse = csv.parse, csvParseRows = csv.parseRows, csvFormat = csv.format, csvFormatBody = csv.formatBody, csvFormatRows = csv.formatRows, csvFormatRow = csv.formatRow, csvFormatValue = csv.formatValue, tsv = dsvFormat("\t"), tsvParse = tsv.parse, tsvParseRows = tsv.parseRows, tsvFormat = tsv.format, tsvFormatBody = tsv.formatBody, tsvFormatRows = tsv.formatRows, tsvFormatRow = tsv.formatRow, tsvFormatValue = tsv.formatValue;
|
|
const fixtz = new Date("2019-01-01T00:00").getHours() || new Date("2019-07-01T00:00").getHours();
|
|
function responseBlob(response) {
|
|
if (!response.ok) throw Error(response.status + " " + response.statusText);
|
|
return response.blob();
|
|
}
|
|
function responseArrayBuffer(response) {
|
|
if (!response.ok) throw Error(response.status + " " + response.statusText);
|
|
return response.arrayBuffer();
|
|
}
|
|
function responseText(response) {
|
|
if (!response.ok) throw Error(response.status + " " + response.statusText);
|
|
return response.text();
|
|
}
|
|
function text(input, init) {
|
|
return fetch(input, init).then(responseText);
|
|
}
|
|
function dsvParse(parse) {
|
|
return function(input, init, row) {
|
|
return 2 === arguments.length && "function" == typeof init && (row = init, init = void 0), text(input, init).then(function(response) {
|
|
return parse(response, row);
|
|
});
|
|
};
|
|
}
|
|
var csv$1 = dsvParse(csvParse), tsv$1 = dsvParse(tsvParse);
|
|
function responseJson(response) {
|
|
if (!response.ok) throw Error(response.status + " " + response.statusText);
|
|
if (204 !== response.status && 205 !== response.status) return response.json();
|
|
}
|
|
function parser(type) {
|
|
return (input, init)=>text(input, init).then((text)=>(new DOMParser).parseFromString(text, type));
|
|
}
|
|
var xml = parser("application/xml"), html = parser("text/html"), svg = parser("image/svg+xml");
|
|
function add(tree, x, y, d) {
|
|
if (isNaN(x) || isNaN(y)) return tree;
|
|
var parent, xm, ym, xp, yp, right, bottom, i, j, node = tree._root, leaf = {
|
|
data: d
|
|
}, x0 = tree._x0, y0 = tree._y0, x1 = tree._x1, y1 = tree._y1;
|
|
if (!node) return tree._root = leaf, tree;
|
|
for(; node.length;)if ((right = x >= (xm = (x0 + x1) / 2)) ? x0 = xm : x1 = xm, (bottom = y >= (ym = (y0 + y1) / 2)) ? y0 = ym : y1 = ym, parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree;
|
|
if (xp = +tree._x.call(null, node.data), yp = +tree._y.call(null, node.data), x === xp && y === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree;
|
|
do parent = parent ? parent[i] = [
|
|
,
|
|
,
|
|
,
|
|
,
|
|
] : tree._root = [
|
|
,
|
|
,
|
|
,
|
|
,
|
|
], (right = x >= (xm = (x0 + x1) / 2)) ? x0 = xm : x1 = xm, (bottom = y >= (ym = (y0 + y1) / 2)) ? y0 = ym : y1 = ym;
|
|
while ((i = bottom << 1 | right) == (j = (yp >= ym) << 1 | xp >= xm))
|
|
return parent[j] = node, parent[i] = leaf, tree;
|
|
}
|
|
function Quad(node, x0, y0, x1, y1) {
|
|
this.node = node, this.x0 = x0, this.y0 = y0, this.x1 = x1, this.y1 = y1;
|
|
}
|
|
function defaultX$1(d) {
|
|
return d[0];
|
|
}
|
|
function defaultY$1(d) {
|
|
return d[1];
|
|
}
|
|
function quadtree(nodes, x, y) {
|
|
var tree = new Quadtree(null == x ? defaultX$1 : x, null == y ? defaultY$1 : y, NaN, NaN, NaN, NaN);
|
|
return null == nodes ? tree : tree.addAll(nodes);
|
|
}
|
|
function Quadtree(x, y, x0, y0, x1, y1) {
|
|
this._x = x, this._y = y, this._x0 = x0, this._y0 = y0, this._x1 = x1, this._y1 = y1, this._root = void 0;
|
|
}
|
|
function leaf_copy(leaf) {
|
|
for(var copy = {
|
|
data: leaf.data
|
|
}, next = copy; leaf = leaf.next;)next = next.next = {
|
|
data: leaf.data
|
|
};
|
|
return copy;
|
|
}
|
|
var treeProto = quadtree.prototype = Quadtree.prototype;
|
|
function constant$7(x) {
|
|
return function() {
|
|
return x;
|
|
};
|
|
}
|
|
function jiggle(random) {
|
|
return (random() - 0.5) * 1e-6;
|
|
}
|
|
function x(d) {
|
|
return d.x + d.vx;
|
|
}
|
|
function y(d) {
|
|
return d.y + d.vy;
|
|
}
|
|
function index$1(d) {
|
|
return d.index;
|
|
}
|
|
function find$1(nodeById, nodeId) {
|
|
var node = nodeById.get(nodeId);
|
|
if (!node) throw Error("node not found: " + nodeId);
|
|
return node;
|
|
}
|
|
function x$1(d) {
|
|
return d.x;
|
|
}
|
|
function y$1(d) {
|
|
return d.y;
|
|
}
|
|
treeProto.copy = function() {
|
|
var nodes, child, copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1), node = this._root;
|
|
if (!node) return copy;
|
|
if (!node.length) return copy._root = leaf_copy(node), copy;
|
|
for(nodes = [
|
|
{
|
|
source: node,
|
|
target: copy._root = [
|
|
,
|
|
,
|
|
,
|
|
,
|
|
]
|
|
}
|
|
]; node = nodes.pop();)for(var i = 0; i < 4; ++i)(child = node.source[i]) && (child.length ? nodes.push({
|
|
source: child,
|
|
target: node.target[i] = [
|
|
,
|
|
,
|
|
,
|
|
,
|
|
]
|
|
}) : node.target[i] = leaf_copy(child));
|
|
return copy;
|
|
}, treeProto.add = function(d) {
|
|
const x = +this._x.call(null, d), y = +this._y.call(null, d);
|
|
return add(this.cover(x, y), x, y, d);
|
|
}, treeProto.addAll = function(data) {
|
|
var d, i, x, y, n = data.length, xz = Array(n), yz = Array(n), x0 = 1 / 0, y0 = 1 / 0, x1 = -1 / 0, y1 = -1 / 0;
|
|
for(i = 0; i < n; ++i)!(isNaN(x = +this._x.call(null, d = data[i])) || isNaN(y = +this._y.call(null, d))) && (xz[i] = x, yz[i] = y, x < x0 && (x0 = x), x > x1 && (x1 = x), y < y0 && (y0 = y), y > y1 && (y1 = y));
|
|
if (x0 > x1 || y0 > y1) return this;
|
|
for(this.cover(x0, y0).cover(x1, y1), i = 0; i < n; ++i)add(this, xz[i], yz[i], data[i]);
|
|
return this;
|
|
}, treeProto.cover = function(x, y) {
|
|
if (isNaN(x = +x) || isNaN(y = +y)) return this;
|
|
var x0 = this._x0, y0 = this._y0, x1 = this._x1, y1 = this._y1;
|
|
if (isNaN(x0)) x1 = (x0 = Math.floor(x)) + 1, y1 = (y0 = Math.floor(y)) + 1;
|
|
else {
|
|
for(var parent, i, z = x1 - x0 || 1, node = this._root; x0 > x || x >= x1 || y0 > y || y >= y1;)switch(i = (y < y0) << 1 | x < x0, (parent = [
|
|
,
|
|
,
|
|
,
|
|
,
|
|
])[i] = node, node = parent, z *= 2, i){
|
|
case 0:
|
|
x1 = x0 + z, y1 = y0 + z;
|
|
break;
|
|
case 1:
|
|
x0 = x1 - z, y1 = y0 + z;
|
|
break;
|
|
case 2:
|
|
x1 = x0 + z, y0 = y1 - z;
|
|
break;
|
|
case 3:
|
|
x0 = x1 - z, y0 = y1 - z;
|
|
}
|
|
this._root && this._root.length && (this._root = node);
|
|
}
|
|
return this._x0 = x0, this._y0 = y0, this._x1 = x1, this._y1 = y1, this;
|
|
}, treeProto.data = function() {
|
|
var data = [];
|
|
return this.visit(function(node) {
|
|
if (!node.length) do data.push(node.data);
|
|
while (node = node.next)
|
|
}), data;
|
|
}, treeProto.extent = function(_) {
|
|
return arguments.length ? this.cover(+_[0][0], +_[0][1]).cover(+_[1][0], +_[1][1]) : isNaN(this._x0) ? void 0 : [
|
|
[
|
|
this._x0,
|
|
this._y0
|
|
],
|
|
[
|
|
this._x1,
|
|
this._y1
|
|
]
|
|
];
|
|
}, treeProto.find = function(x, y, radius) {
|
|
var data, x1, y1, x2, y2, q, i, x0 = this._x0, y0 = this._y0, x3 = this._x1, y3 = this._y1, quads = [], node = this._root;
|
|
for(node && quads.push(new Quad(node, x0, y0, x3, y3)), null == radius ? radius = 1 / 0 : (x0 = x - radius, y0 = y - radius, x3 = x + radius, y3 = y + radius, radius *= radius); q = quads.pop();)if ((node = q.node) && !((x1 = q.x0) > x3) && !((y1 = q.y0) > y3) && !((x2 = q.x1) < x0) && !((y2 = q.y1) < y0)) {
|
|
if (node.length) {
|
|
var xm = (x1 + x2) / 2, ym = (y1 + y2) / 2;
|
|
quads.push(new Quad(node[3], xm, ym, x2, y2), new Quad(node[2], x1, ym, xm, y2), new Quad(node[1], xm, y1, x2, ym), new Quad(node[0], x1, y1, xm, ym)), (i = (y >= ym) << 1 | x >= xm) && (q = quads[quads.length - 1], quads[quads.length - 1] = quads[quads.length - 1 - i], quads[quads.length - 1 - i] = q);
|
|
} else {
|
|
var dx = x - +this._x.call(null, node.data), dy = y - +this._y.call(null, node.data), d2 = dx * dx + dy * dy;
|
|
if (d2 < radius) {
|
|
var d = Math.sqrt(radius = d2);
|
|
x0 = x - d, y0 = y - d, x3 = x + d, y3 = y + d, data = node.data;
|
|
}
|
|
}
|
|
}
|
|
return data;
|
|
}, treeProto.remove = function(d) {
|
|
if (isNaN(x = +this._x.call(null, d)) || isNaN(y = +this._y.call(null, d))) return this;
|
|
var parent, retainer, previous, next, x, y, xm, ym, right, bottom, i, j, node = this._root, x0 = this._x0, y0 = this._y0, x1 = this._x1, y1 = this._y1;
|
|
if (!node) return this;
|
|
if (node.length) for(;;){
|
|
if ((right = x >= (xm = (x0 + x1) / 2)) ? x0 = xm : x1 = xm, (bottom = y >= (ym = (y0 + y1) / 2)) ? y0 = ym : y1 = ym, parent = node, !(node = node[i = bottom << 1 | right])) return this;
|
|
if (!node.length) break;
|
|
(parent[i + 1 & 3] || parent[i + 2 & 3] || parent[i + 3 & 3]) && (retainer = parent, j = i);
|
|
}
|
|
for(; node.data !== d;)if (previous = node, !(node = node.next)) return this;
|
|
return ((next = node.next) && delete node.next, previous) ? (next ? previous.next = next : delete previous.next, this) : parent ? (next ? parent[i] = next : delete parent[i], (node = parent[0] || parent[1] || parent[2] || parent[3]) && node === (parent[3] || parent[2] || parent[1] || parent[0]) && !node.length && (retainer ? retainer[j] = node : this._root = node), this) : (this._root = next, this);
|
|
}, treeProto.removeAll = function(data) {
|
|
for(var i = 0, n = data.length; i < n; ++i)this.remove(data[i]);
|
|
return this;
|
|
}, treeProto.root = function() {
|
|
return this._root;
|
|
}, treeProto.size = function() {
|
|
var size = 0;
|
|
return this.visit(function(node) {
|
|
if (!node.length) do ++size;
|
|
while (node = node.next)
|
|
}), size;
|
|
}, treeProto.visit = function(callback) {
|
|
var q, child, x0, y0, x1, y1, quads = [], node = this._root;
|
|
for(node && quads.push(new Quad(node, this._x0, this._y0, this._x1, this._y1)); q = quads.pop();)if (!callback(node = q.node, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1) && node.length) {
|
|
var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;
|
|
(child = node[3]) && quads.push(new Quad(child, xm, ym, x1, y1)), (child = node[2]) && quads.push(new Quad(child, x0, ym, xm, y1)), (child = node[1]) && quads.push(new Quad(child, xm, y0, x1, ym)), (child = node[0]) && quads.push(new Quad(child, x0, y0, xm, ym));
|
|
}
|
|
return this;
|
|
}, treeProto.visitAfter = function(callback) {
|
|
var q, quads = [], next = [];
|
|
for(this._root && quads.push(new Quad(this._root, this._x0, this._y0, this._x1, this._y1)); q = quads.pop();){
|
|
var node = q.node;
|
|
if (node.length) {
|
|
var child, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;
|
|
(child = node[0]) && quads.push(new Quad(child, x0, y0, xm, ym)), (child = node[1]) && quads.push(new Quad(child, xm, y0, x1, ym)), (child = node[2]) && quads.push(new Quad(child, x0, ym, xm, y1)), (child = node[3]) && quads.push(new Quad(child, xm, ym, x1, y1));
|
|
}
|
|
next.push(q);
|
|
}
|
|
for(; q = next.pop();)callback(q.node, q.x0, q.y0, q.x1, q.y1);
|
|
return this;
|
|
}, treeProto.x = function(_) {
|
|
return arguments.length ? (this._x = _, this) : this._x;
|
|
}, treeProto.y = function(_) {
|
|
return arguments.length ? (this._y = _, this) : this._y;
|
|
};
|
|
var initialAngle = Math.PI * (3 - Math.sqrt(5));
|
|
function formatDecimalParts(x, p) {
|
|
if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf("e")) < 0) return null;
|
|
var i, coefficient = x.slice(0, i);
|
|
return [
|
|
coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,
|
|
+x.slice(i + 1)
|
|
];
|
|
}
|
|
function exponent$1(x) {
|
|
return (x = formatDecimalParts(Math.abs(x))) ? x[1] : NaN;
|
|
}
|
|
var re = /^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;
|
|
function formatSpecifier(specifier) {
|
|
var match;
|
|
if (!(match = re.exec(specifier))) throw Error("invalid format: " + specifier);
|
|
return new FormatSpecifier({
|
|
fill: match[1],
|
|
align: match[2],
|
|
sign: match[3],
|
|
symbol: match[4],
|
|
zero: match[5],
|
|
width: match[6],
|
|
comma: match[7],
|
|
precision: match[8] && match[8].slice(1),
|
|
trim: match[9],
|
|
type: match[10]
|
|
});
|
|
}
|
|
function FormatSpecifier(specifier) {
|
|
this.fill = void 0 === specifier.fill ? " " : specifier.fill + "", this.align = void 0 === specifier.align ? ">" : specifier.align + "", this.sign = void 0 === specifier.sign ? "-" : specifier.sign + "", this.symbol = void 0 === specifier.symbol ? "" : specifier.symbol + "", this.zero = !!specifier.zero, this.width = void 0 === specifier.width ? void 0 : +specifier.width, this.comma = !!specifier.comma, this.precision = void 0 === specifier.precision ? void 0 : +specifier.precision, this.trim = !!specifier.trim, this.type = void 0 === specifier.type ? "" : specifier.type + "";
|
|
}
|
|
function formatRounded(x, p) {
|
|
var d = formatDecimalParts(x, p);
|
|
if (!d) return x + "";
|
|
var coefficient = d[0], exponent = d[1];
|
|
return exponent < 0 ? "0." + Array(-exponent).join("0") + coefficient : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + "." + coefficient.slice(exponent + 1) : coefficient + Array(exponent - coefficient.length + 2).join("0");
|
|
}
|
|
formatSpecifier.prototype = FormatSpecifier.prototype, FormatSpecifier.prototype.toString = function() {
|
|
return this.fill + this.align + this.sign + this.symbol + (this.zero ? "0" : "") + (void 0 === this.width ? "" : Math.max(1, 0 | this.width)) + (this.comma ? "," : "") + (void 0 === this.precision ? "" : "." + Math.max(0, 0 | this.precision)) + (this.trim ? "~" : "") + this.type;
|
|
};
|
|
var formatTypes = {
|
|
"%": (x, p)=>(100 * x).toFixed(p),
|
|
b: (x)=>Math.round(x).toString(2),
|
|
c: (x)=>x + "",
|
|
d: function(x) {
|
|
return Math.abs(x = Math.round(x)) >= 1e21 ? x.toLocaleString("en").replace(/,/g, "") : x.toString(10);
|
|
},
|
|
e: (x, p)=>x.toExponential(p),
|
|
f: (x, p)=>x.toFixed(p),
|
|
g: (x, p)=>x.toPrecision(p),
|
|
o: (x)=>Math.round(x).toString(8),
|
|
p: (x, p)=>formatRounded(100 * x, p),
|
|
r: formatRounded,
|
|
s: function(x, p) {
|
|
var d = formatDecimalParts(x, p);
|
|
if (!d) return x + "";
|
|
var coefficient = d[0], exponent = d[1], i = exponent - (prefixExponent = 3 * Math.max(-8, Math.min(8, Math.floor(exponent / 3)))) + 1, n = coefficient.length;
|
|
return i === n ? coefficient : i > n ? coefficient + Array(i - n + 1).join("0") : i > 0 ? coefficient.slice(0, i) + "." + coefficient.slice(i) : "0." + Array(1 - i).join("0") + formatDecimalParts(x, Math.max(0, p + i - 1))[0];
|
|
},
|
|
X: (x)=>Math.round(x).toString(16).toUpperCase(),
|
|
x: (x)=>Math.round(x).toString(16)
|
|
};
|
|
function identity$3(x) {
|
|
return x;
|
|
}
|
|
var map$1 = Array.prototype.map, prefixes = [
|
|
"y",
|
|
"z",
|
|
"a",
|
|
"f",
|
|
"p",
|
|
"n",
|
|
"\xB5",
|
|
"m",
|
|
"",
|
|
"k",
|
|
"M",
|
|
"G",
|
|
"T",
|
|
"P",
|
|
"E",
|
|
"Z",
|
|
"Y"
|
|
];
|
|
function formatLocale(locale) {
|
|
var grouping, thousands, numerals, group = void 0 === locale.grouping || void 0 === locale.thousands ? identity$3 : (grouping = map$1.call(locale.grouping, Number), thousands = locale.thousands + "", function(value, width) {
|
|
for(var i = value.length, t = [], j = 0, g = grouping[0], length = 0; i > 0 && g > 0 && (length + g + 1 > width && (g = Math.max(1, width - length)), t.push(value.substring(i -= g, i + g)), !((length += g + 1) > width));)g = grouping[j = (j + 1) % grouping.length];
|
|
return t.reverse().join(thousands);
|
|
}), currencyPrefix = void 0 === locale.currency ? "" : locale.currency[0] + "", currencySuffix = void 0 === locale.currency ? "" : locale.currency[1] + "", decimal = void 0 === locale.decimal ? "." : locale.decimal + "", numerals1 = void 0 === locale.numerals ? identity$3 : (numerals = map$1.call(locale.numerals, String), function(value) {
|
|
return value.replace(/[0-9]/g, function(i) {
|
|
return numerals[+i];
|
|
});
|
|
}), percent = void 0 === locale.percent ? "%" : locale.percent + "", minus = void 0 === locale.minus ? "\u2212" : locale.minus + "", nan = void 0 === locale.nan ? "NaN" : locale.nan + "";
|
|
function newFormat(specifier) {
|
|
var fill = (specifier = formatSpecifier(specifier)).fill, align = specifier.align, sign = specifier.sign, symbol = specifier.symbol, zero = specifier.zero, width = specifier.width, comma = specifier.comma, precision = specifier.precision, trim = specifier.trim, type = specifier.type;
|
|
"n" === type ? (comma = !0, type = "g") : formatTypes[type] || (void 0 === precision && (precision = 12), trim = !0, type = "g"), (zero || "0" === fill && "=" === align) && (zero = !0, fill = "0", align = "=");
|
|
var prefix = "$" === symbol ? currencyPrefix : "#" === symbol && /[boxX]/.test(type) ? "0" + type.toLowerCase() : "", suffix = "$" === symbol ? currencySuffix : /[%p]/.test(type) ? percent : "", formatType = formatTypes[type], maybeSuffix = /[defgprs%]/.test(type);
|
|
function format(value) {
|
|
var i, n, c, valuePrefix = prefix, valueSuffix = suffix;
|
|
if ("c" === type) valueSuffix = formatType(value) + valueSuffix, value = "";
|
|
else {
|
|
var valueNegative = (value = +value) < 0 || 1 / value < 0;
|
|
if (value = isNaN(value) ? nan : formatType(Math.abs(value), precision), trim && (value = function(s) {
|
|
out: for(var i1, n = s.length, i = 1, i0 = -1; i < n; ++i)switch(s[i]){
|
|
case ".":
|
|
i0 = i1 = i;
|
|
break;
|
|
case "0":
|
|
0 === i0 && (i0 = i), i1 = i;
|
|
break;
|
|
default:
|
|
if (!+s[i]) break out;
|
|
i0 > 0 && (i0 = 0);
|
|
}
|
|
return i0 > 0 ? s.slice(0, i0) + s.slice(i1 + 1) : s;
|
|
}(value)), valueNegative && 0 == +value && "+" !== sign && (valueNegative = !1), valuePrefix = (valueNegative ? "(" === sign ? sign : minus : "-" === sign || "(" === sign ? "" : sign) + valuePrefix, valueSuffix = ("s" === type ? prefixes[8 + prefixExponent / 3] : "") + valueSuffix + (valueNegative && "(" === sign ? ")" : ""), maybeSuffix) {
|
|
for(i = -1, n = value.length; ++i < n;)if (48 > (c = value.charCodeAt(i)) || c > 57) {
|
|
valueSuffix = (46 === c ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix, value = value.slice(0, i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
comma && !zero && (value = group(value, 1 / 0));
|
|
var length = valuePrefix.length + value.length + valueSuffix.length, padding = length < width ? Array(width - length + 1).join(fill) : "";
|
|
switch(comma && zero && (value = group(padding + value, padding.length ? width - valueSuffix.length : 1 / 0), padding = ""), align){
|
|
case "<":
|
|
value = valuePrefix + value + valueSuffix + padding;
|
|
break;
|
|
case "=":
|
|
value = valuePrefix + padding + value + valueSuffix;
|
|
break;
|
|
case "^":
|
|
value = padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length);
|
|
break;
|
|
default:
|
|
value = padding + valuePrefix + value + valueSuffix;
|
|
}
|
|
return numerals1(value);
|
|
}
|
|
return precision = void 0 === precision ? 6 : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision)) : Math.max(0, Math.min(20, precision)), format.toString = function() {
|
|
return specifier + "";
|
|
}, format;
|
|
}
|
|
return {
|
|
format: newFormat,
|
|
formatPrefix: function(specifier, value) {
|
|
var f = newFormat(((specifier = formatSpecifier(specifier)).type = "f", specifier)), e = 3 * Math.max(-8, Math.min(8, Math.floor(exponent$1(value) / 3))), k = Math.pow(10, -e), prefix = prefixes[8 + e / 3];
|
|
return function(value) {
|
|
return f(k * value) + prefix;
|
|
};
|
|
}
|
|
};
|
|
}
|
|
function defaultLocale(definition) {
|
|
return locale = formatLocale(definition), exports1.format = locale.format, exports1.formatPrefix = locale.formatPrefix, locale;
|
|
}
|
|
function precisionFixed(step) {
|
|
return Math.max(0, -exponent$1(Math.abs(step)));
|
|
}
|
|
function precisionPrefix(step, value) {
|
|
return Math.max(0, 3 * Math.max(-8, Math.min(8, Math.floor(exponent$1(value) / 3))) - exponent$1(Math.abs(step)));
|
|
}
|
|
function precisionRound(step, max) {
|
|
return Math.max(0, exponent$1(max = Math.abs(max) - (step = Math.abs(step))) - exponent$1(step)) + 1;
|
|
}
|
|
defaultLocale({
|
|
thousands: ",",
|
|
grouping: [
|
|
3
|
|
],
|
|
currency: [
|
|
"$",
|
|
""
|
|
]
|
|
});
|
|
var pi$3 = Math.PI, halfPi$2 = pi$3 / 2, quarterPi = pi$3 / 4, tau$4 = 2 * pi$3, degrees$2 = 180 / pi$3, radians$1 = pi$3 / 180, abs$2 = Math.abs, atan = Math.atan, atan2 = Math.atan2, cos$1 = Math.cos, ceil = Math.ceil, exp = Math.exp, hypot = Math.hypot, log = Math.log, pow$1 = Math.pow, sin$1 = Math.sin, sign = Math.sign || function(x) {
|
|
return x > 0 ? 1 : x < 0 ? -1 : 0;
|
|
}, sqrt = Math.sqrt, tan = Math.tan;
|
|
function acos(x) {
|
|
return x > 1 ? 0 : x < -1 ? pi$3 : Math.acos(x);
|
|
}
|
|
function asin(x) {
|
|
return x > 1 ? halfPi$2 : x < -1 ? -halfPi$2 : Math.asin(x);
|
|
}
|
|
function haversin(x) {
|
|
return (x = sin$1(x / 2)) * x;
|
|
}
|
|
function noop$2() {}
|
|
function streamGeometry(geometry, stream) {
|
|
geometry && streamGeometryType.hasOwnProperty(geometry.type) && streamGeometryType[geometry.type](geometry, stream);
|
|
}
|
|
var streamObjectType = {
|
|
Feature: function(object, stream) {
|
|
streamGeometry(object.geometry, stream);
|
|
},
|
|
FeatureCollection: function(object, stream) {
|
|
for(var features = object.features, i = -1, n = features.length; ++i < n;)streamGeometry(features[i].geometry, stream);
|
|
}
|
|
}, streamGeometryType = {
|
|
Sphere: function(object, stream) {
|
|
stream.sphere();
|
|
},
|
|
Point: function(object, stream) {
|
|
object = object.coordinates, stream.point(object[0], object[1], object[2]);
|
|
},
|
|
MultiPoint: function(object, stream) {
|
|
for(var coordinates = object.coordinates, i = -1, n = coordinates.length; ++i < n;)object = coordinates[i], stream.point(object[0], object[1], object[2]);
|
|
},
|
|
LineString: function(object, stream) {
|
|
streamLine(object.coordinates, stream, 0);
|
|
},
|
|
MultiLineString: function(object, stream) {
|
|
for(var coordinates = object.coordinates, i = -1, n = coordinates.length; ++i < n;)streamLine(coordinates[i], stream, 0);
|
|
},
|
|
Polygon: function(object, stream) {
|
|
streamPolygon(object.coordinates, stream);
|
|
},
|
|
MultiPolygon: function(object, stream) {
|
|
for(var coordinates = object.coordinates, i = -1, n = coordinates.length; ++i < n;)streamPolygon(coordinates[i], stream);
|
|
},
|
|
GeometryCollection: function(object, stream) {
|
|
for(var geometries = object.geometries, i = -1, n = geometries.length; ++i < n;)streamGeometry(geometries[i], stream);
|
|
}
|
|
};
|
|
function streamLine(coordinates, stream, closed) {
|
|
var coordinate, i = -1, n = coordinates.length - closed;
|
|
for(stream.lineStart(); ++i < n;)coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]);
|
|
stream.lineEnd();
|
|
}
|
|
function streamPolygon(coordinates, stream) {
|
|
var i = -1, n = coordinates.length;
|
|
for(stream.polygonStart(); ++i < n;)streamLine(coordinates[i], stream, 1);
|
|
stream.polygonEnd();
|
|
}
|
|
function geoStream(object, stream) {
|
|
object && streamObjectType.hasOwnProperty(object.type) ? streamObjectType[object.type](object, stream) : streamGeometry(object, stream);
|
|
}
|
|
var prefixExponent, locale, lambda00, phi00, lambda0, cosPhi0, sinPhi0, areaRingSum = new Adder(), areaSum = new Adder(), areaStream = {
|
|
point: noop$2,
|
|
lineStart: noop$2,
|
|
lineEnd: noop$2,
|
|
polygonStart: function() {
|
|
areaRingSum = new Adder(), areaStream.lineStart = areaRingStart, areaStream.lineEnd = areaRingEnd;
|
|
},
|
|
polygonEnd: function() {
|
|
var areaRing = +areaRingSum;
|
|
areaSum.add(areaRing < 0 ? tau$4 + areaRing : areaRing), this.lineStart = this.lineEnd = this.point = noop$2;
|
|
},
|
|
sphere: function() {
|
|
areaSum.add(tau$4);
|
|
}
|
|
};
|
|
function areaRingStart() {
|
|
areaStream.point = areaPointFirst;
|
|
}
|
|
function areaRingEnd() {
|
|
areaPoint(lambda00, phi00);
|
|
}
|
|
function areaPointFirst(lambda, phi) {
|
|
areaStream.point = areaPoint, lambda00 = lambda, phi00 = phi, lambda *= radians$1, phi *= radians$1, lambda0 = lambda, cosPhi0 = cos$1(phi = phi / 2 + quarterPi), sinPhi0 = sin$1(phi);
|
|
}
|
|
function areaPoint(lambda, phi) {
|
|
lambda *= radians$1, phi *= radians$1;
|
|
var dLambda = lambda - lambda0, sdLambda = dLambda >= 0 ? 1 : -1, adLambda = sdLambda * dLambda, cosPhi = cos$1(phi = phi / 2 + quarterPi), sinPhi = sin$1(phi), k = sinPhi0 * sinPhi, u = cosPhi0 * cosPhi + k * cos$1(adLambda), v = k * sdLambda * sin$1(adLambda);
|
|
areaRingSum.add(atan2(v, u)), lambda0 = lambda, cosPhi0 = cosPhi, sinPhi0 = sinPhi;
|
|
}
|
|
function spherical(cartesian) {
|
|
return [
|
|
atan2(cartesian[1], cartesian[0]),
|
|
asin(cartesian[2])
|
|
];
|
|
}
|
|
function cartesian(spherical) {
|
|
var lambda = spherical[0], phi = spherical[1], cosPhi = cos$1(phi);
|
|
return [
|
|
cosPhi * cos$1(lambda),
|
|
cosPhi * sin$1(lambda),
|
|
sin$1(phi)
|
|
];
|
|
}
|
|
function cartesianDot(a, b) {
|
|
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
|
|
}
|
|
function cartesianCross(a, b) {
|
|
return [
|
|
a[1] * b[2] - a[2] * b[1],
|
|
a[2] * b[0] - a[0] * b[2],
|
|
a[0] * b[1] - a[1] * b[0]
|
|
];
|
|
}
|
|
function cartesianAddInPlace(a, b) {
|
|
a[0] += b[0], a[1] += b[1], a[2] += b[2];
|
|
}
|
|
function cartesianScale(vector, k) {
|
|
return [
|
|
vector[0] * k,
|
|
vector[1] * k,
|
|
vector[2] * k
|
|
];
|
|
}
|
|
function cartesianNormalizeInPlace(d) {
|
|
var l = sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
|
|
d[0] /= l, d[1] /= l, d[2] /= l;
|
|
}
|
|
var boundsStream = {
|
|
point: boundsPoint,
|
|
lineStart: boundsLineStart,
|
|
lineEnd: boundsLineEnd,
|
|
polygonStart: function() {
|
|
boundsStream.point = boundsRingPoint, boundsStream.lineStart = boundsRingStart, boundsStream.lineEnd = boundsRingEnd, deltaSum = new Adder(), areaStream.polygonStart();
|
|
},
|
|
polygonEnd: function() {
|
|
areaStream.polygonEnd(), boundsStream.point = boundsPoint, boundsStream.lineStart = boundsLineStart, boundsStream.lineEnd = boundsLineEnd, areaRingSum < 0 ? (lambda0$1 = -(lambda1 = 180), phi0 = -(phi1 = 90)) : deltaSum > 1e-6 ? phi1 = 90 : deltaSum < -0.000001 && (phi0 = -90), range$1[0] = lambda0$1, range$1[1] = lambda1;
|
|
},
|
|
sphere: function() {
|
|
lambda0$1 = -(lambda1 = 180), phi0 = -(phi1 = 90);
|
|
}
|
|
};
|
|
function boundsPoint(lambda, phi) {
|
|
ranges.push(range$1 = [
|
|
lambda0$1 = lambda,
|
|
lambda1 = lambda
|
|
]), phi < phi0 && (phi0 = phi), phi > phi1 && (phi1 = phi);
|
|
}
|
|
function linePoint(lambda, phi) {
|
|
var p = cartesian([
|
|
lambda * radians$1,
|
|
phi * radians$1
|
|
]);
|
|
if (p0) {
|
|
var normal = cartesianCross(p0, p), inflection = cartesianCross([
|
|
normal[1],
|
|
-normal[0],
|
|
0
|
|
], normal);
|
|
cartesianNormalizeInPlace(inflection);
|
|
var phii, delta = lambda - lambda2, sign = delta > 0 ? 1 : -1, lambdai = (inflection = spherical(inflection))[0] * degrees$2 * sign, antimeridian = abs$2(delta) > 180;
|
|
antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda) ? (phii = inflection[1] * degrees$2) > phi1 && (phi1 = phii) : antimeridian ^ (sign * lambda2 < (lambdai = (lambdai + 360) % 360 - 180) && lambdai < sign * lambda) ? (phii = -inflection[1] * degrees$2) < phi0 && (phi0 = phii) : (phi < phi0 && (phi0 = phi), phi > phi1 && (phi1 = phi)), antimeridian ? lambda < lambda2 ? angle(lambda0$1, lambda) > angle(lambda0$1, lambda1) && (lambda1 = lambda) : angle(lambda, lambda1) > angle(lambda0$1, lambda1) && (lambda0$1 = lambda) : lambda1 >= lambda0$1 ? (lambda < lambda0$1 && (lambda0$1 = lambda), lambda > lambda1 && (lambda1 = lambda)) : lambda > lambda2 ? angle(lambda0$1, lambda) > angle(lambda0$1, lambda1) && (lambda1 = lambda) : angle(lambda, lambda1) > angle(lambda0$1, lambda1) && (lambda0$1 = lambda);
|
|
} else ranges.push(range$1 = [
|
|
lambda0$1 = lambda,
|
|
lambda1 = lambda
|
|
]);
|
|
phi < phi0 && (phi0 = phi), phi > phi1 && (phi1 = phi), p0 = p, lambda2 = lambda;
|
|
}
|
|
function boundsLineStart() {
|
|
boundsStream.point = linePoint;
|
|
}
|
|
function boundsLineEnd() {
|
|
range$1[0] = lambda0$1, range$1[1] = lambda1, boundsStream.point = boundsPoint, p0 = null;
|
|
}
|
|
function boundsRingPoint(lambda, phi) {
|
|
if (p0) {
|
|
var delta = lambda - lambda2;
|
|
deltaSum.add(abs$2(delta) > 180 ? delta + (delta > 0 ? 360 : -360) : delta);
|
|
} else lambda00$1 = lambda, phi00$1 = phi;
|
|
areaStream.point(lambda, phi), linePoint(lambda, phi);
|
|
}
|
|
function boundsRingStart() {
|
|
areaStream.lineStart();
|
|
}
|
|
function boundsRingEnd() {
|
|
boundsRingPoint(lambda00$1, phi00$1), areaStream.lineEnd(), abs$2(deltaSum) > 1e-6 && (lambda0$1 = -(lambda1 = 180)), range$1[0] = lambda0$1, range$1[1] = lambda1, p0 = null;
|
|
}
|
|
function angle(lambda0, lambda1) {
|
|
return (lambda1 -= lambda0) < 0 ? lambda1 + 360 : lambda1;
|
|
}
|
|
function rangeCompare(a, b) {
|
|
return a[0] - b[0];
|
|
}
|
|
function rangeContains(range, x) {
|
|
return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;
|
|
}
|
|
var centroidStream = {
|
|
sphere: noop$2,
|
|
point: centroidPoint,
|
|
lineStart: centroidLineStart,
|
|
lineEnd: centroidLineEnd,
|
|
polygonStart: function() {
|
|
centroidStream.lineStart = centroidRingStart, centroidStream.lineEnd = centroidRingEnd;
|
|
},
|
|
polygonEnd: function() {
|
|
centroidStream.lineStart = centroidLineStart, centroidStream.lineEnd = centroidLineEnd;
|
|
}
|
|
};
|
|
function centroidPoint(lambda, phi) {
|
|
lambda *= radians$1;
|
|
var cosPhi = cos$1(phi *= radians$1);
|
|
centroidPointCartesian(cosPhi * cos$1(lambda), cosPhi * sin$1(lambda), sin$1(phi));
|
|
}
|
|
function centroidPointCartesian(x, y, z) {
|
|
++W0, X0 += (x - X0) / W0, Y0 += (y - Y0) / W0, Z0 += (z - Z0) / W0;
|
|
}
|
|
function centroidLineStart() {
|
|
centroidStream.point = centroidLinePointFirst;
|
|
}
|
|
function centroidLinePointFirst(lambda, phi) {
|
|
lambda *= radians$1;
|
|
var cosPhi = cos$1(phi *= radians$1);
|
|
x0 = cosPhi * cos$1(lambda), y0 = cosPhi * sin$1(lambda), z0 = sin$1(phi), centroidStream.point = centroidLinePoint, centroidPointCartesian(x0, y0, z0);
|
|
}
|
|
function centroidLinePoint(lambda, phi) {
|
|
lambda *= radians$1;
|
|
var cosPhi = cos$1(phi *= radians$1), x = cosPhi * cos$1(lambda), y = cosPhi * sin$1(lambda), z = sin$1(phi), w = atan2(sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);
|
|
W1 += w, X1 += w * (x0 + (x0 = x)), Y1 += w * (y0 + (y0 = y)), Z1 += w * (z0 + (z0 = z)), centroidPointCartesian(x0, y0, z0);
|
|
}
|
|
function centroidLineEnd() {
|
|
centroidStream.point = centroidPoint;
|
|
}
|
|
function centroidRingStart() {
|
|
centroidStream.point = centroidRingPointFirst;
|
|
}
|
|
function centroidRingEnd() {
|
|
centroidRingPoint(lambda00$2, phi00$2), centroidStream.point = centroidPoint;
|
|
}
|
|
function centroidRingPointFirst(lambda, phi) {
|
|
lambda00$2 = lambda, phi00$2 = phi, lambda *= radians$1, phi *= radians$1, centroidStream.point = centroidRingPoint;
|
|
var cosPhi = cos$1(phi);
|
|
x0 = cosPhi * cos$1(lambda), y0 = cosPhi * sin$1(lambda), z0 = sin$1(phi), centroidPointCartesian(x0, y0, z0);
|
|
}
|
|
function centroidRingPoint(lambda, phi) {
|
|
lambda *= radians$1;
|
|
var cosPhi = cos$1(phi *= radians$1), x = cosPhi * cos$1(lambda), y = cosPhi * sin$1(lambda), z = sin$1(phi), cx = y0 * z - z0 * y, cy = z0 * x - x0 * z, cz = x0 * y - y0 * x, m = hypot(cx, cy, cz), w = asin(m), v = m && -w / m;
|
|
X2.add(v * cx), Y2.add(v * cy), Z2.add(v * cz), W1 += w, X1 += w * (x0 + (x0 = x)), Y1 += w * (y0 + (y0 = y)), Z1 += w * (z0 + (z0 = z)), centroidPointCartesian(x0, y0, z0);
|
|
}
|
|
function constant$8(x) {
|
|
return function() {
|
|
return x;
|
|
};
|
|
}
|
|
function compose(a, b) {
|
|
function compose(x, y) {
|
|
return b((x = a(x, y))[0], x[1]);
|
|
}
|
|
return a.invert && b.invert && (compose.invert = function(x, y) {
|
|
return (x = b.invert(x, y)) && a.invert(x[0], x[1]);
|
|
}), compose;
|
|
}
|
|
function rotationIdentity(lambda, phi) {
|
|
return [
|
|
abs$2(lambda) > pi$3 ? lambda + Math.round(-lambda / tau$4) * tau$4 : lambda,
|
|
phi
|
|
];
|
|
}
|
|
function rotateRadians(deltaLambda, deltaPhi, deltaGamma) {
|
|
return (deltaLambda %= tau$4) ? deltaPhi || deltaGamma ? compose(rotationLambda(deltaLambda), rotationPhiGamma(deltaPhi, deltaGamma)) : rotationLambda(deltaLambda) : deltaPhi || deltaGamma ? rotationPhiGamma(deltaPhi, deltaGamma) : rotationIdentity;
|
|
}
|
|
function forwardRotationLambda(deltaLambda) {
|
|
return function(lambda, phi) {
|
|
return [
|
|
(lambda += deltaLambda) > pi$3 ? lambda - tau$4 : lambda < -pi$3 ? lambda + tau$4 : lambda,
|
|
phi
|
|
];
|
|
};
|
|
}
|
|
function rotationLambda(deltaLambda) {
|
|
var rotation = forwardRotationLambda(deltaLambda);
|
|
return rotation.invert = forwardRotationLambda(-deltaLambda), rotation;
|
|
}
|
|
function rotationPhiGamma(deltaPhi, deltaGamma) {
|
|
var cosDeltaPhi = cos$1(deltaPhi), sinDeltaPhi = sin$1(deltaPhi), cosDeltaGamma = cos$1(deltaGamma), sinDeltaGamma = sin$1(deltaGamma);
|
|
function rotation(lambda, phi) {
|
|
var cosPhi = cos$1(phi), x = cos$1(lambda) * cosPhi, y = sin$1(lambda) * cosPhi, z = sin$1(phi), k = z * cosDeltaPhi + x * sinDeltaPhi;
|
|
return [
|
|
atan2(y * cosDeltaGamma - k * sinDeltaGamma, x * cosDeltaPhi - z * sinDeltaPhi),
|
|
asin(k * cosDeltaGamma + y * sinDeltaGamma)
|
|
];
|
|
}
|
|
return rotation.invert = function(lambda, phi) {
|
|
var cosPhi = cos$1(phi), x = cos$1(lambda) * cosPhi, y = sin$1(lambda) * cosPhi, z = sin$1(phi), k = z * cosDeltaGamma - y * sinDeltaGamma;
|
|
return [
|
|
atan2(y * cosDeltaGamma + z * sinDeltaGamma, x * cosDeltaPhi + k * sinDeltaPhi),
|
|
asin(k * cosDeltaPhi - x * sinDeltaPhi)
|
|
];
|
|
}, rotation;
|
|
}
|
|
function rotation(rotate) {
|
|
function forward(coordinates) {
|
|
return coordinates = rotate(coordinates[0] * radians$1, coordinates[1] * radians$1), coordinates[0] *= degrees$2, coordinates[1] *= degrees$2, coordinates;
|
|
}
|
|
return rotate = rotateRadians(rotate[0] * radians$1, rotate[1] * radians$1, rotate.length > 2 ? rotate[2] * radians$1 : 0), forward.invert = function(coordinates) {
|
|
return coordinates = rotate.invert(coordinates[0] * radians$1, coordinates[1] * radians$1), coordinates[0] *= degrees$2, coordinates[1] *= degrees$2, coordinates;
|
|
}, forward;
|
|
}
|
|
function circleStream(stream, radius, delta, direction, t0, t1) {
|
|
if (delta) {
|
|
var cosRadius = cos$1(radius), sinRadius = sin$1(radius), step = direction * delta;
|
|
null == t0 ? (t0 = radius + direction * tau$4, t1 = radius - step / 2) : (t0 = circleRadius(cosRadius, t0), t1 = circleRadius(cosRadius, t1), (direction > 0 ? t0 < t1 : t0 > t1) && (t0 += direction * tau$4));
|
|
for(var point, t = t0; direction > 0 ? t > t1 : t < t1; t -= step)point = spherical([
|
|
cosRadius,
|
|
-sinRadius * cos$1(t),
|
|
-sinRadius * sin$1(t)
|
|
]), stream.point(point[0], point[1]);
|
|
}
|
|
}
|
|
function circleRadius(cosRadius, point) {
|
|
point = cartesian(point), point[0] -= cosRadius, cartesianNormalizeInPlace(point);
|
|
var radius = acos(-point[1]);
|
|
return ((0 > -point[2] ? -radius : radius) + tau$4 - 1e-6) % tau$4;
|
|
}
|
|
function clipBuffer() {
|
|
var line, lines = [];
|
|
return {
|
|
point: function(x, y, m) {
|
|
line.push([
|
|
x,
|
|
y,
|
|
m
|
|
]);
|
|
},
|
|
lineStart: function() {
|
|
lines.push(line = []);
|
|
},
|
|
lineEnd: noop$2,
|
|
rejoin: function() {
|
|
lines.length > 1 && lines.push(lines.pop().concat(lines.shift()));
|
|
},
|
|
result: function() {
|
|
var result = lines;
|
|
return lines = [], line = null, result;
|
|
}
|
|
};
|
|
}
|
|
function pointEqual(a, b) {
|
|
return 1e-6 > abs$2(a[0] - b[0]) && 1e-6 > abs$2(a[1] - b[1]);
|
|
}
|
|
function Intersection(point, points, other, entry) {
|
|
this.x = point, this.z = points, this.o = other, this.e = entry, this.v = !1, this.n = this.p = null;
|
|
}
|
|
function clipRejoin(segments, compareIntersection, startInside, interpolate, stream) {
|
|
var i, n, subject = [], clip = [];
|
|
if (segments.forEach(function(segment) {
|
|
if (!((n = segment.length - 1) <= 0)) {
|
|
var n, x, p0 = segment[0], p1 = segment[n];
|
|
if (pointEqual(p0, p1)) {
|
|
if (!p0[2] && !p1[2]) {
|
|
for(stream.lineStart(), i = 0; i < n; ++i)stream.point((p0 = segment[i])[0], p0[1]);
|
|
stream.lineEnd();
|
|
return;
|
|
}
|
|
p1[0] += 0.000002;
|
|
}
|
|
subject.push(x = new Intersection(p0, segment, null, !0)), clip.push(x.o = new Intersection(p0, null, x, !1)), subject.push(x = new Intersection(p1, segment, null, !1)), clip.push(x.o = new Intersection(p1, null, x, !0));
|
|
}
|
|
}), subject.length) {
|
|
for(clip.sort(compareIntersection), link$1(subject), link$1(clip), i = 0, n = clip.length; i < n; ++i)clip[i].e = startInside = !startInside;
|
|
for(var points, point, start = subject[0];;){
|
|
for(var current = start, isSubject = !0; current.v;)if ((current = current.n) === start) return;
|
|
points = current.z, stream.lineStart();
|
|
do {
|
|
if (current.v = current.o.v = !0, current.e) {
|
|
if (isSubject) for(i = 0, n = points.length; i < n; ++i)stream.point((point = points[i])[0], point[1]);
|
|
else interpolate(current.x, current.n.x, 1, stream);
|
|
current = current.n;
|
|
} else {
|
|
if (isSubject) for(i = (points = current.p.z).length - 1; i >= 0; --i)stream.point((point = points[i])[0], point[1]);
|
|
else interpolate(current.x, current.p.x, -1, stream);
|
|
current = current.p;
|
|
}
|
|
points = (current = current.o).z, isSubject = !isSubject;
|
|
}while (!current.v)
|
|
stream.lineEnd();
|
|
}
|
|
}
|
|
}
|
|
function link$1(array) {
|
|
if (n = array.length) {
|
|
for(var n, b, i = 0, a = array[0]; ++i < n;)a.n = b = array[i], b.p = a, a = b;
|
|
a.n = b = array[0], b.p = a;
|
|
}
|
|
}
|
|
function longitude(point) {
|
|
return abs$2(point[0]) <= pi$3 ? point[0] : sign(point[0]) * ((abs$2(point[0]) + pi$3) % tau$4 - pi$3);
|
|
}
|
|
function polygonContains(polygon, point) {
|
|
var lambda = longitude(point), phi = point[1], sinPhi = sin$1(phi), normal = [
|
|
sin$1(lambda),
|
|
-cos$1(lambda),
|
|
0
|
|
], angle = 0, winding = 0, sum = new Adder();
|
|
1 === sinPhi ? phi = halfPi$2 + 1e-6 : -1 === sinPhi && (phi = -halfPi$2 - 1e-6);
|
|
for(var i = 0, n = polygon.length; i < n; ++i)if (m = (ring = polygon[i]).length) for(var ring, m, point0 = ring[m - 1], lambda0 = longitude(point0), phi0 = point0[1] / 2 + quarterPi, sinPhi0 = sin$1(phi0), cosPhi0 = cos$1(phi0), j = 0; j < m; ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1){
|
|
var point1 = ring[j], lambda1 = longitude(point1), phi1 = point1[1] / 2 + quarterPi, sinPhi1 = sin$1(phi1), cosPhi1 = cos$1(phi1), delta = lambda1 - lambda0, sign = delta >= 0 ? 1 : -1, absDelta = sign * delta, antimeridian = absDelta > pi$3, k = sinPhi0 * sinPhi1;
|
|
if (sum.add(atan2(k * sign * sin$1(absDelta), cosPhi0 * cosPhi1 + k * cos$1(absDelta))), angle += antimeridian ? delta + sign * tau$4 : delta, antimeridian ^ lambda0 >= lambda ^ lambda1 >= lambda) {
|
|
var arc = cartesianCross(cartesian(point0), cartesian(point1));
|
|
cartesianNormalizeInPlace(arc);
|
|
var intersection = cartesianCross(normal, arc);
|
|
cartesianNormalizeInPlace(intersection);
|
|
var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * asin(intersection[2]);
|
|
(phi > phiArc || phi === phiArc && (arc[0] || arc[1])) && (winding += antimeridian ^ delta >= 0 ? 1 : -1);
|
|
}
|
|
}
|
|
return (angle < -0.000001 || angle < 1e-6 && sum < -0.000000000001) ^ 1 & winding;
|
|
}
|
|
function clip(pointVisible, clipLine, interpolate, start) {
|
|
return function(sink) {
|
|
var polygon, segments, ring, line = clipLine(sink), ringBuffer = clipBuffer(), ringSink = clipLine(ringBuffer), polygonStarted = !1, clip = {
|
|
point: point,
|
|
lineStart: lineStart,
|
|
lineEnd: lineEnd,
|
|
polygonStart: function() {
|
|
clip.point = pointRing, clip.lineStart = ringStart, clip.lineEnd = ringEnd, segments = [], polygon = [];
|
|
},
|
|
polygonEnd: function() {
|
|
clip.point = point, clip.lineStart = lineStart, clip.lineEnd = lineEnd, segments = merge(segments);
|
|
var startInside = polygonContains(polygon, start);
|
|
segments.length ? (polygonStarted || (sink.polygonStart(), polygonStarted = !0), clipRejoin(segments, compareIntersection, startInside, interpolate, sink)) : startInside && (polygonStarted || (sink.polygonStart(), polygonStarted = !0), sink.lineStart(), interpolate(null, null, 1, sink), sink.lineEnd()), polygonStarted && (sink.polygonEnd(), polygonStarted = !1), segments = polygon = null;
|
|
},
|
|
sphere: function() {
|
|
sink.polygonStart(), sink.lineStart(), interpolate(null, null, 1, sink), sink.lineEnd(), sink.polygonEnd();
|
|
}
|
|
};
|
|
function point(lambda, phi) {
|
|
pointVisible(lambda, phi) && sink.point(lambda, phi);
|
|
}
|
|
function pointLine(lambda, phi) {
|
|
line.point(lambda, phi);
|
|
}
|
|
function lineStart() {
|
|
clip.point = pointLine, line.lineStart();
|
|
}
|
|
function lineEnd() {
|
|
clip.point = point, line.lineEnd();
|
|
}
|
|
function pointRing(lambda, phi) {
|
|
ring.push([
|
|
lambda,
|
|
phi
|
|
]), ringSink.point(lambda, phi);
|
|
}
|
|
function ringStart() {
|
|
ringSink.lineStart(), ring = [];
|
|
}
|
|
function ringEnd() {
|
|
pointRing(ring[0][0], ring[0][1]), ringSink.lineEnd();
|
|
var i, m, segment, point, clean = ringSink.clean(), ringSegments = ringBuffer.result(), n = ringSegments.length;
|
|
if (ring.pop(), polygon.push(ring), ring = null, n) {
|
|
if (1 & clean) {
|
|
if ((m = (segment = ringSegments[0]).length - 1) > 0) {
|
|
for(polygonStarted || (sink.polygonStart(), polygonStarted = !0), sink.lineStart(), i = 0; i < m; ++i)sink.point((point = segment[i])[0], point[1]);
|
|
sink.lineEnd();
|
|
}
|
|
return;
|
|
}
|
|
n > 1 && 2 & clean && ringSegments.push(ringSegments.pop().concat(ringSegments.shift())), segments.push(ringSegments.filter(validSegment));
|
|
}
|
|
}
|
|
return clip;
|
|
};
|
|
}
|
|
function validSegment(segment) {
|
|
return segment.length > 1;
|
|
}
|
|
function compareIntersection(a, b) {
|
|
return ((a = a.x)[0] < 0 ? a[1] - halfPi$2 - 1e-6 : halfPi$2 - a[1]) - ((b = b.x)[0] < 0 ? b[1] - halfPi$2 - 1e-6 : halfPi$2 - b[1]);
|
|
}
|
|
rotationIdentity.invert = rotationIdentity;
|
|
var clipAntimeridian = clip(function() {
|
|
return !0;
|
|
}, function(stream) {
|
|
var clean, lambda0 = NaN, phi0 = NaN, sign0 = NaN;
|
|
return {
|
|
lineStart: function() {
|
|
stream.lineStart(), clean = 1;
|
|
},
|
|
point: function(lambda1, phi1) {
|
|
var lambda01, phi01, lambda11, phi11, cosPhi0, cosPhi1, sinLambda0Lambda1, sign1 = lambda1 > 0 ? pi$3 : -pi$3, delta = abs$2(lambda1 - lambda0);
|
|
1e-6 > abs$2(delta - pi$3) ? (stream.point(lambda0, phi0 = (phi0 + phi1) / 2 > 0 ? halfPi$2 : -halfPi$2), stream.point(sign0, phi0), stream.lineEnd(), stream.lineStart(), stream.point(sign1, phi0), stream.point(lambda1, phi0), clean = 0) : sign0 !== sign1 && delta >= pi$3 && (1e-6 > abs$2(lambda0 - sign0) && (lambda0 -= 1e-6 * sign0), 1e-6 > abs$2(lambda1 - sign1) && (lambda1 -= 1e-6 * sign1), lambda01 = lambda0, phi01 = phi0, lambda11 = lambda1, phi11 = phi1, sinLambda0Lambda1 = sin$1(lambda01 - lambda11), phi0 = abs$2(sinLambda0Lambda1) > 1e-6 ? atan((sin$1(phi01) * (cosPhi1 = cos$1(phi11)) * sin$1(lambda11) - sin$1(phi11) * (cosPhi0 = cos$1(phi01)) * sin$1(lambda01)) / (cosPhi0 * cosPhi1 * sinLambda0Lambda1)) : (phi01 + phi11) / 2, stream.point(sign0, phi0), stream.lineEnd(), stream.lineStart(), stream.point(sign1, phi0), clean = 0), stream.point(lambda0 = lambda1, phi0 = phi1), sign0 = sign1;
|
|
},
|
|
lineEnd: function() {
|
|
stream.lineEnd(), lambda0 = phi0 = NaN;
|
|
},
|
|
clean: function() {
|
|
return 2 - clean;
|
|
}
|
|
};
|
|
}, function(from, to, direction, stream) {
|
|
var phi;
|
|
if (null == from) phi = direction * halfPi$2, stream.point(-pi$3, phi), stream.point(0, phi), stream.point(pi$3, phi), stream.point(pi$3, 0), stream.point(pi$3, -phi), stream.point(0, -phi), stream.point(-pi$3, -phi), stream.point(-pi$3, 0), stream.point(-pi$3, phi);
|
|
else if (abs$2(from[0] - to[0]) > 1e-6) {
|
|
var lambda = from[0] < to[0] ? pi$3 : -pi$3;
|
|
phi = direction * lambda / 2, stream.point(-lambda, phi), stream.point(0, phi), stream.point(lambda, phi);
|
|
} else stream.point(to[0], to[1]);
|
|
}, [
|
|
-pi$3,
|
|
-halfPi$2
|
|
]);
|
|
function clipCircle(radius) {
|
|
var cr = cos$1(radius), delta = 6 * radians$1, smallRadius = cr > 0, notHemisphere = abs$2(cr) > 1e-6;
|
|
function visible(lambda, phi) {
|
|
return cos$1(lambda) * cos$1(phi) > cr;
|
|
}
|
|
function intersect(a, b, two) {
|
|
var pa = cartesian(a), pb = cartesian(b), n1 = [
|
|
1,
|
|
0,
|
|
0
|
|
], n2 = cartesianCross(pa, pb), n2n2 = cartesianDot(n2, n2), n1n2 = n2[0], determinant = n2n2 - n1n2 * n1n2;
|
|
if (!determinant) return !two && a;
|
|
var n1xn2 = cartesianCross(n1, n2), A = cartesianScale(n1, cr * n2n2 / determinant), B = cartesianScale(n2, -cr * n1n2 / determinant);
|
|
cartesianAddInPlace(A, B);
|
|
var w = cartesianDot(A, n1xn2), uu = cartesianDot(n1xn2, n1xn2), t2 = w * w - uu * (cartesianDot(A, A) - 1);
|
|
if (!(t2 < 0)) {
|
|
var t = sqrt(t2), q = cartesianScale(n1xn2, (-w - t) / uu);
|
|
if (cartesianAddInPlace(q, A), q = spherical(q), !two) return q;
|
|
var z, lambda0 = a[0], lambda1 = b[0], phi0 = a[1], phi1 = b[1];
|
|
lambda1 < lambda0 && (z = lambda0, lambda0 = lambda1, lambda1 = z);
|
|
var delta = lambda1 - lambda0, polar = 1e-6 > abs$2(delta - pi$3);
|
|
if (!polar && phi1 < phi0 && (z = phi0, phi0 = phi1, phi1 = z), polar || delta < 1e-6 ? polar ? phi0 + phi1 > 0 ^ q[1] < (1e-6 > abs$2(q[0] - lambda0) ? phi0 : phi1) : phi0 <= q[1] && q[1] <= phi1 : delta > pi$3 ^ (lambda0 <= q[0] && q[0] <= lambda1)) {
|
|
var q1 = cartesianScale(n1xn2, (-w + t) / uu);
|
|
return cartesianAddInPlace(q1, A), [
|
|
q,
|
|
spherical(q1)
|
|
];
|
|
}
|
|
}
|
|
}
|
|
function code(lambda, phi) {
|
|
var r = smallRadius ? radius : pi$3 - radius, code = 0;
|
|
return lambda < -r ? code |= 1 : lambda > r && (code |= 2), phi < -r ? code |= 4 : phi > r && (code |= 8), code;
|
|
}
|
|
return clip(visible, function(stream) {
|
|
var point0, c0, v0, v00, clean;
|
|
return {
|
|
lineStart: function() {
|
|
v00 = v0 = !1, clean = 1;
|
|
},
|
|
point: function(lambda, phi) {
|
|
var t, point2, point1 = [
|
|
lambda,
|
|
phi
|
|
], v = visible(lambda, phi), c = smallRadius ? v ? 0 : code(lambda, phi) : v ? code(lambda + (lambda < 0 ? pi$3 : -pi$3), phi) : 0;
|
|
!point0 && (v00 = v0 = v) && stream.lineStart(), v !== v0 && (!(point2 = intersect(point0, point1)) || pointEqual(point0, point2) || pointEqual(point1, point2)) && (point1[2] = 1), v !== v0 ? (clean = 0, v ? (stream.lineStart(), point2 = intersect(point1, point0), stream.point(point2[0], point2[1])) : (point2 = intersect(point0, point1), stream.point(point2[0], point2[1], 2), stream.lineEnd()), point0 = point2) : notHemisphere && point0 && smallRadius ^ v && !(c & c0) && (t = intersect(point1, point0, !0)) && (clean = 0, smallRadius ? (stream.lineStart(), stream.point(t[0][0], t[0][1]), stream.point(t[1][0], t[1][1]), stream.lineEnd()) : (stream.point(t[1][0], t[1][1]), stream.lineEnd(), stream.lineStart(), stream.point(t[0][0], t[0][1], 3))), !v || point0 && pointEqual(point0, point1) || stream.point(point1[0], point1[1]), point0 = point1, v0 = v, c0 = c;
|
|
},
|
|
lineEnd: function() {
|
|
v0 && stream.lineEnd(), point0 = null;
|
|
},
|
|
clean: function() {
|
|
return clean | (v00 && v0) << 1;
|
|
}
|
|
};
|
|
}, function(from, to, direction, stream) {
|
|
circleStream(stream, radius, delta, direction, from, to);
|
|
}, smallRadius ? [
|
|
0,
|
|
-radius
|
|
] : [
|
|
-pi$3,
|
|
radius - pi$3
|
|
]);
|
|
}
|
|
function clipRectangle(x0, y0, x1, y1) {
|
|
function visible(x, y) {
|
|
return x0 <= x && x <= x1 && y0 <= y && y <= y1;
|
|
}
|
|
function interpolate(from, to, direction, stream) {
|
|
var a = 0, a1 = 0;
|
|
if (null == from || (a = corner(from, direction)) !== (a1 = corner(to, direction)) || 0 > comparePoint(from, to) ^ direction > 0) do stream.point(0 === a || 3 === a ? x0 : x1, a > 1 ? y1 : y0);
|
|
while ((a = (a + direction + 4) % 4) !== a1)
|
|
else stream.point(to[0], to[1]);
|
|
}
|
|
function corner(p, direction) {
|
|
return 1e-6 > abs$2(p[0] - x0) ? direction > 0 ? 0 : 3 : 1e-6 > abs$2(p[0] - x1) ? direction > 0 ? 2 : 1 : 1e-6 > abs$2(p[1] - y0) ? direction > 0 ? 1 : 0 : direction > 0 ? 3 : 2;
|
|
}
|
|
function compareIntersection(a, b) {
|
|
return comparePoint(a.x, b.x);
|
|
}
|
|
function comparePoint(a, b) {
|
|
var ca = corner(a, 1), cb = corner(b, 1);
|
|
return ca !== cb ? ca - cb : 0 === ca ? b[1] - a[1] : 1 === ca ? a[0] - b[0] : 2 === ca ? a[1] - b[1] : b[0] - a[0];
|
|
}
|
|
return function(stream) {
|
|
var segments, polygon, ring, x__, y__, v__, x_, y_, v_, first, clean, activeStream = stream, bufferStream = clipBuffer(), clipStream = {
|
|
point: point,
|
|
lineStart: function() {
|
|
clipStream.point = linePoint, polygon && polygon.push(ring = []), first = !0, v_ = !1, x_ = y_ = NaN;
|
|
},
|
|
lineEnd: function() {
|
|
segments && (linePoint(x__, y__), v__ && v_ && bufferStream.rejoin(), segments.push(bufferStream.result())), clipStream.point = point, v_ && activeStream.lineEnd();
|
|
},
|
|
polygonStart: function() {
|
|
activeStream = bufferStream, segments = [], polygon = [], clean = !0;
|
|
},
|
|
polygonEnd: function() {
|
|
var startInside = function() {
|
|
for(var winding = 0, i = 0, n = polygon.length; i < n; ++i)for(var a0, a1, ring = polygon[i], j = 1, m = ring.length, point = ring[0], b0 = point[0], b1 = point[1]; j < m; ++j)a0 = b0, a1 = b1, b0 = (point = ring[j])[0], b1 = point[1], a1 <= y1 ? b1 > y1 && (b0 - a0) * (y1 - a1) > (b1 - a1) * (x0 - a0) && ++winding : b1 <= y1 && (b0 - a0) * (y1 - a1) < (b1 - a1) * (x0 - a0) && --winding;
|
|
return winding;
|
|
}(), cleanInside = clean && startInside, visible = (segments = merge(segments)).length;
|
|
(cleanInside || visible) && (stream.polygonStart(), cleanInside && (stream.lineStart(), interpolate(null, null, 1, stream), stream.lineEnd()), visible && clipRejoin(segments, compareIntersection, startInside, interpolate, stream), stream.polygonEnd()), activeStream = stream, segments = polygon = ring = null;
|
|
}
|
|
};
|
|
function point(x, y) {
|
|
visible(x, y) && activeStream.point(x, y);
|
|
}
|
|
function linePoint(x, y) {
|
|
var v = visible(x, y);
|
|
if (polygon && ring.push([
|
|
x,
|
|
y
|
|
]), first) x__ = x, y__ = y, v__ = v, first = !1, v && (activeStream.lineStart(), activeStream.point(x, y));
|
|
else if (v && v_) activeStream.point(x, y);
|
|
else {
|
|
var a = [
|
|
x_ = Math.max(-1000000000, Math.min(1e9, x_)),
|
|
y_ = Math.max(-1000000000, Math.min(1e9, y_))
|
|
], b = [
|
|
x = Math.max(-1000000000, Math.min(1e9, x)),
|
|
y = Math.max(-1000000000, Math.min(1e9, y))
|
|
];
|
|
!function(a, b, x0, y0, x1, y1) {
|
|
var r, ax = a[0], ay = a[1], bx = b[0], by = b[1], t0 = 0, t1 = 1, dx = bx - ax, dy = by - ay;
|
|
if (r = x0 - ax, dx || !(r > 0)) {
|
|
if (r /= dx, dx < 0) {
|
|
if (r < t0) return;
|
|
r < t1 && (t1 = r);
|
|
} else if (dx > 0) {
|
|
if (r > t1) return;
|
|
r > t0 && (t0 = r);
|
|
}
|
|
if (r = x1 - ax, dx || !(r < 0)) {
|
|
if (r /= dx, dx < 0) {
|
|
if (r > t1) return;
|
|
r > t0 && (t0 = r);
|
|
} else if (dx > 0) {
|
|
if (r < t0) return;
|
|
r < t1 && (t1 = r);
|
|
}
|
|
if (r = y0 - ay, dy || !(r > 0)) {
|
|
if (r /= dy, dy < 0) {
|
|
if (r < t0) return;
|
|
r < t1 && (t1 = r);
|
|
} else if (dy > 0) {
|
|
if (r > t1) return;
|
|
r > t0 && (t0 = r);
|
|
}
|
|
if (r = y1 - ay, dy || !(r < 0)) {
|
|
if (r /= dy, dy < 0) {
|
|
if (r > t1) return;
|
|
r > t0 && (t0 = r);
|
|
} else if (dy > 0) {
|
|
if (r < t0) return;
|
|
r < t1 && (t1 = r);
|
|
}
|
|
return t0 > 0 && (a[0] = ax + t0 * dx, a[1] = ay + t0 * dy), t1 < 1 && (b[0] = ax + t1 * dx, b[1] = ay + t1 * dy), !0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}(a, b, x0, y0, x1, y1) ? v && (activeStream.lineStart(), activeStream.point(x, y), clean = !1) : (v_ || (activeStream.lineStart(), activeStream.point(a[0], a[1])), activeStream.point(b[0], b[1]), v || activeStream.lineEnd(), clean = !1);
|
|
}
|
|
x_ = x, y_ = y, v_ = v;
|
|
}
|
|
return clipStream;
|
|
};
|
|
}
|
|
var lengthStream = {
|
|
sphere: noop$2,
|
|
point: noop$2,
|
|
lineStart: function() {
|
|
lengthStream.point = lengthPointFirst, lengthStream.lineEnd = lengthLineEnd;
|
|
},
|
|
lineEnd: noop$2,
|
|
polygonStart: noop$2,
|
|
polygonEnd: noop$2
|
|
};
|
|
function lengthLineEnd() {
|
|
lengthStream.point = lengthStream.lineEnd = noop$2;
|
|
}
|
|
function lengthPointFirst(lambda, phi) {
|
|
lambda *= radians$1, phi *= radians$1, lambda0$2 = lambda, sinPhi0$1 = sin$1(phi), cosPhi0$1 = cos$1(phi), lengthStream.point = lengthPoint;
|
|
}
|
|
function lengthPoint(lambda, phi) {
|
|
lambda *= radians$1;
|
|
var sinPhi = sin$1(phi *= radians$1), cosPhi = cos$1(phi), delta = abs$2(lambda - lambda0$2), cosDelta = cos$1(delta), sinDelta = sin$1(delta), x = cosPhi * sinDelta, y = cosPhi0$1 * sinPhi - sinPhi0$1 * cosPhi * cosDelta, z = sinPhi0$1 * sinPhi + cosPhi0$1 * cosPhi * cosDelta;
|
|
lengthSum.add(atan2(sqrt(x * x + y * y), z)), lambda0$2 = lambda, sinPhi0$1 = sinPhi, cosPhi0$1 = cosPhi;
|
|
}
|
|
function length$2(object) {
|
|
return lengthSum = new Adder(), geoStream(object, lengthStream), +lengthSum;
|
|
}
|
|
var coordinates = [
|
|
null,
|
|
null
|
|
], object$1 = {
|
|
type: "LineString",
|
|
coordinates: coordinates
|
|
};
|
|
function distance(a, b) {
|
|
return coordinates[0] = a, coordinates[1] = b, length$2(object$1);
|
|
}
|
|
var containsObjectType = {
|
|
Feature: function(object, point) {
|
|
return containsGeometry(object.geometry, point);
|
|
},
|
|
FeatureCollection: function(object, point) {
|
|
for(var features = object.features, i = -1, n = features.length; ++i < n;)if (containsGeometry(features[i].geometry, point)) return !0;
|
|
return !1;
|
|
}
|
|
}, containsGeometryType = {
|
|
Sphere: function() {
|
|
return !0;
|
|
},
|
|
Point: function(object, point) {
|
|
return containsPoint(object.coordinates, point);
|
|
},
|
|
MultiPoint: function(object, point) {
|
|
for(var coordinates = object.coordinates, i = -1, n = coordinates.length; ++i < n;)if (containsPoint(coordinates[i], point)) return !0;
|
|
return !1;
|
|
},
|
|
LineString: function(object, point) {
|
|
return containsLine(object.coordinates, point);
|
|
},
|
|
MultiLineString: function(object, point) {
|
|
for(var coordinates = object.coordinates, i = -1, n = coordinates.length; ++i < n;)if (containsLine(coordinates[i], point)) return !0;
|
|
return !1;
|
|
},
|
|
Polygon: function(object, point) {
|
|
return containsPolygon(object.coordinates, point);
|
|
},
|
|
MultiPolygon: function(object, point) {
|
|
for(var coordinates = object.coordinates, i = -1, n = coordinates.length; ++i < n;)if (containsPolygon(coordinates[i], point)) return !0;
|
|
return !1;
|
|
},
|
|
GeometryCollection: function(object, point) {
|
|
for(var geometries = object.geometries, i = -1, n = geometries.length; ++i < n;)if (containsGeometry(geometries[i], point)) return !0;
|
|
return !1;
|
|
}
|
|
};
|
|
function containsGeometry(geometry, point) {
|
|
return !!(geometry && containsGeometryType.hasOwnProperty(geometry.type)) && containsGeometryType[geometry.type](geometry, point);
|
|
}
|
|
function containsPoint(coordinates, point) {
|
|
return 0 === distance(coordinates, point);
|
|
}
|
|
function containsLine(coordinates, point) {
|
|
for(var ao, bo, ab, i = 0, n = coordinates.length; i < n; i++){
|
|
if (0 === (bo = distance(coordinates[i], point)) || i > 0 && (ab = distance(coordinates[i], coordinates[i - 1])) > 0 && ao <= ab && bo <= ab && (ao + bo - ab) * (1 - Math.pow((ao - bo) / ab, 2)) < 1e-12 * ab) return !0;
|
|
ao = bo;
|
|
}
|
|
return !1;
|
|
}
|
|
function containsPolygon(coordinates, point) {
|
|
return !!polygonContains(coordinates.map(ringRadians), pointRadians(point));
|
|
}
|
|
function ringRadians(ring) {
|
|
return (ring = ring.map(pointRadians)).pop(), ring;
|
|
}
|
|
function pointRadians(point) {
|
|
return [
|
|
point[0] * radians$1,
|
|
point[1] * radians$1
|
|
];
|
|
}
|
|
function graticuleX(y0, y1, dy) {
|
|
var y = sequence(y0, y1 - 1e-6, dy).concat(y1);
|
|
return function(x) {
|
|
return y.map(function(y) {
|
|
return [
|
|
x,
|
|
y
|
|
];
|
|
});
|
|
};
|
|
}
|
|
function graticuleY(x0, x1, dx) {
|
|
var x = sequence(x0, x1 - 1e-6, dx).concat(x1);
|
|
return function(y) {
|
|
return x.map(function(x) {
|
|
return [
|
|
x,
|
|
y
|
|
];
|
|
});
|
|
};
|
|
}
|
|
function graticule() {
|
|
var x1, x0, X1, X0, y1, y0, Y1, Y0, x, y, X, Y, dx = 10, dy = 10, DX = 90, DY = 360, precision = 2.5;
|
|
function graticule() {
|
|
return {
|
|
type: "MultiLineString",
|
|
coordinates: lines()
|
|
};
|
|
}
|
|
function lines() {
|
|
return sequence(ceil(X0 / DX) * DX, X1, DX).map(X).concat(sequence(ceil(Y0 / DY) * DY, Y1, DY).map(Y)).concat(sequence(ceil(x0 / dx) * dx, x1, dx).filter(function(x) {
|
|
return abs$2(x % DX) > 1e-6;
|
|
}).map(x)).concat(sequence(ceil(y0 / dy) * dy, y1, dy).filter(function(y) {
|
|
return abs$2(y % DY) > 1e-6;
|
|
}).map(y));
|
|
}
|
|
return graticule.lines = function() {
|
|
return lines().map(function(coordinates) {
|
|
return {
|
|
type: "LineString",
|
|
coordinates: coordinates
|
|
};
|
|
});
|
|
}, graticule.outline = function() {
|
|
return {
|
|
type: "Polygon",
|
|
coordinates: [
|
|
X(X0).concat(Y(Y1).slice(1), X(X1).reverse().slice(1), Y(Y0).reverse().slice(1))
|
|
]
|
|
};
|
|
}, graticule.extent = function(_) {
|
|
return arguments.length ? graticule.extentMajor(_).extentMinor(_) : graticule.extentMinor();
|
|
}, graticule.extentMajor = function(_) {
|
|
return arguments.length ? (X0 = +_[0][0], X1 = +_[1][0], Y0 = +_[0][1], Y1 = +_[1][1], X0 > X1 && (_ = X0, X0 = X1, X1 = _), Y0 > Y1 && (_ = Y0, Y0 = Y1, Y1 = _), graticule.precision(precision)) : [
|
|
[
|
|
X0,
|
|
Y0
|
|
],
|
|
[
|
|
X1,
|
|
Y1
|
|
]
|
|
];
|
|
}, graticule.extentMinor = function(_) {
|
|
return arguments.length ? (x0 = +_[0][0], x1 = +_[1][0], y0 = +_[0][1], y1 = +_[1][1], x0 > x1 && (_ = x0, x0 = x1, x1 = _), y0 > y1 && (_ = y0, y0 = y1, y1 = _), graticule.precision(precision)) : [
|
|
[
|
|
x0,
|
|
y0
|
|
],
|
|
[
|
|
x1,
|
|
y1
|
|
]
|
|
];
|
|
}, graticule.step = function(_) {
|
|
return arguments.length ? graticule.stepMajor(_).stepMinor(_) : graticule.stepMinor();
|
|
}, graticule.stepMajor = function(_) {
|
|
return arguments.length ? (DX = +_[0], DY = +_[1], graticule) : [
|
|
DX,
|
|
DY
|
|
];
|
|
}, graticule.stepMinor = function(_) {
|
|
return arguments.length ? (dx = +_[0], dy = +_[1], graticule) : [
|
|
dx,
|
|
dy
|
|
];
|
|
}, graticule.precision = function(_) {
|
|
return arguments.length ? (precision = +_, x = graticuleX(y0, y1, 90), y = graticuleY(x0, x1, precision), X = graticuleX(Y0, Y1, 90), Y = graticuleY(X0, X1, precision), graticule) : precision;
|
|
}, graticule.extentMajor([
|
|
[
|
|
-180,
|
|
-89.999999
|
|
],
|
|
[
|
|
180,
|
|
89.999999
|
|
]
|
|
]).extentMinor([
|
|
[
|
|
-180,
|
|
-80.000001
|
|
],
|
|
[
|
|
180,
|
|
80.000001
|
|
]
|
|
]);
|
|
}
|
|
var lambda0$1, phi0, lambda1, phi1, lambda2, lambda00$1, phi00$1, p0, deltaSum, ranges, range$1, W0, W1, X0, Y0, Z0, X1, Y1, Z1, X2, Y2, Z2, lambda00$2, phi00$2, x0, y0, z0, lengthSum, lambda0$2, sinPhi0$1, cosPhi0$1, x00, y00, x0$1, y0$1, identity$4 = (x)=>x, areaSum$1 = new Adder(), areaRingSum$1 = new Adder(), areaStream$1 = {
|
|
point: noop$2,
|
|
lineStart: noop$2,
|
|
lineEnd: noop$2,
|
|
polygonStart: function() {
|
|
areaStream$1.lineStart = areaRingStart$1, areaStream$1.lineEnd = areaRingEnd$1;
|
|
},
|
|
polygonEnd: function() {
|
|
areaStream$1.lineStart = areaStream$1.lineEnd = areaStream$1.point = noop$2, areaSum$1.add(abs$2(areaRingSum$1)), areaRingSum$1 = new Adder();
|
|
},
|
|
result: function() {
|
|
var area = areaSum$1 / 2;
|
|
return areaSum$1 = new Adder(), area;
|
|
}
|
|
};
|
|
function areaRingStart$1() {
|
|
areaStream$1.point = areaPointFirst$1;
|
|
}
|
|
function areaPointFirst$1(x, y) {
|
|
areaStream$1.point = areaPoint$1, x00 = x0$1 = x, y00 = y0$1 = y;
|
|
}
|
|
function areaPoint$1(x, y) {
|
|
areaRingSum$1.add(y0$1 * x - x0$1 * y), x0$1 = x, y0$1 = y;
|
|
}
|
|
function areaRingEnd$1() {
|
|
areaPoint$1(x00, y00);
|
|
}
|
|
var x00$1, y00$1, x0$3, y0$3, x0$2 = 1 / 0, y0$2 = 1 / 0, x1 = -1 / 0, y1 = x1, boundsStream$1 = {
|
|
point: function(x, y) {
|
|
x < x0$2 && (x0$2 = x), x > x1 && (x1 = x), y < y0$2 && (y0$2 = y), y > y1 && (y1 = y);
|
|
},
|
|
lineStart: noop$2,
|
|
lineEnd: noop$2,
|
|
polygonStart: noop$2,
|
|
polygonEnd: noop$2,
|
|
result: function() {
|
|
var bounds = [
|
|
[
|
|
x0$2,
|
|
y0$2
|
|
],
|
|
[
|
|
x1,
|
|
y1
|
|
]
|
|
];
|
|
return x1 = y1 = -(y0$2 = x0$2 = 1 / 0), bounds;
|
|
}
|
|
}, X0$1 = 0, Y0$1 = 0, Z0$1 = 0, X1$1 = 0, Y1$1 = 0, Z1$1 = 0, X2$1 = 0, Y2$1 = 0, Z2$1 = 0, centroidStream$1 = {
|
|
point: centroidPoint$1,
|
|
lineStart: centroidLineStart$1,
|
|
lineEnd: centroidLineEnd$1,
|
|
polygonStart: function() {
|
|
centroidStream$1.lineStart = centroidRingStart$1, centroidStream$1.lineEnd = centroidRingEnd$1;
|
|
},
|
|
polygonEnd: function() {
|
|
centroidStream$1.point = centroidPoint$1, centroidStream$1.lineStart = centroidLineStart$1, centroidStream$1.lineEnd = centroidLineEnd$1;
|
|
},
|
|
result: function() {
|
|
var centroid = Z2$1 ? [
|
|
X2$1 / Z2$1,
|
|
Y2$1 / Z2$1
|
|
] : Z1$1 ? [
|
|
X1$1 / Z1$1,
|
|
Y1$1 / Z1$1
|
|
] : Z0$1 ? [
|
|
X0$1 / Z0$1,
|
|
Y0$1 / Z0$1
|
|
] : [
|
|
NaN,
|
|
NaN
|
|
];
|
|
return X0$1 = Y0$1 = Z0$1 = X1$1 = Y1$1 = Z1$1 = X2$1 = Y2$1 = Z2$1 = 0, centroid;
|
|
}
|
|
};
|
|
function centroidPoint$1(x, y) {
|
|
X0$1 += x, Y0$1 += y, ++Z0$1;
|
|
}
|
|
function centroidLineStart$1() {
|
|
centroidStream$1.point = centroidPointFirstLine;
|
|
}
|
|
function centroidPointFirstLine(x, y) {
|
|
centroidStream$1.point = centroidPointLine, centroidPoint$1(x0$3 = x, y0$3 = y);
|
|
}
|
|
function centroidPointLine(x, y) {
|
|
var dx = x - x0$3, dy = y - y0$3, z = sqrt(dx * dx + dy * dy);
|
|
X1$1 += z * (x0$3 + x) / 2, Y1$1 += z * (y0$3 + y) / 2, Z1$1 += z, centroidPoint$1(x0$3 = x, y0$3 = y);
|
|
}
|
|
function centroidLineEnd$1() {
|
|
centroidStream$1.point = centroidPoint$1;
|
|
}
|
|
function centroidRingStart$1() {
|
|
centroidStream$1.point = centroidPointFirstRing;
|
|
}
|
|
function centroidRingEnd$1() {
|
|
centroidPointRing(x00$1, y00$1);
|
|
}
|
|
function centroidPointFirstRing(x, y) {
|
|
centroidStream$1.point = centroidPointRing, centroidPoint$1(x00$1 = x0$3 = x, y00$1 = y0$3 = y);
|
|
}
|
|
function centroidPointRing(x, y) {
|
|
var dx = x - x0$3, dy = y - y0$3, z = sqrt(dx * dx + dy * dy);
|
|
X1$1 += z * (x0$3 + x) / 2, Y1$1 += z * (y0$3 + y) / 2, Z1$1 += z, X2$1 += (z = y0$3 * x - x0$3 * y) * (x0$3 + x), Y2$1 += z * (y0$3 + y), Z2$1 += 3 * z, centroidPoint$1(x0$3 = x, y0$3 = y);
|
|
}
|
|
function PathContext(context) {
|
|
this._context = context;
|
|
}
|
|
PathContext.prototype = {
|
|
_radius: 4.5,
|
|
pointRadius: function(_) {
|
|
return this._radius = _, this;
|
|
},
|
|
polygonStart: function() {
|
|
this._line = 0;
|
|
},
|
|
polygonEnd: function() {
|
|
this._line = NaN;
|
|
},
|
|
lineStart: function() {
|
|
this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
0 === this._line && this._context.closePath(), this._point = NaN;
|
|
},
|
|
point: function(x, y) {
|
|
switch(this._point){
|
|
case 0:
|
|
this._context.moveTo(x, y), this._point = 1;
|
|
break;
|
|
case 1:
|
|
this._context.lineTo(x, y);
|
|
break;
|
|
default:
|
|
this._context.moveTo(x + this._radius, y), this._context.arc(x, y, this._radius, 0, tau$4);
|
|
}
|
|
},
|
|
result: noop$2
|
|
};
|
|
var lengthRing, x00$2, y00$2, x0$4, y0$4, lengthSum$1 = new Adder(), lengthStream$1 = {
|
|
point: noop$2,
|
|
lineStart: function() {
|
|
lengthStream$1.point = lengthPointFirst$1;
|
|
},
|
|
lineEnd: function() {
|
|
lengthRing && lengthPoint$1(x00$2, y00$2), lengthStream$1.point = noop$2;
|
|
},
|
|
polygonStart: function() {
|
|
lengthRing = !0;
|
|
},
|
|
polygonEnd: function() {
|
|
lengthRing = null;
|
|
},
|
|
result: function() {
|
|
var length = +lengthSum$1;
|
|
return lengthSum$1 = new Adder(), length;
|
|
}
|
|
};
|
|
function lengthPointFirst$1(x, y) {
|
|
lengthStream$1.point = lengthPoint$1, x00$2 = x0$4 = x, y00$2 = y0$4 = y;
|
|
}
|
|
function lengthPoint$1(x, y) {
|
|
x0$4 -= x, y0$4 -= y, lengthSum$1.add(sqrt(x0$4 * x0$4 + y0$4 * y0$4)), x0$4 = x, y0$4 = y;
|
|
}
|
|
function PathString() {
|
|
this._string = [];
|
|
}
|
|
function circle$1(radius) {
|
|
return "m0," + radius + "a" + radius + "," + radius + " 0 1,1 0," + -2 * radius + "a" + radius + "," + radius + " 0 1,1 0," + 2 * radius + "z";
|
|
}
|
|
function transformer(methods) {
|
|
return function(stream) {
|
|
var s = new TransformStream;
|
|
for(var key in methods)s[key] = methods[key];
|
|
return s.stream = stream, s;
|
|
};
|
|
}
|
|
function TransformStream() {}
|
|
function fit(projection, fitBounds, object) {
|
|
var clip = projection.clipExtent && projection.clipExtent();
|
|
return projection.scale(150).translate([
|
|
0,
|
|
0
|
|
]), null != clip && projection.clipExtent(null), geoStream(object, projection.stream(boundsStream$1)), fitBounds(boundsStream$1.result()), null != clip && projection.clipExtent(clip), projection;
|
|
}
|
|
function fitExtent(projection, extent, object) {
|
|
return fit(projection, function(b) {
|
|
var w = extent[1][0] - extent[0][0], h = extent[1][1] - extent[0][1], k = Math.min(w / (b[1][0] - b[0][0]), h / (b[1][1] - b[0][1])), x = +extent[0][0] + (w - k * (b[1][0] + b[0][0])) / 2, y = +extent[0][1] + (h - k * (b[1][1] + b[0][1])) / 2;
|
|
projection.scale(150 * k).translate([
|
|
x,
|
|
y
|
|
]);
|
|
}, object);
|
|
}
|
|
function fitSize(projection, size, object) {
|
|
return fitExtent(projection, [
|
|
[
|
|
0,
|
|
0
|
|
],
|
|
size
|
|
], object);
|
|
}
|
|
function fitWidth(projection, width, object) {
|
|
return fit(projection, function(b) {
|
|
var w = +width, k = w / (b[1][0] - b[0][0]), x = (w - k * (b[1][0] + b[0][0])) / 2, y = -k * b[0][1];
|
|
projection.scale(150 * k).translate([
|
|
x,
|
|
y
|
|
]);
|
|
}, object);
|
|
}
|
|
function fitHeight(projection, height, object) {
|
|
return fit(projection, function(b) {
|
|
var h = +height, k = h / (b[1][1] - b[0][1]), x = -k * b[0][0], y = (h - k * (b[1][1] + b[0][1])) / 2;
|
|
projection.scale(150 * k).translate([
|
|
x,
|
|
y
|
|
]);
|
|
}, object);
|
|
}
|
|
PathString.prototype = {
|
|
_radius: 4.5,
|
|
_circle: circle$1(4.5),
|
|
pointRadius: function(_) {
|
|
return (_ = +_) !== this._radius && (this._radius = _, this._circle = null), this;
|
|
},
|
|
polygonStart: function() {
|
|
this._line = 0;
|
|
},
|
|
polygonEnd: function() {
|
|
this._line = NaN;
|
|
},
|
|
lineStart: function() {
|
|
this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
0 === this._line && this._string.push("Z"), this._point = NaN;
|
|
},
|
|
point: function(x, y) {
|
|
switch(this._point){
|
|
case 0:
|
|
this._string.push("M", x, ",", y), this._point = 1;
|
|
break;
|
|
case 1:
|
|
this._string.push("L", x, ",", y);
|
|
break;
|
|
default:
|
|
null == this._circle && (this._circle = circle$1(this._radius)), this._string.push("M", x, ",", y, this._circle);
|
|
}
|
|
},
|
|
result: function() {
|
|
if (!this._string.length) return null;
|
|
var result = this._string.join("");
|
|
return this._string = [], result;
|
|
}
|
|
}, TransformStream.prototype = {
|
|
constructor: TransformStream,
|
|
point: function(x, y) {
|
|
this.stream.point(x, y);
|
|
},
|
|
sphere: function() {
|
|
this.stream.sphere();
|
|
},
|
|
lineStart: function() {
|
|
this.stream.lineStart();
|
|
},
|
|
lineEnd: function() {
|
|
this.stream.lineEnd();
|
|
},
|
|
polygonStart: function() {
|
|
this.stream.polygonStart();
|
|
},
|
|
polygonEnd: function() {
|
|
this.stream.polygonEnd();
|
|
}
|
|
};
|
|
var cosMinDistance = cos$1(30 * radians$1);
|
|
function resample(project, delta2) {
|
|
var project1;
|
|
return +delta2 ? function(project, delta2) {
|
|
function resampleLineTo(x0, y0, lambda0, a0, b0, c0, x1, y1, lambda1, a1, b1, c1, depth, stream) {
|
|
var dx = x1 - x0, dy = y1 - y0, d2 = dx * dx + dy * dy;
|
|
if (d2 > 4 * delta2 && depth--) {
|
|
var a = a0 + a1, b = b0 + b1, c = c0 + c1, m = sqrt(a * a + b * b + c * c), phi2 = asin(c /= m), lambda2 = 1e-6 > abs$2(abs$2(c) - 1) || 1e-6 > abs$2(lambda0 - lambda1) ? (lambda0 + lambda1) / 2 : atan2(b, a), p = project(lambda2, phi2), x2 = p[0], y2 = p[1], dx2 = x2 - x0, dy2 = y2 - y0, dz = dy * dx2 - dx * dy2;
|
|
(dz * dz / d2 > delta2 || abs$2((dx * dx2 + dy * dy2) / d2 - 0.5) > 0.3 || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) && (resampleLineTo(x0, y0, lambda0, a0, b0, c0, x2, y2, lambda2, a /= m, b /= m, c, depth, stream), stream.point(x2, y2), resampleLineTo(x2, y2, lambda2, a, b, c, x1, y1, lambda1, a1, b1, c1, depth, stream));
|
|
}
|
|
}
|
|
return function(stream) {
|
|
var lambda00, x00, y00, a00, b00, c00, lambda0, x0, y0, a0, b0, c0, resampleStream = {
|
|
point: point,
|
|
lineStart: lineStart,
|
|
lineEnd: lineEnd,
|
|
polygonStart: function() {
|
|
stream.polygonStart(), resampleStream.lineStart = ringStart;
|
|
},
|
|
polygonEnd: function() {
|
|
stream.polygonEnd(), resampleStream.lineStart = lineStart;
|
|
}
|
|
};
|
|
function point(x, y) {
|
|
x = project(x, y), stream.point(x[0], x[1]);
|
|
}
|
|
function lineStart() {
|
|
x0 = NaN, resampleStream.point = linePoint, stream.lineStart();
|
|
}
|
|
function linePoint(lambda, phi) {
|
|
var c = cartesian([
|
|
lambda,
|
|
phi
|
|
]), p = project(lambda, phi);
|
|
resampleLineTo(x0, y0, lambda0, a0, b0, c0, x0 = p[0], y0 = p[1], lambda0 = lambda, a0 = c[0], b0 = c[1], c0 = c[2], 16, stream), stream.point(x0, y0);
|
|
}
|
|
function lineEnd() {
|
|
resampleStream.point = point, stream.lineEnd();
|
|
}
|
|
function ringStart() {
|
|
lineStart(), resampleStream.point = ringPoint, resampleStream.lineEnd = ringEnd;
|
|
}
|
|
function ringPoint(lambda, phi) {
|
|
linePoint(lambda00 = lambda, phi), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0, resampleStream.point = linePoint;
|
|
}
|
|
function ringEnd() {
|
|
resampleLineTo(x0, y0, lambda0, a0, b0, c0, x00, y00, lambda00, a00, b00, c00, 16, stream), resampleStream.lineEnd = lineEnd, lineEnd();
|
|
}
|
|
return resampleStream;
|
|
};
|
|
}(project, delta2) : (project1 = project, transformer({
|
|
point: function(x, y) {
|
|
x = project1(x, y), this.stream.point(x[0], x[1]);
|
|
}
|
|
}));
|
|
}
|
|
var transformRadians = transformer({
|
|
point: function(x, y) {
|
|
this.stream.point(x * radians$1, y * radians$1);
|
|
}
|
|
});
|
|
function scaleTranslateRotate(k, dx, dy, sx, sy, alpha) {
|
|
if (!alpha) return function(k, dx, dy, sx, sy) {
|
|
function transform(x, y) {
|
|
return [
|
|
dx + k * (x *= sx),
|
|
dy - k * (y *= sy)
|
|
];
|
|
}
|
|
return transform.invert = function(x, y) {
|
|
return [
|
|
(x - dx) / k * sx,
|
|
(dy - y) / k * sy
|
|
];
|
|
}, transform;
|
|
}(k, dx, dy, sx, sy);
|
|
var cosAlpha = cos$1(alpha), sinAlpha = sin$1(alpha), a = cosAlpha * k, b = sinAlpha * k, ai = cosAlpha / k, bi = sinAlpha / k, ci = (sinAlpha * dy - cosAlpha * dx) / k, fi = (sinAlpha * dx + cosAlpha * dy) / k;
|
|
function transform(x, y) {
|
|
return [
|
|
a * (x *= sx) - b * (y *= sy) + dx,
|
|
dy - b * x - a * y
|
|
];
|
|
}
|
|
return transform.invert = function(x, y) {
|
|
return [
|
|
sx * (ai * x - bi * y + ci),
|
|
sy * (fi - bi * x - ai * y)
|
|
];
|
|
}, transform;
|
|
}
|
|
function projection(project) {
|
|
return projectionMutator(function() {
|
|
return project;
|
|
})();
|
|
}
|
|
function projectionMutator(projectAt) {
|
|
var project, rotate, y0, x1, y1, projectResample, projectTransform, projectRotateTransform, cache, cacheStream, k = 150, x = 480, y = 250, lambda = 0, phi = 0, deltaLambda = 0, deltaPhi = 0, deltaGamma = 0, alpha = 0, sx = 1, sy = 1, theta = null, preclip = clipAntimeridian, x0 = null, postclip = identity$4, delta2 = 0.5;
|
|
function projection(point) {
|
|
return projectRotateTransform(point[0] * radians$1, point[1] * radians$1);
|
|
}
|
|
function invert(point) {
|
|
return (point = projectRotateTransform.invert(point[0], point[1])) && [
|
|
point[0] * degrees$2,
|
|
point[1] * degrees$2
|
|
];
|
|
}
|
|
function recenter() {
|
|
var center = scaleTranslateRotate(k, 0, 0, sx, sy, alpha).apply(null, project(lambda, phi)), transform = scaleTranslateRotate(k, x - center[0], y - center[1], sx, sy, alpha);
|
|
return rotate = rotateRadians(deltaLambda, deltaPhi, deltaGamma), projectTransform = compose(project, transform), projectRotateTransform = compose(rotate, projectTransform), projectResample = resample(projectTransform, delta2), reset();
|
|
}
|
|
function reset() {
|
|
return cache = cacheStream = null, projection;
|
|
}
|
|
return projection.stream = function(stream) {
|
|
var rotate1;
|
|
return cache && cacheStream === stream ? cache : cache = transformRadians((rotate1 = rotate, transformer({
|
|
point: function(x, y) {
|
|
var r = rotate1(x, y);
|
|
return this.stream.point(r[0], r[1]);
|
|
}
|
|
}))(preclip(projectResample(postclip(cacheStream = stream)))));
|
|
}, projection.preclip = function(_) {
|
|
return arguments.length ? (preclip = _, theta = void 0, reset()) : preclip;
|
|
}, projection.postclip = function(_) {
|
|
return arguments.length ? (postclip = _, x0 = y0 = x1 = y1 = null, reset()) : postclip;
|
|
}, projection.clipAngle = function(_) {
|
|
return arguments.length ? (preclip = +_ ? clipCircle(theta = _ * radians$1) : (theta = null, clipAntimeridian), reset()) : theta * degrees$2;
|
|
}, projection.clipExtent = function(_) {
|
|
return arguments.length ? (postclip = null == _ ? (x0 = y0 = x1 = y1 = null, identity$4) : clipRectangle(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : null == x0 ? null : [
|
|
[
|
|
x0,
|
|
y0
|
|
],
|
|
[
|
|
x1,
|
|
y1
|
|
]
|
|
];
|
|
}, projection.scale = function(_) {
|
|
return arguments.length ? (k = +_, recenter()) : k;
|
|
}, projection.translate = function(_) {
|
|
return arguments.length ? (x = +_[0], y = +_[1], recenter()) : [
|
|
x,
|
|
y
|
|
];
|
|
}, projection.center = function(_) {
|
|
return arguments.length ? (lambda = _[0] % 360 * radians$1, phi = _[1] % 360 * radians$1, recenter()) : [
|
|
lambda * degrees$2,
|
|
phi * degrees$2
|
|
];
|
|
}, projection.rotate = function(_) {
|
|
return arguments.length ? (deltaLambda = _[0] % 360 * radians$1, deltaPhi = _[1] % 360 * radians$1, deltaGamma = _.length > 2 ? _[2] % 360 * radians$1 : 0, recenter()) : [
|
|
deltaLambda * degrees$2,
|
|
deltaPhi * degrees$2,
|
|
deltaGamma * degrees$2
|
|
];
|
|
}, projection.angle = function(_) {
|
|
return arguments.length ? (alpha = _ % 360 * radians$1, recenter()) : alpha * degrees$2;
|
|
}, projection.reflectX = function(_) {
|
|
return arguments.length ? (sx = _ ? -1 : 1, recenter()) : sx < 0;
|
|
}, projection.reflectY = function(_) {
|
|
return arguments.length ? (sy = _ ? -1 : 1, recenter()) : sy < 0;
|
|
}, projection.precision = function(_) {
|
|
return arguments.length ? (projectResample = resample(projectTransform, delta2 = _ * _), reset()) : sqrt(delta2);
|
|
}, projection.fitExtent = function(extent, object) {
|
|
return fitExtent(projection, extent, object);
|
|
}, projection.fitSize = function(size, object) {
|
|
return fitSize(projection, size, object);
|
|
}, projection.fitWidth = function(width, object) {
|
|
return fitWidth(projection, width, object);
|
|
}, projection.fitHeight = function(height, object) {
|
|
return fitHeight(projection, height, object);
|
|
}, function() {
|
|
return project = projectAt.apply(this, arguments), projection.invert = project.invert && invert, recenter();
|
|
};
|
|
}
|
|
function conicProjection(projectAt) {
|
|
var phi0 = 0, phi1 = pi$3 / 3, m = projectionMutator(projectAt), p = m(phi0, phi1);
|
|
return p.parallels = function(_) {
|
|
return arguments.length ? m(phi0 = _[0] * radians$1, phi1 = _[1] * radians$1) : [
|
|
phi0 * degrees$2,
|
|
phi1 * degrees$2
|
|
];
|
|
}, p;
|
|
}
|
|
function conicEqualAreaRaw(y0, y1) {
|
|
var sy0 = sin$1(y0), n = (sy0 + sin$1(y1)) / 2;
|
|
if (1e-6 > abs$2(n)) return function(phi0) {
|
|
var cosPhi0 = cos$1(phi0);
|
|
function forward(lambda, phi) {
|
|
return [
|
|
lambda * cosPhi0,
|
|
sin$1(phi) / cosPhi0
|
|
];
|
|
}
|
|
return forward.invert = function(x, y) {
|
|
return [
|
|
x / cosPhi0,
|
|
asin(y * cosPhi0)
|
|
];
|
|
}, forward;
|
|
}(y0);
|
|
var c = 1 + sy0 * (2 * n - sy0), r0 = sqrt(c) / n;
|
|
function project(x, y) {
|
|
var r = sqrt(c - 2 * n * sin$1(y)) / n;
|
|
return [
|
|
r * sin$1(x *= n),
|
|
r0 - r * cos$1(x)
|
|
];
|
|
}
|
|
return project.invert = function(x, y) {
|
|
var r0y = r0 - y, l = atan2(x, abs$2(r0y)) * sign(r0y);
|
|
return r0y * n < 0 && (l -= pi$3 * sign(x) * sign(r0y)), [
|
|
l / n,
|
|
asin((c - (x * x + r0y * r0y) * n * n) / (2 * n))
|
|
];
|
|
}, project;
|
|
}
|
|
function conicEqualArea() {
|
|
return conicProjection(conicEqualAreaRaw).scale(155.424).center([
|
|
0,
|
|
33.6442
|
|
]);
|
|
}
|
|
function albers() {
|
|
return conicEqualArea().parallels([
|
|
29.5,
|
|
45.5
|
|
]).scale(1070).translate([
|
|
480,
|
|
250
|
|
]).rotate([
|
|
96,
|
|
0
|
|
]).center([
|
|
-0.6,
|
|
38.7
|
|
]);
|
|
}
|
|
function azimuthalRaw(scale) {
|
|
return function(x, y) {
|
|
var cx = cos$1(x), cy = cos$1(y), k = scale(cx * cy);
|
|
return k === 1 / 0 ? [
|
|
2,
|
|
0
|
|
] : [
|
|
k * cy * sin$1(x),
|
|
k * sin$1(y)
|
|
];
|
|
};
|
|
}
|
|
function azimuthalInvert(angle) {
|
|
return function(x, y) {
|
|
var z = sqrt(x * x + y * y), c = angle(z), sc = sin$1(c), cc = cos$1(c);
|
|
return [
|
|
atan2(x * sc, z * cc),
|
|
asin(z && y * sc / z)
|
|
];
|
|
};
|
|
}
|
|
var azimuthalEqualAreaRaw = azimuthalRaw(function(cxcy) {
|
|
return sqrt(2 / (1 + cxcy));
|
|
});
|
|
azimuthalEqualAreaRaw.invert = azimuthalInvert(function(z) {
|
|
return 2 * asin(z / 2);
|
|
});
|
|
var azimuthalEquidistantRaw = azimuthalRaw(function(c) {
|
|
return (c = acos(c)) && c / sin$1(c);
|
|
});
|
|
function mercatorRaw(lambda, phi) {
|
|
return [
|
|
lambda,
|
|
log(tan((halfPi$2 + phi) / 2))
|
|
];
|
|
}
|
|
function mercatorProjection(project) {
|
|
var y0, x1, y1, m = projection(project), center = m.center, scale = m.scale, translate = m.translate, clipExtent = m.clipExtent, x0 = null;
|
|
function reclip() {
|
|
var k = pi$3 * scale(), t = m(rotation(m.rotate()).invert([
|
|
0,
|
|
0
|
|
]));
|
|
return clipExtent(null == x0 ? [
|
|
[
|
|
t[0] - k,
|
|
t[1] - k
|
|
],
|
|
[
|
|
t[0] + k,
|
|
t[1] + k
|
|
]
|
|
] : project === mercatorRaw ? [
|
|
[
|
|
Math.max(t[0] - k, x0),
|
|
y0
|
|
],
|
|
[
|
|
Math.min(t[0] + k, x1),
|
|
y1
|
|
]
|
|
] : [
|
|
[
|
|
x0,
|
|
Math.max(t[1] - k, y0)
|
|
],
|
|
[
|
|
x1,
|
|
Math.min(t[1] + k, y1)
|
|
]
|
|
]);
|
|
}
|
|
return m.scale = function(_) {
|
|
return arguments.length ? (scale(_), reclip()) : scale();
|
|
}, m.translate = function(_) {
|
|
return arguments.length ? (translate(_), reclip()) : translate();
|
|
}, m.center = function(_) {
|
|
return arguments.length ? (center(_), reclip()) : center();
|
|
}, m.clipExtent = function(_) {
|
|
return arguments.length ? (null == _ ? x0 = y0 = x1 = y1 = null : (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reclip()) : null == x0 ? null : [
|
|
[
|
|
x0,
|
|
y0
|
|
],
|
|
[
|
|
x1,
|
|
y1
|
|
]
|
|
];
|
|
}, reclip();
|
|
}
|
|
function tany(y) {
|
|
return tan((halfPi$2 + y) / 2);
|
|
}
|
|
function conicConformalRaw(y0, y1) {
|
|
var cy0 = cos$1(y0), n = y0 === y1 ? sin$1(y0) : log(cy0 / cos$1(y1)) / log(tany(y1) / tany(y0)), f = cy0 * pow$1(tany(y0), n) / n;
|
|
if (!n) return mercatorRaw;
|
|
function project(x, y) {
|
|
f > 0 ? y < -halfPi$2 + 1e-6 && (y = -halfPi$2 + 1e-6) : y > halfPi$2 - 1e-6 && (y = halfPi$2 - 1e-6);
|
|
var r = f / pow$1(tany(y), n);
|
|
return [
|
|
r * sin$1(n * x),
|
|
f - r * cos$1(n * x)
|
|
];
|
|
}
|
|
return project.invert = function(x, y) {
|
|
var fy = f - y, r = sign(n) * sqrt(x * x + fy * fy), l = atan2(x, abs$2(fy)) * sign(fy);
|
|
return fy * n < 0 && (l -= pi$3 * sign(x) * sign(fy)), [
|
|
l / n,
|
|
2 * atan(pow$1(f / r, 1 / n)) - halfPi$2
|
|
];
|
|
}, project;
|
|
}
|
|
function equirectangularRaw(lambda, phi) {
|
|
return [
|
|
lambda,
|
|
phi
|
|
];
|
|
}
|
|
function conicEquidistantRaw(y0, y1) {
|
|
var cy0 = cos$1(y0), n = y0 === y1 ? sin$1(y0) : (cy0 - cos$1(y1)) / (y1 - y0), g = cy0 / n + y0;
|
|
if (1e-6 > abs$2(n)) return equirectangularRaw;
|
|
function project(x, y) {
|
|
var gy = g - y, nx = n * x;
|
|
return [
|
|
gy * sin$1(nx),
|
|
g - gy * cos$1(nx)
|
|
];
|
|
}
|
|
return project.invert = function(x, y) {
|
|
var gy = g - y, l = atan2(x, abs$2(gy)) * sign(gy);
|
|
return gy * n < 0 && (l -= pi$3 * sign(x) * sign(gy)), [
|
|
l / n,
|
|
g - sign(n) * sqrt(x * x + gy * gy)
|
|
];
|
|
}, project;
|
|
}
|
|
azimuthalEquidistantRaw.invert = azimuthalInvert(function(z) {
|
|
return z;
|
|
}), mercatorRaw.invert = function(x, y) {
|
|
return [
|
|
x,
|
|
2 * atan(exp(y)) - halfPi$2
|
|
];
|
|
}, equirectangularRaw.invert = equirectangularRaw;
|
|
var M = sqrt(3) / 2;
|
|
function equalEarthRaw(lambda, phi) {
|
|
var l = asin(M * sin$1(phi)), l2 = l * l, l6 = l2 * l2 * l2;
|
|
return [
|
|
lambda * cos$1(l) / (M * (1.340264 + -0.24331799999999998 * l2 + l6 * (0.0062510000000000005 + 0.034164 * l2))),
|
|
l * (1.340264 + -0.081106 * l2 + l6 * (0.000893 + 0.003796 * l2))
|
|
];
|
|
}
|
|
function gnomonicRaw(x, y) {
|
|
var cy = cos$1(y), k = cos$1(x) * cy;
|
|
return [
|
|
cy * sin$1(x) / k,
|
|
sin$1(y) / k
|
|
];
|
|
}
|
|
function naturalEarth1Raw(lambda, phi) {
|
|
var phi2 = phi * phi, phi4 = phi2 * phi2;
|
|
return [
|
|
lambda * (0.8707 - 0.131979 * phi2 + phi4 * (-0.013791 + phi4 * (0.003971 * phi2 - 0.001529 * phi4))),
|
|
phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 0.005916 * phi4)))
|
|
];
|
|
}
|
|
function orthographicRaw(x, y) {
|
|
return [
|
|
cos$1(y) * sin$1(x),
|
|
sin$1(y)
|
|
];
|
|
}
|
|
function stereographicRaw(x, y) {
|
|
var cy = cos$1(y), k = 1 + cos$1(x) * cy;
|
|
return [
|
|
cy * sin$1(x) / k,
|
|
sin$1(y) / k
|
|
];
|
|
}
|
|
function transverseMercatorRaw(lambda, phi) {
|
|
return [
|
|
log(tan((halfPi$2 + phi) / 2)),
|
|
-lambda
|
|
];
|
|
}
|
|
function defaultSeparation(a, b) {
|
|
return a.parent === b.parent ? 1 : 2;
|
|
}
|
|
function meanXReduce(x, c) {
|
|
return x + c.x;
|
|
}
|
|
function maxYReduce(y, c) {
|
|
return Math.max(y, c.y);
|
|
}
|
|
function count$1(node) {
|
|
var sum = 0, children = node.children, i = children && children.length;
|
|
if (i) for(; --i >= 0;)sum += children[i].value;
|
|
else sum = 1;
|
|
node.value = sum;
|
|
}
|
|
function hierarchy(data, children) {
|
|
data instanceof Map ? (data = [
|
|
void 0,
|
|
data
|
|
], void 0 === children && (children = mapChildren)) : void 0 === children && (children = objectChildren);
|
|
for(var node, child, childs, i, n, root = new Node(data), nodes = [
|
|
root
|
|
]; node = nodes.pop();)if ((childs = children(node.data)) && (n = (childs = Array.from(childs)).length)) for(node.children = childs, i = n - 1; i >= 0; --i)nodes.push(child = childs[i] = new Node(childs[i])), child.parent = node, child.depth = node.depth + 1;
|
|
return root.eachBefore(computeHeight);
|
|
}
|
|
function objectChildren(d) {
|
|
return d.children;
|
|
}
|
|
function mapChildren(d) {
|
|
return Array.isArray(d) ? d[1] : null;
|
|
}
|
|
function copyData(node) {
|
|
void 0 !== node.data.value && (node.value = node.data.value), node.data = node.data.data;
|
|
}
|
|
function computeHeight(node) {
|
|
var height = 0;
|
|
do node.height = height;
|
|
while ((node = node.parent) && node.height < ++height)
|
|
}
|
|
function Node(data) {
|
|
this.data = data, this.depth = this.height = 0, this.parent = null;
|
|
}
|
|
function enclose(circles) {
|
|
for(var p, e, i = 0, n = (circles = function(array) {
|
|
for(var t, i, m = array.length; m;)i = Math.random() * m-- | 0, t = array[m], array[m] = array[i], array[i] = t;
|
|
return array;
|
|
}(Array.from(circles))).length, B = []; i < n;)p = circles[i], e && enclosesWeak(e, p) ? ++i : (e = function(B) {
|
|
switch(B.length){
|
|
case 1:
|
|
var a;
|
|
return {
|
|
x: (a = B[0]).x,
|
|
y: a.y,
|
|
r: a.r
|
|
};
|
|
case 2:
|
|
return encloseBasis2(B[0], B[1]);
|
|
case 3:
|
|
return encloseBasis3(B[0], B[1], B[2]);
|
|
}
|
|
}(B = function(B, p) {
|
|
var i, j;
|
|
if (enclosesWeakAll(p, B)) return [
|
|
p
|
|
];
|
|
for(i = 0; i < B.length; ++i)if (enclosesNot(p, B[i]) && enclosesWeakAll(encloseBasis2(B[i], p), B)) return [
|
|
B[i],
|
|
p
|
|
];
|
|
for(i = 0; i < B.length - 1; ++i)for(j = i + 1; j < B.length; ++j)if (enclosesNot(encloseBasis2(B[i], B[j]), p) && enclosesNot(encloseBasis2(B[i], p), B[j]) && enclosesNot(encloseBasis2(B[j], p), B[i]) && enclosesWeakAll(encloseBasis3(B[i], B[j], p), B)) return [
|
|
B[i],
|
|
B[j],
|
|
p
|
|
];
|
|
throw Error();
|
|
}(B, p)), i = 0);
|
|
return e;
|
|
}
|
|
function enclosesNot(a, b) {
|
|
var dr = a.r - b.r, dx = b.x - a.x, dy = b.y - a.y;
|
|
return dr < 0 || dr * dr < dx * dx + dy * dy;
|
|
}
|
|
function enclosesWeak(a, b) {
|
|
var dr = a.r - b.r + 1e-9 * Math.max(a.r, b.r, 1), dx = b.x - a.x, dy = b.y - a.y;
|
|
return dr > 0 && dr * dr > dx * dx + dy * dy;
|
|
}
|
|
function enclosesWeakAll(a, B) {
|
|
for(var i = 0; i < B.length; ++i)if (!enclosesWeak(a, B[i])) return !1;
|
|
return !0;
|
|
}
|
|
function encloseBasis2(a, b) {
|
|
var x1 = a.x, y1 = a.y, r1 = a.r, x2 = b.x, y2 = b.y, r2 = b.r, x21 = x2 - x1, y21 = y2 - y1, r21 = r2 - r1, l = Math.sqrt(x21 * x21 + y21 * y21);
|
|
return {
|
|
x: (x1 + x2 + x21 / l * r21) / 2,
|
|
y: (y1 + y2 + y21 / l * r21) / 2,
|
|
r: (l + r1 + r2) / 2
|
|
};
|
|
}
|
|
function encloseBasis3(a, b, c) {
|
|
var x1 = a.x, y1 = a.y, r1 = a.r, x2 = b.x, y2 = b.y, r2 = b.r, x3 = c.x, y3 = c.y, r3 = c.r, a2 = x1 - x2, a3 = x1 - x3, b2 = y1 - y2, b3 = y1 - y3, c2 = r2 - r1, c3 = r3 - r1, d1 = x1 * x1 + y1 * y1 - r1 * r1, d2 = d1 - x2 * x2 - y2 * y2 + r2 * r2, d3 = d1 - x3 * x3 - y3 * y3 + r3 * r3, ab = a3 * b2 - a2 * b3, xa = (b2 * d3 - b3 * d2) / (2 * ab) - x1, xb = (b3 * c2 - b2 * c3) / ab, ya = (a3 * d2 - a2 * d3) / (2 * ab) - y1, yb = (a2 * c3 - a3 * c2) / ab, A = xb * xb + yb * yb - 1, B = 2 * (r1 + xa * xb + ya * yb), C = xa * xa + ya * ya - r1 * r1, r = -(A ? (B + Math.sqrt(B * B - 4 * A * C)) / (2 * A) : C / B);
|
|
return {
|
|
x: x1 + xa + xb * r,
|
|
y: y1 + ya + yb * r,
|
|
r: r
|
|
};
|
|
}
|
|
function place(b, a, c) {
|
|
var x, a2, y, b2, dx = b.x - a.x, dy = b.y - a.y, d2 = dx * dx + dy * dy;
|
|
d2 ? (a2 = a.r + c.r, a2 *= a2, b2 = b.r + c.r, a2 > (b2 *= b2) ? (x = (d2 + b2 - a2) / (2 * d2), y = Math.sqrt(Math.max(0, b2 / d2 - x * x)), c.x = b.x - x * dx - y * dy, c.y = b.y - x * dy + y * dx) : (x = (d2 + a2 - b2) / (2 * d2), y = Math.sqrt(Math.max(0, a2 / d2 - x * x)), c.x = a.x + x * dx - y * dy, c.y = a.y + x * dy + y * dx)) : (c.x = a.x + c.r, c.y = a.y);
|
|
}
|
|
function intersects(a, b) {
|
|
var dr = a.r + b.r - 1e-6, dx = b.x - a.x, dy = b.y - a.y;
|
|
return dr > 0 && dr * dr > dx * dx + dy * dy;
|
|
}
|
|
function score(node) {
|
|
var a = node._, b = node.next._, ab = a.r + b.r, dx = (a.x * b.r + b.x * a.r) / ab, dy = (a.y * b.r + b.y * a.r) / ab;
|
|
return dx * dx + dy * dy;
|
|
}
|
|
function Node$1(circle) {
|
|
this._ = circle, this.next = null, this.previous = null;
|
|
}
|
|
function packEnclose(circles) {
|
|
var a, b, c, n, aa, ca, i, j, k, sj, sk, x;
|
|
if (!(n = (circles = "object" == typeof (x = circles) && "length" in x ? x : Array.from(x)).length)) return 0;
|
|
if ((a = circles[0]).x = 0, a.y = 0, !(n > 1)) return a.r;
|
|
if (b = circles[1], a.x = -b.r, b.x = a.r, b.y = 0, !(n > 2)) return a.r + b.r;
|
|
place(b, a, c = circles[2]), a = new Node$1(a), b = new Node$1(b), c = new Node$1(c), a.next = c.previous = b, b.next = a.previous = c, c.next = b.previous = a;
|
|
pack: for(i = 3; i < n; ++i){
|
|
place(a._, b._, c = circles[i]), c = new Node$1(c), j = b.next, k = a.previous, sj = b._.r, sk = a._.r;
|
|
do if (sj <= sk) {
|
|
if (intersects(j._, c._)) {
|
|
b = j, a.next = b, b.previous = a, --i;
|
|
continue pack;
|
|
}
|
|
sj += j._.r, j = j.next;
|
|
} else {
|
|
if (intersects(k._, c._)) {
|
|
(a = k).next = b, b.previous = a, --i;
|
|
continue pack;
|
|
}
|
|
sk += k._.r, k = k.previous;
|
|
}
|
|
while (j !== k.next)
|
|
for(c.previous = a, c.next = b, a.next = b.previous = b = c, aa = score(a); (c = c.next) !== b;)(ca = score(c)) < aa && (a = c, aa = ca);
|
|
b = a.next;
|
|
}
|
|
for(a = [
|
|
b._
|
|
], c = b; (c = c.next) !== b;)a.push(c._);
|
|
for(i = 0, c = enclose(a); i < n; ++i)a = circles[i], a.x -= c.x, a.y -= c.y;
|
|
return c.r;
|
|
}
|
|
function required(f) {
|
|
if ("function" != typeof f) throw Error();
|
|
return f;
|
|
}
|
|
function constantZero() {
|
|
return 0;
|
|
}
|
|
function constant$9(x) {
|
|
return function() {
|
|
return x;
|
|
};
|
|
}
|
|
function defaultRadius$1(d) {
|
|
return Math.sqrt(d.value);
|
|
}
|
|
function radiusLeaf(radius) {
|
|
return function(node) {
|
|
node.children || (node.r = Math.max(0, +radius(node) || 0));
|
|
};
|
|
}
|
|
function packChildren(padding, k) {
|
|
return function(node) {
|
|
if (children = node.children) {
|
|
var children, i, e, n = children.length, r = padding(node) * k || 0;
|
|
if (r) for(i = 0; i < n; ++i)children[i].r += r;
|
|
if (e = packEnclose(children), r) for(i = 0; i < n; ++i)children[i].r -= r;
|
|
node.r = e + r;
|
|
}
|
|
};
|
|
}
|
|
function translateChild(k) {
|
|
return function(node) {
|
|
var parent = node.parent;
|
|
node.r *= k, parent && (node.x = parent.x + k * node.x, node.y = parent.y + k * node.y);
|
|
};
|
|
}
|
|
function roundNode(node) {
|
|
node.x0 = Math.round(node.x0), node.y0 = Math.round(node.y0), node.x1 = Math.round(node.x1), node.y1 = Math.round(node.y1);
|
|
}
|
|
function treemapDice(parent, x0, y0, x1, y1) {
|
|
for(var node, nodes = parent.children, i = -1, n = nodes.length, k = parent.value && (x1 - x0) / parent.value; ++i < n;)(node = nodes[i]).y0 = y0, node.y1 = y1, node.x0 = x0, node.x1 = x0 += node.value * k;
|
|
}
|
|
equalEarthRaw.invert = function(x, y) {
|
|
for(var delta, fy, fpy, l = y, l2 = l * l, l6 = l2 * l2 * l2, i = 0; i < 12 && (fy = l * (1.340264 + -0.081106 * l2 + l6 * (0.000893 + 0.003796 * l2)) - y, l -= delta = fy / (1.340264 + -0.24331799999999998 * l2 + l6 * (0.0062510000000000005 + 0.034164 * l2)), l6 = (l2 = l * l) * l2 * l2, !(1e-12 > abs$2(delta))); ++i);
|
|
return [
|
|
M * x * (1.340264 + -0.24331799999999998 * l2 + l6 * (0.0062510000000000005 + 0.034164 * l2)) / cos$1(l),
|
|
asin(sin$1(l) / M)
|
|
];
|
|
}, gnomonicRaw.invert = azimuthalInvert(atan), naturalEarth1Raw.invert = function(x, y) {
|
|
var delta, phi = y, i = 25;
|
|
do {
|
|
var phi2 = phi * phi, phi4 = phi2 * phi2;
|
|
phi -= delta = (phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 0.005916 * phi4))) - y) / (1.007226 + phi2 * (0.045255 + phi4 * (-0.311325 + 0.259866 * phi2 - 0.005916 * 11 * phi4)));
|
|
}while (abs$2(delta) > 1e-6 && --i > 0)
|
|
return [
|
|
x / (0.8707 + (phi2 = phi * phi) * (-0.131979 + phi2 * (-0.013791 + phi2 * phi2 * phi2 * (0.003971 - 0.001529 * phi2)))),
|
|
phi
|
|
];
|
|
}, orthographicRaw.invert = azimuthalInvert(asin), stereographicRaw.invert = azimuthalInvert(function(z) {
|
|
return 2 * atan(z);
|
|
}), transverseMercatorRaw.invert = function(x, y) {
|
|
return [
|
|
-y,
|
|
2 * atan(exp(x)) - halfPi$2
|
|
];
|
|
}, Node.prototype = hierarchy.prototype = {
|
|
constructor: Node,
|
|
count: function() {
|
|
return this.eachAfter(count$1);
|
|
},
|
|
each: function(callback, that) {
|
|
let index = -1;
|
|
for (const node of this)callback.call(that, node, ++index, this);
|
|
return this;
|
|
},
|
|
eachAfter: function(callback, that) {
|
|
for(var children, i, n, node = this, nodes = [
|
|
node
|
|
], next = [], index = -1; node = nodes.pop();)if (next.push(node), children = node.children) for(i = 0, n = children.length; i < n; ++i)nodes.push(children[i]);
|
|
for(; node = next.pop();)callback.call(that, node, ++index, this);
|
|
return this;
|
|
},
|
|
eachBefore: function(callback, that) {
|
|
for(var children, i, node = this, nodes = [
|
|
node
|
|
], index = -1; node = nodes.pop();)if (callback.call(that, node, ++index, this), children = node.children) for(i = children.length - 1; i >= 0; --i)nodes.push(children[i]);
|
|
return this;
|
|
},
|
|
find: function(callback, that) {
|
|
let index = -1;
|
|
for (const node of this)if (callback.call(that, node, ++index, this)) return node;
|
|
},
|
|
sum: function(value) {
|
|
return this.eachAfter(function(node) {
|
|
for(var sum = +value(node.data) || 0, children = node.children, i = children && children.length; --i >= 0;)sum += children[i].value;
|
|
node.value = sum;
|
|
});
|
|
},
|
|
sort: function(compare) {
|
|
return this.eachBefore(function(node) {
|
|
node.children && node.children.sort(compare);
|
|
});
|
|
},
|
|
path: function(end) {
|
|
for(var start = this, ancestor = function(a, b) {
|
|
if (a === b) return a;
|
|
var aNodes = a.ancestors(), bNodes = b.ancestors(), c = null;
|
|
for(a = aNodes.pop(), b = bNodes.pop(); a === b;)c = a, a = aNodes.pop(), b = bNodes.pop();
|
|
return c;
|
|
}(start, end), nodes = [
|
|
start
|
|
]; start !== ancestor;)start = start.parent, nodes.push(start);
|
|
for(var k = nodes.length; end !== ancestor;)nodes.splice(k, 0, end), end = end.parent;
|
|
return nodes;
|
|
},
|
|
ancestors: function() {
|
|
for(var node = this, nodes = [
|
|
node
|
|
]; node = node.parent;)nodes.push(node);
|
|
return nodes;
|
|
},
|
|
descendants: function() {
|
|
return Array.from(this);
|
|
},
|
|
leaves: function() {
|
|
var leaves = [];
|
|
return this.eachBefore(function(node) {
|
|
node.children || leaves.push(node);
|
|
}), leaves;
|
|
},
|
|
links: function() {
|
|
var root = this, links = [];
|
|
return root.each(function(node) {
|
|
node !== root && links.push({
|
|
source: node.parent,
|
|
target: node
|
|
});
|
|
}), links;
|
|
},
|
|
copy: function() {
|
|
return hierarchy(this).eachBefore(copyData);
|
|
},
|
|
[Symbol.iterator]: function*() {
|
|
var current, children, i, n, node = this, next = [
|
|
node
|
|
];
|
|
do for(current = next.reverse(), next = []; node = current.pop();)if (yield node, children = node.children) for(i = 0, n = children.length; i < n; ++i)next.push(children[i]);
|
|
while (next.length)
|
|
}
|
|
};
|
|
var preroot = {
|
|
depth: -1
|
|
}, ambiguous = {};
|
|
function defaultId(d) {
|
|
return d.id;
|
|
}
|
|
function defaultParentId(d) {
|
|
return d.parentId;
|
|
}
|
|
function defaultSeparation$1(a, b) {
|
|
return a.parent === b.parent ? 1 : 2;
|
|
}
|
|
function nextLeft(v) {
|
|
var children = v.children;
|
|
return children ? children[0] : v.t;
|
|
}
|
|
function nextRight(v) {
|
|
var children = v.children;
|
|
return children ? children[children.length - 1] : v.t;
|
|
}
|
|
function TreeNode(node, i) {
|
|
this._ = node, this.parent = null, this.children = null, this.A = null, this.a = this, this.z = 0, this.m = 0, this.c = 0, this.s = 0, this.t = null, this.i = i;
|
|
}
|
|
function treemapSlice(parent, x0, y0, x1, y1) {
|
|
for(var node, nodes = parent.children, i = -1, n = nodes.length, k = parent.value && (y1 - y0) / parent.value; ++i < n;)(node = nodes[i]).x0 = x0, node.x1 = x1, node.y0 = y0, node.y1 = y0 += node.value * k;
|
|
}
|
|
TreeNode.prototype = Object.create(Node.prototype);
|
|
var phi = (1 + Math.sqrt(5)) / 2;
|
|
function squarifyRatio(ratio, parent, x0, y0, x1, y1) {
|
|
for(var row, nodeValue, dx, dy, sumValue, minValue, maxValue, newRatio, minRatio, alpha, beta, rows = [], nodes = parent.children, i0 = 0, i1 = 0, n = nodes.length, value = parent.value; i0 < n;){
|
|
dx = x1 - x0, dy = y1 - y0;
|
|
do sumValue = nodes[i1++].value;
|
|
while (!sumValue && i1 < n)
|
|
for(minValue = maxValue = sumValue, minRatio = Math.max(maxValue / (beta = sumValue * sumValue * (alpha = Math.max(dy / dx, dx / dy) / (value * ratio))), beta / minValue); i1 < n; ++i1){
|
|
if (sumValue += nodeValue = nodes[i1].value, nodeValue < minValue && (minValue = nodeValue), nodeValue > maxValue && (maxValue = nodeValue), (newRatio = Math.max(maxValue / (beta = sumValue * sumValue * alpha), beta / minValue)) > minRatio) {
|
|
sumValue -= nodeValue;
|
|
break;
|
|
}
|
|
minRatio = newRatio;
|
|
}
|
|
rows.push(row = {
|
|
value: sumValue,
|
|
dice: dx < dy,
|
|
children: nodes.slice(i0, i1)
|
|
}), row.dice ? treemapDice(row, x0, y0, x1, value ? y0 += dy * sumValue / value : y1) : treemapSlice(row, x0, y0, value ? x0 += dx * sumValue / value : x1, y1), value -= sumValue, i0 = i1;
|
|
}
|
|
return rows;
|
|
}
|
|
var squarify = function custom(ratio) {
|
|
function squarify(parent, x0, y0, x1, y1) {
|
|
squarifyRatio(ratio, parent, x0, y0, x1, y1);
|
|
}
|
|
return squarify.ratio = function(x) {
|
|
return custom((x = +x) > 1 ? x : 1);
|
|
}, squarify;
|
|
}(phi), resquarify = function custom(ratio) {
|
|
function resquarify(parent, x0, y0, x1, y1) {
|
|
if ((rows = parent._squarify) && rows.ratio === ratio) for(var rows, row, nodes, i, n, j = -1, m = rows.length, value = parent.value; ++j < m;){
|
|
for(nodes = (row = rows[j]).children, i = row.value = 0, n = nodes.length; i < n; ++i)row.value += nodes[i].value;
|
|
row.dice ? treemapDice(row, x0, y0, x1, value ? y0 += (y1 - y0) * row.value / value : y1) : treemapSlice(row, x0, y0, value ? x0 += (x1 - x0) * row.value / value : x1, y1), value -= row.value;
|
|
}
|
|
else parent._squarify = rows = squarifyRatio(ratio, parent, x0, y0, x1, y1), rows.ratio = ratio;
|
|
}
|
|
return resquarify.ratio = function(x) {
|
|
return custom((x = +x) > 1 ? x : 1);
|
|
}, resquarify;
|
|
}(phi);
|
|
function lexicographicOrder(a, b) {
|
|
return a[0] - b[0] || a[1] - b[1];
|
|
}
|
|
function computeUpperHullIndexes(points) {
|
|
const n = points.length, indexes = [
|
|
0,
|
|
1
|
|
];
|
|
let size = 2, i;
|
|
for(i = 2; i < n; ++i){
|
|
for(var a, b, c; size > 1 && 0 >= (a = points[indexes[size - 2]], b = points[indexes[size - 1]], c = points[i], (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]));)--size;
|
|
indexes[size++] = i;
|
|
}
|
|
return indexes.slice(0, size);
|
|
}
|
|
var defaultSource$1 = Math.random, uniform = function sourceRandomUniform(source) {
|
|
function randomUniform(min, max) {
|
|
return min = null == min ? 0 : +min, max = null == max ? 1 : +max, 1 === arguments.length ? (max = min, min = 0) : max -= min, function() {
|
|
return source() * max + min;
|
|
};
|
|
}
|
|
return randomUniform.source = sourceRandomUniform, randomUniform;
|
|
}(defaultSource$1), int = function sourceRandomInt(source) {
|
|
function randomInt(min, max) {
|
|
return arguments.length < 2 && (max = min, min = 0), min = Math.floor(min), max = Math.floor(max) - min, function() {
|
|
return Math.floor(source() * max + min);
|
|
};
|
|
}
|
|
return randomInt.source = sourceRandomInt, randomInt;
|
|
}(defaultSource$1), normal = function sourceRandomNormal(source) {
|
|
function randomNormal(mu, sigma) {
|
|
var x, r;
|
|
return mu = null == mu ? 0 : +mu, sigma = null == sigma ? 1 : +sigma, function() {
|
|
var y;
|
|
if (null != x) y = x, x = null;
|
|
else do x = 2 * source() - 1, y = 2 * source() - 1, r = x * x + y * y;
|
|
while (!r || r > 1)
|
|
return mu + sigma * y * Math.sqrt(-2 * Math.log(r) / r);
|
|
};
|
|
}
|
|
return randomNormal.source = sourceRandomNormal, randomNormal;
|
|
}(defaultSource$1), logNormal = function sourceRandomLogNormal(source) {
|
|
var N = normal.source(source);
|
|
function randomLogNormal() {
|
|
var randomNormal = N.apply(this, arguments);
|
|
return function() {
|
|
return Math.exp(randomNormal());
|
|
};
|
|
}
|
|
return randomLogNormal.source = sourceRandomLogNormal, randomLogNormal;
|
|
}(defaultSource$1), irwinHall = function sourceRandomIrwinHall(source) {
|
|
function randomIrwinHall(n) {
|
|
return (n = +n) <= 0 ? ()=>0 : function() {
|
|
for(var sum = 0, i = n; i > 1; --i)sum += source();
|
|
return sum + i * source();
|
|
};
|
|
}
|
|
return randomIrwinHall.source = sourceRandomIrwinHall, randomIrwinHall;
|
|
}(defaultSource$1), bates = function sourceRandomBates(source) {
|
|
var I = irwinHall.source(source);
|
|
function randomBates(n) {
|
|
if (0 == (n = +n)) return source;
|
|
var randomIrwinHall = I(n);
|
|
return function() {
|
|
return randomIrwinHall() / n;
|
|
};
|
|
}
|
|
return randomBates.source = sourceRandomBates, randomBates;
|
|
}(defaultSource$1), exponential$1 = function sourceRandomExponential(source) {
|
|
function randomExponential(lambda) {
|
|
return function() {
|
|
return -Math.log1p(-source()) / lambda;
|
|
};
|
|
}
|
|
return randomExponential.source = sourceRandomExponential, randomExponential;
|
|
}(defaultSource$1), pareto = function sourceRandomPareto(source) {
|
|
function randomPareto(alpha) {
|
|
if ((alpha = +alpha) < 0) throw RangeError("invalid alpha");
|
|
return alpha = -(1 / alpha), function() {
|
|
return Math.pow(1 - source(), alpha);
|
|
};
|
|
}
|
|
return randomPareto.source = sourceRandomPareto, randomPareto;
|
|
}(defaultSource$1), bernoulli = function sourceRandomBernoulli(source) {
|
|
function randomBernoulli(p) {
|
|
if ((p = +p) < 0 || p > 1) throw RangeError("invalid p");
|
|
return function() {
|
|
return Math.floor(source() + p);
|
|
};
|
|
}
|
|
return randomBernoulli.source = sourceRandomBernoulli, randomBernoulli;
|
|
}(defaultSource$1), geometric = function sourceRandomGeometric(source) {
|
|
function randomGeometric(p) {
|
|
if ((p = +p) < 0 || p > 1) throw RangeError("invalid p");
|
|
return 0 === p ? ()=>1 / 0 : 1 === p ? ()=>1 : (p = Math.log1p(-p), function() {
|
|
return 1 + Math.floor(Math.log1p(-source()) / p);
|
|
});
|
|
}
|
|
return randomGeometric.source = sourceRandomGeometric, randomGeometric;
|
|
}(defaultSource$1), gamma$1 = function sourceRandomGamma(source) {
|
|
var randomNormal = normal.source(source)();
|
|
function randomGamma(k, theta) {
|
|
if ((k = +k) < 0) throw RangeError("invalid k");
|
|
if (0 === k) return ()=>0;
|
|
if (theta = null == theta ? 1 : +theta, 1 === k) return ()=>-Math.log1p(-source()) * theta;
|
|
var d = (k < 1 ? k + 1 : k) - 1 / 3, c = 1 / (3 * Math.sqrt(d)), multiplier = k < 1 ? ()=>Math.pow(source(), 1 / k) : ()=>1;
|
|
return function() {
|
|
do {
|
|
do var x = randomNormal(), v = 1 + c * x;
|
|
while (v <= 0)
|
|
v *= v * v;
|
|
var u = 1 - source();
|
|
}while (u >= 1 - 0.0331 * x * x * x * x && Math.log(u) >= 0.5 * x * x + d * (1 - v + Math.log(v)))
|
|
return d * v * multiplier() * theta;
|
|
};
|
|
}
|
|
return randomGamma.source = sourceRandomGamma, randomGamma;
|
|
}(defaultSource$1), beta = function sourceRandomBeta(source) {
|
|
var G = gamma$1.source(source);
|
|
function randomBeta(alpha, beta) {
|
|
var X = G(alpha), Y = G(beta);
|
|
return function() {
|
|
var x = X();
|
|
return 0 === x ? 0 : x / (x + Y());
|
|
};
|
|
}
|
|
return randomBeta.source = sourceRandomBeta, randomBeta;
|
|
}(defaultSource$1), binomial = function sourceRandomBinomial(source) {
|
|
var G = geometric.source(source), B = beta.source(source);
|
|
function randomBinomial(n, p) {
|
|
return (n = +n, (p = +p) >= 1) ? ()=>n : p <= 0 ? ()=>0 : function() {
|
|
for(var acc = 0, nn = n, pp = p; nn * pp > 16 && nn * (1 - pp) > 16;){
|
|
var i = Math.floor((nn + 1) * pp), y = B(i, nn - i + 1)();
|
|
y <= pp ? (acc += i, nn -= i, pp = (pp - y) / (1 - y)) : (nn = i - 1, pp /= y);
|
|
}
|
|
for(var sign = pp < 0.5, pFinal = sign ? pp : 1 - pp, g = G(pFinal), s = g(), k = 0; s <= nn; ++k)s += g();
|
|
return acc + (sign ? k : nn - k);
|
|
};
|
|
}
|
|
return randomBinomial.source = sourceRandomBinomial, randomBinomial;
|
|
}(defaultSource$1), weibull = function sourceRandomWeibull(source) {
|
|
function randomWeibull(k, a, b) {
|
|
var outerFunc;
|
|
return 0 == (k = +k) ? outerFunc = (x)=>-Math.log(x) : (k = 1 / k, outerFunc = (x)=>Math.pow(x, k)), a = null == a ? 0 : +a, b = null == b ? 1 : +b, function() {
|
|
return a + b * outerFunc(-Math.log1p(-source()));
|
|
};
|
|
}
|
|
return randomWeibull.source = sourceRandomWeibull, randomWeibull;
|
|
}(defaultSource$1), cauchy = function sourceRandomCauchy(source) {
|
|
function randomCauchy(a, b) {
|
|
return a = null == a ? 0 : +a, b = null == b ? 1 : +b, function() {
|
|
return a + b * Math.tan(Math.PI * source());
|
|
};
|
|
}
|
|
return randomCauchy.source = sourceRandomCauchy, randomCauchy;
|
|
}(defaultSource$1), logistic = function sourceRandomLogistic(source) {
|
|
function randomLogistic(a, b) {
|
|
return a = null == a ? 0 : +a, b = null == b ? 1 : +b, function() {
|
|
var u = source();
|
|
return a + b * Math.log(u / (1 - u));
|
|
};
|
|
}
|
|
return randomLogistic.source = sourceRandomLogistic, randomLogistic;
|
|
}(defaultSource$1), poisson = function sourceRandomPoisson(source) {
|
|
var G = gamma$1.source(source), B = binomial.source(source);
|
|
function randomPoisson(lambda) {
|
|
return function() {
|
|
for(var acc = 0, l = lambda; l > 16;){
|
|
var n = Math.floor(0.875 * l), t = G(n)();
|
|
if (t > l) return acc + B(n - 1, l / t)();
|
|
acc += n, l -= t;
|
|
}
|
|
for(var s = -Math.log1p(-source()), k = 0; s <= l; ++k)s -= Math.log1p(-source());
|
|
return acc + k;
|
|
};
|
|
}
|
|
return randomPoisson.source = sourceRandomPoisson, randomPoisson;
|
|
}(defaultSource$1);
|
|
const eps = 1 / 0x100000000;
|
|
function initRange(domain, range) {
|
|
switch(arguments.length){
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
this.range(domain);
|
|
break;
|
|
default:
|
|
this.range(range).domain(domain);
|
|
}
|
|
return this;
|
|
}
|
|
function initInterpolator(domain, interpolator) {
|
|
switch(arguments.length){
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
"function" == typeof domain ? this.interpolator(domain) : this.range(domain);
|
|
break;
|
|
default:
|
|
this.domain(domain), "function" == typeof interpolator ? this.interpolator(interpolator) : this.range(interpolator);
|
|
}
|
|
return this;
|
|
}
|
|
const implicit = Symbol("implicit");
|
|
function ordinal() {
|
|
var index = new Map(), domain = [], range = [], unknown = implicit;
|
|
function scale(d) {
|
|
var key = d + "", i = index.get(key);
|
|
if (!i) {
|
|
if (unknown !== implicit) return unknown;
|
|
index.set(key, i = domain.push(d));
|
|
}
|
|
return range[(i - 1) % range.length];
|
|
}
|
|
return scale.domain = function(_) {
|
|
if (!arguments.length) return domain.slice();
|
|
for (const value of (domain = [], index = new Map(), _)){
|
|
const key = value + "";
|
|
index.has(key) || index.set(key, domain.push(value));
|
|
}
|
|
return scale;
|
|
}, scale.range = function(_) {
|
|
return arguments.length ? (range = Array.from(_), scale) : range.slice();
|
|
}, scale.unknown = function(_) {
|
|
return arguments.length ? (unknown = _, scale) : unknown;
|
|
}, scale.copy = function() {
|
|
return ordinal(domain, range).unknown(unknown);
|
|
}, initRange.apply(scale, arguments), scale;
|
|
}
|
|
function band() {
|
|
var step, bandwidth, scale = ordinal().unknown(void 0), domain = scale.domain, ordinalRange = scale.range, r0 = 0, r1 = 1, round = !1, paddingInner = 0, paddingOuter = 0, align = 0.5;
|
|
function rescale() {
|
|
var n = domain().length, reverse = r1 < r0, start = reverse ? r1 : r0, stop = reverse ? r0 : r1;
|
|
step = (stop - start) / Math.max(1, n - paddingInner + 2 * paddingOuter), round && (step = Math.floor(step)), start += (stop - start - step * (n - paddingInner)) * align, bandwidth = step * (1 - paddingInner), round && (start = Math.round(start), bandwidth = Math.round(bandwidth));
|
|
var values = sequence(n).map(function(i) {
|
|
return start + step * i;
|
|
});
|
|
return ordinalRange(reverse ? values.reverse() : values);
|
|
}
|
|
return delete scale.unknown, scale.domain = function(_) {
|
|
return arguments.length ? (domain(_), rescale()) : domain();
|
|
}, scale.range = function(_) {
|
|
return arguments.length ? ([r0, r1] = _, r0 = +r0, r1 = +r1, rescale()) : [
|
|
r0,
|
|
r1
|
|
];
|
|
}, scale.rangeRound = function(_) {
|
|
return [r0, r1] = _, r0 = +r0, r1 = +r1, round = !0, rescale();
|
|
}, scale.bandwidth = function() {
|
|
return bandwidth;
|
|
}, scale.step = function() {
|
|
return step;
|
|
}, scale.round = function(_) {
|
|
return arguments.length ? (round = !!_, rescale()) : round;
|
|
}, scale.padding = function(_) {
|
|
return arguments.length ? (paddingInner = Math.min(1, paddingOuter = +_), rescale()) : paddingInner;
|
|
}, scale.paddingInner = function(_) {
|
|
return arguments.length ? (paddingInner = Math.min(1, _), rescale()) : paddingInner;
|
|
}, scale.paddingOuter = function(_) {
|
|
return arguments.length ? (paddingOuter = +_, rescale()) : paddingOuter;
|
|
}, scale.align = function(_) {
|
|
return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align;
|
|
}, scale.copy = function() {
|
|
return band(domain(), [
|
|
r0,
|
|
r1
|
|
]).round(round).paddingInner(paddingInner).paddingOuter(paddingOuter).align(align);
|
|
}, initRange.apply(rescale(), arguments);
|
|
}
|
|
function number$2(x) {
|
|
return +x;
|
|
}
|
|
var unit = [
|
|
0,
|
|
1
|
|
];
|
|
function identity$6(x) {
|
|
return x;
|
|
}
|
|
function normalize(a, b) {
|
|
var x;
|
|
return (b -= a = +a) ? function(x) {
|
|
return (x - a) / b;
|
|
} : (x = isNaN(b) ? NaN : 0.5, function() {
|
|
return x;
|
|
});
|
|
}
|
|
function bimap(domain, range, interpolate) {
|
|
var d0 = domain[0], d1 = domain[1], r0 = range[0], r1 = range[1];
|
|
return d1 < d0 ? (d0 = normalize(d1, d0), r0 = interpolate(r1, r0)) : (d0 = normalize(d0, d1), r0 = interpolate(r0, r1)), function(x) {
|
|
return r0(d0(x));
|
|
};
|
|
}
|
|
function polymap(domain, range, interpolate) {
|
|
var j = Math.min(domain.length, range.length) - 1, d = Array(j), r = Array(j), i = -1;
|
|
for(domain[j] < domain[0] && (domain = domain.slice().reverse(), range = range.slice().reverse()); ++i < j;)d[i] = normalize(domain[i], domain[i + 1]), r[i] = interpolate(range[i], range[i + 1]);
|
|
return function(x) {
|
|
var i = bisectRight(domain, x, 1, j) - 1;
|
|
return r[i](d[i](x));
|
|
};
|
|
}
|
|
function copy(source, target) {
|
|
return target.domain(source.domain()).range(source.range()).interpolate(source.interpolate()).clamp(source.clamp()).unknown(source.unknown());
|
|
}
|
|
function transformer$1() {
|
|
var transform, untransform, unknown, piecewise, output, input, domain = unit, range = unit, interpolate$1 = interpolate, clamp = identity$6;
|
|
function rescale() {
|
|
var a, b, t, n = Math.min(domain.length, range.length);
|
|
return clamp !== identity$6 && ((a = domain[0]) > (b = domain[n - 1]) && (t = a, a = b, b = t), clamp = function(x) {
|
|
return Math.max(a, Math.min(b, x));
|
|
}), piecewise = n > 2 ? polymap : bimap, output = input = null, scale;
|
|
}
|
|
function scale(x) {
|
|
return isNaN(x = +x) ? unknown : (output || (output = piecewise(domain.map(transform), range, interpolate$1)))(transform(clamp(x)));
|
|
}
|
|
return scale.invert = function(y) {
|
|
return clamp(untransform((input || (input = piecewise(range, domain.map(transform), interpolateNumber)))(y)));
|
|
}, scale.domain = function(_) {
|
|
return arguments.length ? (domain = Array.from(_, number$2), rescale()) : domain.slice();
|
|
}, scale.range = function(_) {
|
|
return arguments.length ? (range = Array.from(_), rescale()) : range.slice();
|
|
}, scale.rangeRound = function(_) {
|
|
return range = Array.from(_), interpolate$1 = interpolateRound, rescale();
|
|
}, scale.clamp = function(_) {
|
|
return arguments.length ? (clamp = !!_ || identity$6, rescale()) : clamp !== identity$6;
|
|
}, scale.interpolate = function(_) {
|
|
return arguments.length ? (interpolate$1 = _, rescale()) : interpolate$1;
|
|
}, scale.unknown = function(_) {
|
|
return arguments.length ? (unknown = _, scale) : unknown;
|
|
}, function(t, u) {
|
|
return transform = t, untransform = u, rescale();
|
|
};
|
|
}
|
|
function continuous() {
|
|
return transformer$1()(identity$6, identity$6);
|
|
}
|
|
function tickFormat(start, stop, count, specifier) {
|
|
var precision, step = tickStep(start, stop, count);
|
|
switch((specifier = formatSpecifier(null == specifier ? ",f" : specifier)).type){
|
|
case "s":
|
|
var value = Math.max(Math.abs(start), Math.abs(stop));
|
|
return null != specifier.precision || isNaN(precision = precisionPrefix(step, value)) || (specifier.precision = precision), exports1.formatPrefix(specifier, value);
|
|
case "":
|
|
case "e":
|
|
case "g":
|
|
case "p":
|
|
case "r":
|
|
null != specifier.precision || isNaN(precision = precisionRound(step, Math.max(Math.abs(start), Math.abs(stop)))) || (specifier.precision = precision - ("e" === specifier.type));
|
|
break;
|
|
case "f":
|
|
case "%":
|
|
null != specifier.precision || isNaN(precision = precisionFixed(step)) || (specifier.precision = precision - ("%" === specifier.type) * 2);
|
|
}
|
|
return exports1.format(specifier);
|
|
}
|
|
function linearish(scale) {
|
|
var domain = scale.domain;
|
|
return scale.ticks = function(count) {
|
|
var d = domain();
|
|
return ticks(d[0], d[d.length - 1], null == count ? 10 : count);
|
|
}, scale.tickFormat = function(count, specifier) {
|
|
var d = domain();
|
|
return tickFormat(d[0], d[d.length - 1], null == count ? 10 : count, specifier);
|
|
}, scale.nice = function(count) {
|
|
null == count && (count = 10);
|
|
var prestep, step, d = domain(), i0 = 0, i1 = d.length - 1, start = d[i0], stop = d[i1], maxIter = 10;
|
|
for(stop < start && (step = start, start = stop, stop = step, step = i0, i0 = i1, i1 = step); maxIter-- > 0;){
|
|
if ((step = tickIncrement(start, stop, count)) === prestep) return d[i0] = start, d[i1] = stop, domain(d);
|
|
if (step > 0) start = Math.floor(start / step) * step, stop = Math.ceil(stop / step) * step;
|
|
else if (step < 0) start = Math.ceil(start * step) / step, stop = Math.floor(stop * step) / step;
|
|
else break;
|
|
prestep = step;
|
|
}
|
|
return scale;
|
|
}, scale;
|
|
}
|
|
function nice$1(domain, interval) {
|
|
domain = domain.slice();
|
|
var t, i0 = 0, i1 = domain.length - 1, x0 = domain[i0], x1 = domain[i1];
|
|
return x1 < x0 && (t = i0, i0 = i1, i1 = t, t = x0, x0 = x1, x1 = t), domain[i0] = interval.floor(x0), domain[i1] = interval.ceil(x1), domain;
|
|
}
|
|
function transformLog(x) {
|
|
return Math.log(x);
|
|
}
|
|
function transformExp(x) {
|
|
return Math.exp(x);
|
|
}
|
|
function transformLogn(x) {
|
|
return -Math.log(-x);
|
|
}
|
|
function transformExpn(x) {
|
|
return -Math.exp(-x);
|
|
}
|
|
function pow10(x) {
|
|
return isFinite(x) ? +("1e" + x) : x < 0 ? 0 : x;
|
|
}
|
|
function reflect(f) {
|
|
return function(x) {
|
|
return -f(-x);
|
|
};
|
|
}
|
|
function loggish(transform) {
|
|
var logs, pows, scale = transform(transformLog, transformExp), domain = scale.domain, base = 10;
|
|
function rescale() {
|
|
var base1, base2;
|
|
return logs = (base1 = base) === Math.E ? Math.log : 10 === base1 && Math.log10 || 2 === base1 && Math.log2 || (base1 = Math.log(base1), function(x) {
|
|
return Math.log(x) / base1;
|
|
}), pows = 10 === (base2 = base) ? pow10 : base2 === Math.E ? Math.exp : function(x) {
|
|
return Math.pow(base2, x);
|
|
}, domain()[0] < 0 ? (logs = reflect(logs), pows = reflect(pows), transform(transformLogn, transformExpn)) : transform(transformLog, transformExp), scale;
|
|
}
|
|
return scale.base = function(_) {
|
|
return arguments.length ? (base = +_, rescale()) : base;
|
|
}, scale.domain = function(_) {
|
|
return arguments.length ? (domain(_), rescale()) : domain();
|
|
}, scale.ticks = function(count) {
|
|
var r, d = domain(), u = d[0], v = d[d.length - 1];
|
|
(r = v < u) && (i = u, u = v, v = i);
|
|
var p, k, t, i = logs(u), j = logs(v), n = null == count ? 10 : +count, z = [];
|
|
if (!(base % 1) && j - i < n) {
|
|
if (i = Math.floor(i), j = Math.ceil(j), u > 0) {
|
|
for(; i <= j; ++i)for(k = 1, p = pows(i); k < base; ++k)if (!((t = p * k) < u)) {
|
|
if (t > v) break;
|
|
z.push(t);
|
|
}
|
|
} else for(; i <= j; ++i)for(k = base - 1, p = pows(i); k >= 1; --k)if (!((t = p * k) < u)) {
|
|
if (t > v) break;
|
|
z.push(t);
|
|
}
|
|
2 * z.length < n && (z = ticks(u, v, n));
|
|
} else z = ticks(i, j, Math.min(j - i, n)).map(pows);
|
|
return r ? z.reverse() : z;
|
|
}, scale.tickFormat = function(count, specifier) {
|
|
if (null == specifier && (specifier = 10 === base ? ".0e" : ","), "function" != typeof specifier && (specifier = exports1.format(specifier)), count === 1 / 0) return specifier;
|
|
null == count && (count = 10);
|
|
var k = Math.max(1, base * count / scale.ticks().length);
|
|
return function(d) {
|
|
var i = d / pows(Math.round(logs(d)));
|
|
return i * base < base - 0.5 && (i *= base), i <= k ? specifier(d) : "";
|
|
};
|
|
}, scale.nice = function() {
|
|
return domain(nice$1(domain(), {
|
|
floor: function(x) {
|
|
return pows(Math.floor(logs(x)));
|
|
},
|
|
ceil: function(x) {
|
|
return pows(Math.ceil(logs(x)));
|
|
}
|
|
}));
|
|
}, scale;
|
|
}
|
|
function transformSymlog(c) {
|
|
return function(x) {
|
|
return Math.sign(x) * Math.log1p(Math.abs(x / c));
|
|
};
|
|
}
|
|
function transformSymexp(c) {
|
|
return function(x) {
|
|
return Math.sign(x) * Math.expm1(Math.abs(x)) * c;
|
|
};
|
|
}
|
|
function symlogish(transform) {
|
|
var c = 1, scale = transform(transformSymlog(1), transformSymexp(c));
|
|
return scale.constant = function(_) {
|
|
return arguments.length ? transform(transformSymlog(c = +_), transformSymexp(c)) : c;
|
|
}, linearish(scale);
|
|
}
|
|
function transformPow(exponent) {
|
|
return function(x) {
|
|
return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent);
|
|
};
|
|
}
|
|
function transformSqrt(x) {
|
|
return x < 0 ? -Math.sqrt(-x) : Math.sqrt(x);
|
|
}
|
|
function transformSquare(x) {
|
|
return x < 0 ? -x * x : x * x;
|
|
}
|
|
function powish(transform) {
|
|
var scale = transform(identity$6, identity$6), exponent = 1;
|
|
return scale.exponent = function(_) {
|
|
return arguments.length ? 1 == (exponent = +_) ? transform(identity$6, identity$6) : 0.5 === exponent ? transform(transformSqrt, transformSquare) : transform(transformPow(exponent), transformPow(1 / exponent)) : exponent;
|
|
}, linearish(scale);
|
|
}
|
|
function pow$2() {
|
|
var scale = powish(transformer$1());
|
|
return scale.copy = function() {
|
|
return copy(scale, pow$2()).exponent(scale.exponent());
|
|
}, initRange.apply(scale, arguments), scale;
|
|
}
|
|
function square(x) {
|
|
return Math.sign(x) * x * x;
|
|
}
|
|
var t0$1 = new Date, t1$1 = new Date;
|
|
function newInterval(floori, offseti, count, field) {
|
|
function interval(date) {
|
|
return floori(date = 0 === arguments.length ? new Date : new Date(+date)), date;
|
|
}
|
|
return interval.floor = function(date) {
|
|
return floori(date = new Date(+date)), date;
|
|
}, interval.ceil = function(date) {
|
|
return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;
|
|
}, interval.round = function(date) {
|
|
var d0 = interval(date), d1 = interval.ceil(date);
|
|
return date - d0 < d1 - date ? d0 : d1;
|
|
}, interval.offset = function(date, step) {
|
|
return offseti(date = new Date(+date), null == step ? 1 : Math.floor(step)), date;
|
|
}, interval.range = function(start, stop, step) {
|
|
var previous, range = [];
|
|
if (start = interval.ceil(start), step = null == step ? 1 : Math.floor(step), !(start < stop) || !(step > 0)) return range;
|
|
do range.push(previous = new Date(+start)), offseti(start, step), floori(start);
|
|
while (previous < start && start < stop)
|
|
return range;
|
|
}, interval.filter = function(test) {
|
|
return newInterval(function(date) {
|
|
if (date >= date) for(; floori(date), !test(date);)date.setTime(date - 1);
|
|
}, function(date, step) {
|
|
if (date >= date) {
|
|
if (step < 0) for(; ++step <= 0;)for(; offseti(date, -1), !test(date););
|
|
else for(; --step >= 0;)for(; offseti(date, 1), !test(date););
|
|
}
|
|
});
|
|
}, count && (interval.count = function(start, end) {
|
|
return t0$1.setTime(+start), t1$1.setTime(+end), floori(t0$1), floori(t1$1), Math.floor(count(t0$1, t1$1));
|
|
}, interval.every = function(step) {
|
|
return isFinite(step = Math.floor(step)) && step > 0 ? step > 1 ? interval.filter(field ? function(d) {
|
|
return field(d) % step == 0;
|
|
} : function(d) {
|
|
return interval.count(0, d) % step == 0;
|
|
}) : interval : null;
|
|
}), interval;
|
|
}
|
|
var millisecond = newInterval(function() {}, function(date, step) {
|
|
date.setTime(+date + step);
|
|
}, function(start, end) {
|
|
return end - start;
|
|
});
|
|
millisecond.every = function(k) {
|
|
return isFinite(k = Math.floor(k)) && k > 0 ? k > 1 ? newInterval(function(date) {
|
|
date.setTime(Math.floor(date / k) * k);
|
|
}, function(date, step) {
|
|
date.setTime(+date + step * k);
|
|
}, function(start, end) {
|
|
return (end - start) / k;
|
|
}) : millisecond : null;
|
|
};
|
|
var milliseconds = millisecond.range, second = newInterval(function(date) {
|
|
date.setTime(date - date.getMilliseconds());
|
|
}, function(date, step) {
|
|
date.setTime(+date + 1e3 * step);
|
|
}, function(start, end) {
|
|
return (end - start) / 1e3;
|
|
}, function(date) {
|
|
return date.getUTCSeconds();
|
|
}), seconds = second.range, minute = newInterval(function(date) {
|
|
date.setTime(date - date.getMilliseconds() - 1e3 * date.getSeconds());
|
|
}, function(date, step) {
|
|
date.setTime(+date + 6e4 * step);
|
|
}, function(start, end) {
|
|
return (end - start) / 6e4;
|
|
}, function(date) {
|
|
return date.getMinutes();
|
|
}), minutes = minute.range, hour = newInterval(function(date) {
|
|
date.setTime(date - date.getMilliseconds() - 1e3 * date.getSeconds() - 6e4 * date.getMinutes());
|
|
}, function(date, step) {
|
|
date.setTime(+date + 36e5 * step);
|
|
}, function(start, end) {
|
|
return (end - start) / 36e5;
|
|
}, function(date) {
|
|
return date.getHours();
|
|
}), hours = hour.range, day = newInterval((date)=>date.setHours(0, 0, 0, 0), (date, step)=>date.setDate(date.getDate() + step), (start, end)=>(end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * 6e4) / 864e5, (date)=>date.getDate() - 1), days = day.range;
|
|
function weekday(i) {
|
|
return newInterval(function(date) {
|
|
date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7), date.setHours(0, 0, 0, 0);
|
|
}, function(date, step) {
|
|
date.setDate(date.getDate() + 7 * step);
|
|
}, function(start, end) {
|
|
return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * 6e4) / 6048e5;
|
|
});
|
|
}
|
|
var sunday = weekday(0), monday = weekday(1), tuesday = weekday(2), wednesday = weekday(3), thursday = weekday(4), friday = weekday(5), saturday = weekday(6), sundays = sunday.range, mondays = monday.range, tuesdays = tuesday.range, wednesdays = wednesday.range, thursdays = thursday.range, fridays = friday.range, saturdays = saturday.range, month = newInterval(function(date) {
|
|
date.setDate(1), date.setHours(0, 0, 0, 0);
|
|
}, function(date, step) {
|
|
date.setMonth(date.getMonth() + step);
|
|
}, function(start, end) {
|
|
return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;
|
|
}, function(date) {
|
|
return date.getMonth();
|
|
}), months = month.range, year = newInterval(function(date) {
|
|
date.setMonth(0, 1), date.setHours(0, 0, 0, 0);
|
|
}, function(date, step) {
|
|
date.setFullYear(date.getFullYear() + step);
|
|
}, function(start, end) {
|
|
return end.getFullYear() - start.getFullYear();
|
|
}, function(date) {
|
|
return date.getFullYear();
|
|
});
|
|
year.every = function(k) {
|
|
return isFinite(k = Math.floor(k)) && k > 0 ? newInterval(function(date) {
|
|
date.setFullYear(Math.floor(date.getFullYear() / k) * k), date.setMonth(0, 1), date.setHours(0, 0, 0, 0);
|
|
}, function(date, step) {
|
|
date.setFullYear(date.getFullYear() + step * k);
|
|
}) : null;
|
|
};
|
|
var years = year.range, utcMinute = newInterval(function(date) {
|
|
date.setUTCSeconds(0, 0);
|
|
}, function(date, step) {
|
|
date.setTime(+date + 6e4 * step);
|
|
}, function(start, end) {
|
|
return (end - start) / 6e4;
|
|
}, function(date) {
|
|
return date.getUTCMinutes();
|
|
}), utcMinutes = utcMinute.range, utcHour = newInterval(function(date) {
|
|
date.setUTCMinutes(0, 0, 0);
|
|
}, function(date, step) {
|
|
date.setTime(+date + 36e5 * step);
|
|
}, function(start, end) {
|
|
return (end - start) / 36e5;
|
|
}, function(date) {
|
|
return date.getUTCHours();
|
|
}), utcHours = utcHour.range, utcDay = newInterval(function(date) {
|
|
date.setUTCHours(0, 0, 0, 0);
|
|
}, function(date, step) {
|
|
date.setUTCDate(date.getUTCDate() + step);
|
|
}, function(start, end) {
|
|
return (end - start) / 864e5;
|
|
}, function(date) {
|
|
return date.getUTCDate() - 1;
|
|
}), utcDays = utcDay.range;
|
|
function utcWeekday(i) {
|
|
return newInterval(function(date) {
|
|
date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7), date.setUTCHours(0, 0, 0, 0);
|
|
}, function(date, step) {
|
|
date.setUTCDate(date.getUTCDate() + 7 * step);
|
|
}, function(start, end) {
|
|
return (end - start) / 6048e5;
|
|
});
|
|
}
|
|
var utcSunday = utcWeekday(0), utcMonday = utcWeekday(1), utcTuesday = utcWeekday(2), utcWednesday = utcWeekday(3), utcThursday = utcWeekday(4), utcFriday = utcWeekday(5), utcSaturday = utcWeekday(6), utcSundays = utcSunday.range, utcMondays = utcMonday.range, utcTuesdays = utcTuesday.range, utcWednesdays = utcWednesday.range, utcThursdays = utcThursday.range, utcFridays = utcFriday.range, utcSaturdays = utcSaturday.range, utcMonth = newInterval(function(date) {
|
|
date.setUTCDate(1), date.setUTCHours(0, 0, 0, 0);
|
|
}, function(date, step) {
|
|
date.setUTCMonth(date.getUTCMonth() + step);
|
|
}, function(start, end) {
|
|
return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;
|
|
}, function(date) {
|
|
return date.getUTCMonth();
|
|
}), utcMonths = utcMonth.range, utcYear = newInterval(function(date) {
|
|
date.setUTCMonth(0, 1), date.setUTCHours(0, 0, 0, 0);
|
|
}, function(date, step) {
|
|
date.setUTCFullYear(date.getUTCFullYear() + step);
|
|
}, function(start, end) {
|
|
return end.getUTCFullYear() - start.getUTCFullYear();
|
|
}, function(date) {
|
|
return date.getUTCFullYear();
|
|
});
|
|
utcYear.every = function(k) {
|
|
return isFinite(k = Math.floor(k)) && k > 0 ? newInterval(function(date) {
|
|
date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k), date.setUTCMonth(0, 1), date.setUTCHours(0, 0, 0, 0);
|
|
}, function(date, step) {
|
|
date.setUTCFullYear(date.getUTCFullYear() + step * k);
|
|
}) : null;
|
|
};
|
|
var utcYears = utcYear.range;
|
|
function localDate(d) {
|
|
if (0 <= d.y && d.y < 100) {
|
|
var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L);
|
|
return date.setFullYear(d.y), date;
|
|
}
|
|
return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L);
|
|
}
|
|
function utcDate(d) {
|
|
if (0 <= d.y && d.y < 100) {
|
|
var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L));
|
|
return date.setUTCFullYear(d.y), date;
|
|
}
|
|
return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));
|
|
}
|
|
function newDate(y, m, d) {
|
|
return {
|
|
y: y,
|
|
m: m,
|
|
d: d,
|
|
H: 0,
|
|
M: 0,
|
|
S: 0,
|
|
L: 0
|
|
};
|
|
}
|
|
function formatLocale$1(locale) {
|
|
var locale_dateTime = locale.dateTime, locale_date = locale.date, locale_time = locale.time, locale_periods = locale.periods, locale_weekdays = locale.days, locale_shortWeekdays = locale.shortDays, locale_months = locale.months, locale_shortMonths = locale.shortMonths, periodRe = formatRe(locale_periods), periodLookup = formatLookup(locale_periods), weekdayRe = formatRe(locale_weekdays), weekdayLookup = formatLookup(locale_weekdays), shortWeekdayRe = formatRe(locale_shortWeekdays), shortWeekdayLookup = formatLookup(locale_shortWeekdays), monthRe = formatRe(locale_months), monthLookup = formatLookup(locale_months), shortMonthRe = formatRe(locale_shortMonths), shortMonthLookup = formatLookup(locale_shortMonths), formats = {
|
|
a: function(d) {
|
|
return locale_shortWeekdays[d.getDay()];
|
|
},
|
|
A: function(d) {
|
|
return locale_weekdays[d.getDay()];
|
|
},
|
|
b: function(d) {
|
|
return locale_shortMonths[d.getMonth()];
|
|
},
|
|
B: function(d) {
|
|
return locale_months[d.getMonth()];
|
|
},
|
|
c: null,
|
|
d: formatDayOfMonth,
|
|
e: formatDayOfMonth,
|
|
f: formatMicroseconds,
|
|
g: formatYearISO,
|
|
G: formatFullYearISO,
|
|
H: formatHour24,
|
|
I: formatHour12,
|
|
j: formatDayOfYear,
|
|
L: formatMilliseconds,
|
|
m: formatMonthNumber,
|
|
M: formatMinutes,
|
|
p: function(d) {
|
|
return locale_periods[+(d.getHours() >= 12)];
|
|
},
|
|
q: function(d) {
|
|
return 1 + ~~(d.getMonth() / 3);
|
|
},
|
|
Q: formatUnixTimestamp,
|
|
s: formatUnixTimestampSeconds,
|
|
S: formatSeconds,
|
|
u: formatWeekdayNumberMonday,
|
|
U: formatWeekNumberSunday,
|
|
V: formatWeekNumberISO,
|
|
w: formatWeekdayNumberSunday,
|
|
W: formatWeekNumberMonday,
|
|
x: null,
|
|
X: null,
|
|
y: formatYear$1,
|
|
Y: formatFullYear,
|
|
Z: formatZone,
|
|
"%": formatLiteralPercent
|
|
}, utcFormats = {
|
|
a: function(d) {
|
|
return locale_shortWeekdays[d.getUTCDay()];
|
|
},
|
|
A: function(d) {
|
|
return locale_weekdays[d.getUTCDay()];
|
|
},
|
|
b: function(d) {
|
|
return locale_shortMonths[d.getUTCMonth()];
|
|
},
|
|
B: function(d) {
|
|
return locale_months[d.getUTCMonth()];
|
|
},
|
|
c: null,
|
|
d: formatUTCDayOfMonth,
|
|
e: formatUTCDayOfMonth,
|
|
f: formatUTCMicroseconds,
|
|
g: formatUTCYearISO,
|
|
G: formatUTCFullYearISO,
|
|
H: formatUTCHour24,
|
|
I: formatUTCHour12,
|
|
j: formatUTCDayOfYear,
|
|
L: formatUTCMilliseconds,
|
|
m: formatUTCMonthNumber,
|
|
M: formatUTCMinutes,
|
|
p: function(d) {
|
|
return locale_periods[+(d.getUTCHours() >= 12)];
|
|
},
|
|
q: function(d) {
|
|
return 1 + ~~(d.getUTCMonth() / 3);
|
|
},
|
|
Q: formatUnixTimestamp,
|
|
s: formatUnixTimestampSeconds,
|
|
S: formatUTCSeconds,
|
|
u: formatUTCWeekdayNumberMonday,
|
|
U: formatUTCWeekNumberSunday,
|
|
V: formatUTCWeekNumberISO,
|
|
w: formatUTCWeekdayNumberSunday,
|
|
W: formatUTCWeekNumberMonday,
|
|
x: null,
|
|
X: null,
|
|
y: formatUTCYear,
|
|
Y: formatUTCFullYear,
|
|
Z: formatUTCZone,
|
|
"%": formatLiteralPercent
|
|
}, parses = {
|
|
a: function(d, string, i) {
|
|
var n = shortWeekdayRe.exec(string.slice(i));
|
|
return n ? (d.w = shortWeekdayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
|
|
},
|
|
A: function(d, string, i) {
|
|
var n = weekdayRe.exec(string.slice(i));
|
|
return n ? (d.w = weekdayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
|
|
},
|
|
b: function(d, string, i) {
|
|
var n = shortMonthRe.exec(string.slice(i));
|
|
return n ? (d.m = shortMonthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
|
|
},
|
|
B: function(d, string, i) {
|
|
var n = monthRe.exec(string.slice(i));
|
|
return n ? (d.m = monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
|
|
},
|
|
c: function(d, string, i) {
|
|
return parseSpecifier(d, locale_dateTime, string, i);
|
|
},
|
|
d: parseDayOfMonth,
|
|
e: parseDayOfMonth,
|
|
f: parseMicroseconds,
|
|
g: parseYear,
|
|
G: parseFullYear,
|
|
H: parseHour24,
|
|
I: parseHour24,
|
|
j: parseDayOfYear,
|
|
L: parseMilliseconds,
|
|
m: parseMonthNumber,
|
|
M: parseMinutes,
|
|
p: function(d, string, i) {
|
|
var n = periodRe.exec(string.slice(i));
|
|
return n ? (d.p = periodLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
|
|
},
|
|
q: parseQuarter,
|
|
Q: parseUnixTimestamp,
|
|
s: parseUnixTimestampSeconds,
|
|
S: parseSeconds,
|
|
u: parseWeekdayNumberMonday,
|
|
U: parseWeekNumberSunday,
|
|
V: parseWeekNumberISO,
|
|
w: parseWeekdayNumberSunday,
|
|
W: parseWeekNumberMonday,
|
|
x: function(d, string, i) {
|
|
return parseSpecifier(d, locale_date, string, i);
|
|
},
|
|
X: function(d, string, i) {
|
|
return parseSpecifier(d, locale_time, string, i);
|
|
},
|
|
y: parseYear,
|
|
Y: parseFullYear,
|
|
Z: parseZone,
|
|
"%": parseLiteralPercent
|
|
};
|
|
function newFormat(specifier, formats) {
|
|
return function(date) {
|
|
var c, pad, format, string = [], i = -1, j = 0, n = specifier.length;
|
|
for(date instanceof Date || (date = new Date(+date)); ++i < n;)37 === specifier.charCodeAt(i) && (string.push(specifier.slice(j, i)), null != (pad = pads[c = specifier.charAt(++i)]) ? c = specifier.charAt(++i) : pad = "e" === c ? " " : "0", (format = formats[c]) && (c = format(date, pad)), string.push(c), j = i + 1);
|
|
return string.push(specifier.slice(j, i)), string.join("");
|
|
};
|
|
}
|
|
function newParse(specifier, Z) {
|
|
return function(string) {
|
|
var week, day$1, d = newDate(1900, void 0, 1);
|
|
if (parseSpecifier(d, specifier, string += "", 0) != string.length) return null;
|
|
if ("Q" in d) return new Date(d.Q);
|
|
if ("s" in d) return new Date(1000 * d.s + ("L" in d ? d.L : 0));
|
|
if (!Z || "Z" in d || (d.Z = 0), "p" in d && (d.H = d.H % 12 + 12 * d.p), void 0 === d.m && (d.m = "q" in d ? d.q : 0), "V" in d) {
|
|
if (d.V < 1 || d.V > 53) return null;
|
|
"w" in d || (d.w = 1), "Z" in d ? (week = (day$1 = (week = utcDate(newDate(d.y, 0, 1))).getUTCDay()) > 4 || 0 === day$1 ? utcMonday.ceil(week) : utcMonday(week), week = utcDay.offset(week, (d.V - 1) * 7), d.y = week.getUTCFullYear(), d.m = week.getUTCMonth(), d.d = week.getUTCDate() + (d.w + 6) % 7) : (week = (day$1 = (week = localDate(newDate(d.y, 0, 1))).getDay()) > 4 || 0 === day$1 ? monday.ceil(week) : monday(week), week = day.offset(week, (d.V - 1) * 7), d.y = week.getFullYear(), d.m = week.getMonth(), d.d = week.getDate() + (d.w + 6) % 7);
|
|
} else ("W" in d || "U" in d) && ("w" in d || (d.w = "u" in d ? d.u % 7 : "W" in d ? 1 : 0), day$1 = "Z" in d ? utcDate(newDate(d.y, 0, 1)).getUTCDay() : localDate(newDate(d.y, 0, 1)).getDay(), d.m = 0, d.d = "W" in d ? (d.w + 6) % 7 + 7 * d.W - (day$1 + 5) % 7 : d.w + 7 * d.U - (day$1 + 6) % 7);
|
|
return "Z" in d ? (d.H += d.Z / 100 | 0, d.M += d.Z % 100, utcDate(d)) : localDate(d);
|
|
};
|
|
}
|
|
function parseSpecifier(d, specifier, string, j) {
|
|
for(var c, parse, i = 0, n = specifier.length, m = string.length; i < n;){
|
|
if (j >= m) return -1;
|
|
if (37 === (c = specifier.charCodeAt(i++))) {
|
|
if (!(parse = parses[(c = specifier.charAt(i++)) in pads ? specifier.charAt(i++) : c]) || (j = parse(d, string, j)) < 0) return -1;
|
|
} else if (c != string.charCodeAt(j++)) return -1;
|
|
}
|
|
return j;
|
|
}
|
|
return formats.x = newFormat(locale_date, formats), formats.X = newFormat(locale_time, formats), formats.c = newFormat(locale_dateTime, formats), utcFormats.x = newFormat(locale_date, utcFormats), utcFormats.X = newFormat(locale_time, utcFormats), utcFormats.c = newFormat(locale_dateTime, utcFormats), {
|
|
format: function(specifier) {
|
|
var f = newFormat(specifier += "", formats);
|
|
return f.toString = function() {
|
|
return specifier;
|
|
}, f;
|
|
},
|
|
parse: function(specifier) {
|
|
var p = newParse(specifier += "", !1);
|
|
return p.toString = function() {
|
|
return specifier;
|
|
}, p;
|
|
},
|
|
utcFormat: function(specifier) {
|
|
var f = newFormat(specifier += "", utcFormats);
|
|
return f.toString = function() {
|
|
return specifier;
|
|
}, f;
|
|
},
|
|
utcParse: function(specifier) {
|
|
var p = newParse(specifier += "", !0);
|
|
return p.toString = function() {
|
|
return specifier;
|
|
}, p;
|
|
}
|
|
};
|
|
}
|
|
var pads = {
|
|
"-": "",
|
|
_: " ",
|
|
0: "0"
|
|
}, numberRe = /^\s*\d+/, percentRe = /^%/, requoteRe = /[\\^$*+?|[\]().{}]/g;
|
|
function pad$1(value, fill, width) {
|
|
var sign = value < 0 ? "-" : "", string = (sign ? -value : value) + "", length = string.length;
|
|
return sign + (length < width ? Array(width - length + 1).join(fill) + string : string);
|
|
}
|
|
function requote(s) {
|
|
return s.replace(requoteRe, "\\$&");
|
|
}
|
|
function formatRe(names) {
|
|
return RegExp("^(?:" + names.map(requote).join("|") + ")", "i");
|
|
}
|
|
function formatLookup(names) {
|
|
return new Map(names.map((name, i)=>[
|
|
name.toLowerCase(),
|
|
i
|
|
]));
|
|
}
|
|
function parseWeekdayNumberSunday(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 1));
|
|
return n ? (d.w = +n[0], i + n[0].length) : -1;
|
|
}
|
|
function parseWeekdayNumberMonday(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 1));
|
|
return n ? (d.u = +n[0], i + n[0].length) : -1;
|
|
}
|
|
function parseWeekNumberSunday(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
return n ? (d.U = +n[0], i + n[0].length) : -1;
|
|
}
|
|
function parseWeekNumberISO(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
return n ? (d.V = +n[0], i + n[0].length) : -1;
|
|
}
|
|
function parseWeekNumberMonday(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
return n ? (d.W = +n[0], i + n[0].length) : -1;
|
|
}
|
|
function parseFullYear(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 4));
|
|
return n ? (d.y = +n[0], i + n[0].length) : -1;
|
|
}
|
|
function parseYear(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1;
|
|
}
|
|
function parseZone(d, string, i) {
|
|
var n = /^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(string.slice(i, i + 6));
|
|
return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || "00")), i + n[0].length) : -1;
|
|
}
|
|
function parseQuarter(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 1));
|
|
return n ? (d.q = 3 * n[0] - 3, i + n[0].length) : -1;
|
|
}
|
|
function parseMonthNumber(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
return n ? (d.m = n[0] - 1, i + n[0].length) : -1;
|
|
}
|
|
function parseDayOfMonth(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
return n ? (d.d = +n[0], i + n[0].length) : -1;
|
|
}
|
|
function parseDayOfYear(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 3));
|
|
return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1;
|
|
}
|
|
function parseHour24(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
return n ? (d.H = +n[0], i + n[0].length) : -1;
|
|
}
|
|
function parseMinutes(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
return n ? (d.M = +n[0], i + n[0].length) : -1;
|
|
}
|
|
function parseSeconds(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
return n ? (d.S = +n[0], i + n[0].length) : -1;
|
|
}
|
|
function parseMilliseconds(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 3));
|
|
return n ? (d.L = +n[0], i + n[0].length) : -1;
|
|
}
|
|
function parseMicroseconds(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 6));
|
|
return n ? (d.L = Math.floor(n[0] / 1000), i + n[0].length) : -1;
|
|
}
|
|
function parseLiteralPercent(d, string, i) {
|
|
var n = percentRe.exec(string.slice(i, i + 1));
|
|
return n ? i + n[0].length : -1;
|
|
}
|
|
function parseUnixTimestamp(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i));
|
|
return n ? (d.Q = +n[0], i + n[0].length) : -1;
|
|
}
|
|
function parseUnixTimestampSeconds(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i));
|
|
return n ? (d.s = +n[0], i + n[0].length) : -1;
|
|
}
|
|
function formatDayOfMonth(d, p) {
|
|
return pad$1(d.getDate(), p, 2);
|
|
}
|
|
function formatHour24(d, p) {
|
|
return pad$1(d.getHours(), p, 2);
|
|
}
|
|
function formatHour12(d, p) {
|
|
return pad$1(d.getHours() % 12 || 12, p, 2);
|
|
}
|
|
function formatDayOfYear(d, p) {
|
|
return pad$1(1 + day.count(year(d), d), p, 3);
|
|
}
|
|
function formatMilliseconds(d, p) {
|
|
return pad$1(d.getMilliseconds(), p, 3);
|
|
}
|
|
function formatMicroseconds(d, p) {
|
|
return formatMilliseconds(d, p) + "000";
|
|
}
|
|
function formatMonthNumber(d, p) {
|
|
return pad$1(d.getMonth() + 1, p, 2);
|
|
}
|
|
function formatMinutes(d, p) {
|
|
return pad$1(d.getMinutes(), p, 2);
|
|
}
|
|
function formatSeconds(d, p) {
|
|
return pad$1(d.getSeconds(), p, 2);
|
|
}
|
|
function formatWeekdayNumberMonday(d) {
|
|
var day = d.getDay();
|
|
return 0 === day ? 7 : day;
|
|
}
|
|
function formatWeekNumberSunday(d, p) {
|
|
return pad$1(sunday.count(year(d) - 1, d), p, 2);
|
|
}
|
|
function dISO(d) {
|
|
var day = d.getDay();
|
|
return day >= 4 || 0 === day ? thursday(d) : thursday.ceil(d);
|
|
}
|
|
function formatWeekNumberISO(d, p) {
|
|
return d = dISO(d), pad$1(thursday.count(year(d), d) + (4 === year(d).getDay()), p, 2);
|
|
}
|
|
function formatWeekdayNumberSunday(d) {
|
|
return d.getDay();
|
|
}
|
|
function formatWeekNumberMonday(d, p) {
|
|
return pad$1(monday.count(year(d) - 1, d), p, 2);
|
|
}
|
|
function formatYear$1(d, p) {
|
|
return pad$1(d.getFullYear() % 100, p, 2);
|
|
}
|
|
function formatYearISO(d, p) {
|
|
return d = dISO(d), pad$1(d.getFullYear() % 100, p, 2);
|
|
}
|
|
function formatFullYear(d, p) {
|
|
return pad$1(d.getFullYear() % 10000, p, 4);
|
|
}
|
|
function formatFullYearISO(d, p) {
|
|
var day = d.getDay();
|
|
return d = day >= 4 || 0 === day ? thursday(d) : thursday.ceil(d), pad$1(d.getFullYear() % 10000, p, 4);
|
|
}
|
|
function formatZone(d) {
|
|
var z = d.getTimezoneOffset();
|
|
return (z > 0 ? "-" : (z *= -1, "+")) + pad$1(z / 60 | 0, "0", 2) + pad$1(z % 60, "0", 2);
|
|
}
|
|
function formatUTCDayOfMonth(d, p) {
|
|
return pad$1(d.getUTCDate(), p, 2);
|
|
}
|
|
function formatUTCHour24(d, p) {
|
|
return pad$1(d.getUTCHours(), p, 2);
|
|
}
|
|
function formatUTCHour12(d, p) {
|
|
return pad$1(d.getUTCHours() % 12 || 12, p, 2);
|
|
}
|
|
function formatUTCDayOfYear(d, p) {
|
|
return pad$1(1 + utcDay.count(utcYear(d), d), p, 3);
|
|
}
|
|
function formatUTCMilliseconds(d, p) {
|
|
return pad$1(d.getUTCMilliseconds(), p, 3);
|
|
}
|
|
function formatUTCMicroseconds(d, p) {
|
|
return formatUTCMilliseconds(d, p) + "000";
|
|
}
|
|
function formatUTCMonthNumber(d, p) {
|
|
return pad$1(d.getUTCMonth() + 1, p, 2);
|
|
}
|
|
function formatUTCMinutes(d, p) {
|
|
return pad$1(d.getUTCMinutes(), p, 2);
|
|
}
|
|
function formatUTCSeconds(d, p) {
|
|
return pad$1(d.getUTCSeconds(), p, 2);
|
|
}
|
|
function formatUTCWeekdayNumberMonday(d) {
|
|
var dow = d.getUTCDay();
|
|
return 0 === dow ? 7 : dow;
|
|
}
|
|
function formatUTCWeekNumberSunday(d, p) {
|
|
return pad$1(utcSunday.count(utcYear(d) - 1, d), p, 2);
|
|
}
|
|
function UTCdISO(d) {
|
|
var day = d.getUTCDay();
|
|
return day >= 4 || 0 === day ? utcThursday(d) : utcThursday.ceil(d);
|
|
}
|
|
function formatUTCWeekNumberISO(d, p) {
|
|
return d = UTCdISO(d), pad$1(utcThursday.count(utcYear(d), d) + (4 === utcYear(d).getUTCDay()), p, 2);
|
|
}
|
|
function formatUTCWeekdayNumberSunday(d) {
|
|
return d.getUTCDay();
|
|
}
|
|
function formatUTCWeekNumberMonday(d, p) {
|
|
return pad$1(utcMonday.count(utcYear(d) - 1, d), p, 2);
|
|
}
|
|
function formatUTCYear(d, p) {
|
|
return pad$1(d.getUTCFullYear() % 100, p, 2);
|
|
}
|
|
function formatUTCYearISO(d, p) {
|
|
return d = UTCdISO(d), pad$1(d.getUTCFullYear() % 100, p, 2);
|
|
}
|
|
function formatUTCFullYear(d, p) {
|
|
return pad$1(d.getUTCFullYear() % 10000, p, 4);
|
|
}
|
|
function formatUTCFullYearISO(d, p) {
|
|
var day = d.getUTCDay();
|
|
return d = day >= 4 || 0 === day ? utcThursday(d) : utcThursday.ceil(d), pad$1(d.getUTCFullYear() % 10000, p, 4);
|
|
}
|
|
function formatUTCZone() {
|
|
return "+0000";
|
|
}
|
|
function formatLiteralPercent() {
|
|
return "%";
|
|
}
|
|
function formatUnixTimestamp(d) {
|
|
return +d;
|
|
}
|
|
function formatUnixTimestampSeconds(d) {
|
|
return Math.floor(+d / 1000);
|
|
}
|
|
function defaultLocale$1(definition) {
|
|
return locale$1 = formatLocale$1(definition), exports1.timeFormat = locale$1.format, exports1.timeParse = locale$1.parse, exports1.utcFormat = locale$1.utcFormat, exports1.utcParse = locale$1.utcParse, locale$1;
|
|
}
|
|
defaultLocale$1({
|
|
dateTime: "%x, %X",
|
|
date: "%-m/%-d/%Y",
|
|
time: "%-I:%M:%S %p",
|
|
periods: [
|
|
"AM",
|
|
"PM"
|
|
],
|
|
days: [
|
|
"Sunday",
|
|
"Monday",
|
|
"Tuesday",
|
|
"Wednesday",
|
|
"Thursday",
|
|
"Friday",
|
|
"Saturday"
|
|
],
|
|
shortDays: [
|
|
"Sun",
|
|
"Mon",
|
|
"Tue",
|
|
"Wed",
|
|
"Thu",
|
|
"Fri",
|
|
"Sat"
|
|
],
|
|
months: [
|
|
"January",
|
|
"February",
|
|
"March",
|
|
"April",
|
|
"May",
|
|
"June",
|
|
"July",
|
|
"August",
|
|
"September",
|
|
"October",
|
|
"November",
|
|
"December"
|
|
],
|
|
shortMonths: [
|
|
"Jan",
|
|
"Feb",
|
|
"Mar",
|
|
"Apr",
|
|
"May",
|
|
"Jun",
|
|
"Jul",
|
|
"Aug",
|
|
"Sep",
|
|
"Oct",
|
|
"Nov",
|
|
"Dec"
|
|
]
|
|
});
|
|
var isoSpecifier = "%Y-%m-%dT%H:%M:%S.%LZ", formatIso = Date.prototype.toISOString ? function(date) {
|
|
return date.toISOString();
|
|
} : exports1.utcFormat(isoSpecifier), parseIso = +new Date("2000-01-01T00:00:00.000Z") ? function(string) {
|
|
var date = new Date(string);
|
|
return isNaN(date) ? null : date;
|
|
} : exports1.utcParse(isoSpecifier), durationMonth = 2592000000, durationYear = 31536000000;
|
|
function date$1(t) {
|
|
return new Date(t);
|
|
}
|
|
function number$3(t) {
|
|
return t instanceof Date ? +t : +new Date(+t);
|
|
}
|
|
function calendar(year, month, week, day, hour, minute, second, millisecond, format) {
|
|
var scale = continuous(), invert = scale.invert, domain = scale.domain, formatMillisecond = format(".%L"), formatSecond = format(":%S"), formatMinute = format("%I:%M"), formatHour = format("%I %p"), formatDay = format("%a %d"), formatWeek = format("%b %d"), formatMonth = format("%B"), formatYear = format("%Y"), tickIntervals = [
|
|
[
|
|
second,
|
|
1,
|
|
1000
|
|
],
|
|
[
|
|
second,
|
|
5,
|
|
5000
|
|
],
|
|
[
|
|
second,
|
|
15,
|
|
15000
|
|
],
|
|
[
|
|
second,
|
|
30,
|
|
30000
|
|
],
|
|
[
|
|
minute,
|
|
1,
|
|
60000
|
|
],
|
|
[
|
|
minute,
|
|
5,
|
|
300000
|
|
],
|
|
[
|
|
minute,
|
|
15,
|
|
900000
|
|
],
|
|
[
|
|
minute,
|
|
30,
|
|
1800000
|
|
],
|
|
[
|
|
hour,
|
|
1,
|
|
3600000
|
|
],
|
|
[
|
|
hour,
|
|
3,
|
|
10800000
|
|
],
|
|
[
|
|
hour,
|
|
6,
|
|
21600000
|
|
],
|
|
[
|
|
hour,
|
|
12,
|
|
43200000
|
|
],
|
|
[
|
|
day,
|
|
1,
|
|
86400000
|
|
],
|
|
[
|
|
day,
|
|
2,
|
|
172800000
|
|
],
|
|
[
|
|
week,
|
|
1,
|
|
604800000
|
|
],
|
|
[
|
|
month,
|
|
1,
|
|
durationMonth
|
|
],
|
|
[
|
|
month,
|
|
3,
|
|
3 * durationMonth
|
|
],
|
|
[
|
|
year,
|
|
1,
|
|
durationYear
|
|
]
|
|
];
|
|
function tickFormat(date) {
|
|
return (second(date) < date ? formatMillisecond : minute(date) < date ? formatSecond : hour(date) < date ? formatMinute : day(date) < date ? formatHour : month(date) < date ? week(date) < date ? formatDay : formatWeek : year(date) < date ? formatMonth : formatYear)(date);
|
|
}
|
|
function tickInterval(interval, start, stop) {
|
|
if (null == interval && (interval = 10), "number" == typeof interval) {
|
|
var step, target = Math.abs(stop - start) / interval, i = bisector(function(i) {
|
|
return i[2];
|
|
}).right(tickIntervals, target);
|
|
return i === tickIntervals.length ? (step = tickStep(start / durationYear, stop / durationYear, interval), interval = year) : i ? (step = (i = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i])[1], interval = i[0]) : (step = Math.max(tickStep(start, stop, interval), 1), interval = millisecond), interval.every(step);
|
|
}
|
|
return interval;
|
|
}
|
|
return scale.invert = function(y) {
|
|
return new Date(invert(y));
|
|
}, scale.domain = function(_) {
|
|
return arguments.length ? domain(Array.from(_, number$3)) : domain().map(date$1);
|
|
}, scale.ticks = function(interval) {
|
|
var t, d = domain(), t0 = d[0], t1 = d[d.length - 1], r = t1 < t0;
|
|
return r && (t = t0, t0 = t1, t1 = t), t = (t = tickInterval(interval, t0, t1)) ? t.range(t0, t1 + 1) : [], r ? t.reverse() : t;
|
|
}, scale.tickFormat = function(count, specifier) {
|
|
return null == specifier ? tickFormat : format(specifier);
|
|
}, scale.nice = function(interval) {
|
|
var d = domain();
|
|
return (interval = tickInterval(interval, d[0], d[d.length - 1])) ? domain(nice$1(d, interval)) : scale;
|
|
}, scale.copy = function() {
|
|
return copy(scale, calendar(year, month, week, day, hour, minute, second, millisecond, format));
|
|
}, scale;
|
|
}
|
|
function transformer$2() {
|
|
var t0, t1, k10, transform, unknown, x0 = 0, x1 = 1, interpolator = identity$6, clamp = !1;
|
|
function scale(x) {
|
|
return isNaN(x = +x) ? unknown : interpolator(0 === k10 ? 0.5 : (x = (transform(x) - t0) * k10, clamp ? Math.max(0, Math.min(1, x)) : x));
|
|
}
|
|
function range(interpolate) {
|
|
return function(_) {
|
|
var r0, r1;
|
|
return arguments.length ? ([r0, r1] = _, interpolator = interpolate(r0, r1), scale) : [
|
|
interpolator(0),
|
|
interpolator(1)
|
|
];
|
|
};
|
|
}
|
|
return scale.domain = function(_) {
|
|
return arguments.length ? ([x0, x1] = _, t0 = transform(x0 = +x0), t1 = transform(x1 = +x1), k10 = t0 === t1 ? 0 : 1 / (t1 - t0), scale) : [
|
|
x0,
|
|
x1
|
|
];
|
|
}, scale.clamp = function(_) {
|
|
return arguments.length ? (clamp = !!_, scale) : clamp;
|
|
}, scale.interpolator = function(_) {
|
|
return arguments.length ? (interpolator = _, scale) : interpolator;
|
|
}, scale.range = range(interpolate), scale.rangeRound = range(interpolateRound), scale.unknown = function(_) {
|
|
return arguments.length ? (unknown = _, scale) : unknown;
|
|
}, function(t) {
|
|
return transform = t, t0 = t(x0), t1 = t(x1), k10 = t0 === t1 ? 0 : 1 / (t1 - t0), scale;
|
|
};
|
|
}
|
|
function copy$1(source, target) {
|
|
return target.domain(source.domain()).interpolator(source.interpolator()).clamp(source.clamp()).unknown(source.unknown());
|
|
}
|
|
function sequentialPow() {
|
|
var scale = powish(transformer$2());
|
|
return scale.copy = function() {
|
|
return copy$1(scale, sequentialPow()).exponent(scale.exponent());
|
|
}, initInterpolator.apply(scale, arguments);
|
|
}
|
|
function transformer$3() {
|
|
var t0, t1, t2, k10, k21, transform, unknown, x0 = 0, x1 = 0.5, x2 = 1, s = 1, interpolator = identity$6, clamp = !1;
|
|
function scale(x) {
|
|
return isNaN(x = +x) ? unknown : (x = 0.5 + ((x = +transform(x)) - t1) * (s * x < s * t1 ? k10 : k21), interpolator(clamp ? Math.max(0, Math.min(1, x)) : x));
|
|
}
|
|
function range(interpolate) {
|
|
return function(_) {
|
|
var r0, r1, r2;
|
|
return arguments.length ? ([r0, r1, r2] = _, interpolator = piecewise(interpolate, [
|
|
r0,
|
|
r1,
|
|
r2
|
|
]), scale) : [
|
|
interpolator(0),
|
|
interpolator(0.5),
|
|
interpolator(1)
|
|
];
|
|
};
|
|
}
|
|
return scale.domain = function(_) {
|
|
return arguments.length ? ([x0, x1, x2] = _, t0 = transform(x0 = +x0), t1 = transform(x1 = +x1), t2 = transform(x2 = +x2), k10 = t0 === t1 ? 0 : 0.5 / (t1 - t0), k21 = t1 === t2 ? 0 : 0.5 / (t2 - t1), s = t1 < t0 ? -1 : 1, scale) : [
|
|
x0,
|
|
x1,
|
|
x2
|
|
];
|
|
}, scale.clamp = function(_) {
|
|
return arguments.length ? (clamp = !!_, scale) : clamp;
|
|
}, scale.interpolator = function(_) {
|
|
return arguments.length ? (interpolator = _, scale) : interpolator;
|
|
}, scale.range = range(interpolate), scale.rangeRound = range(interpolateRound), scale.unknown = function(_) {
|
|
return arguments.length ? (unknown = _, scale) : unknown;
|
|
}, function(t) {
|
|
return transform = t, t0 = t(x0), t1 = t(x1), t2 = t(x2), k10 = t0 === t1 ? 0 : 0.5 / (t1 - t0), k21 = t1 === t2 ? 0 : 0.5 / (t2 - t1), s = t1 < t0 ? -1 : 1, scale;
|
|
};
|
|
}
|
|
function divergingPow() {
|
|
var scale = powish(transformer$3());
|
|
return scale.copy = function() {
|
|
return copy$1(scale, divergingPow()).exponent(scale.exponent());
|
|
}, initInterpolator.apply(scale, arguments);
|
|
}
|
|
function colors(specifier) {
|
|
for(var n = specifier.length / 6 | 0, colors = Array(n), i = 0; i < n;)colors[i] = "#" + specifier.slice(6 * i, 6 * ++i);
|
|
return colors;
|
|
}
|
|
var category10 = colors("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf"), Accent = colors("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666"), Dark2 = colors("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666"), Paired = colors("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928"), Pastel1 = colors("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2"), Pastel2 = colors("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc"), Set1 = colors("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999"), Set2 = colors("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3"), Set3 = colors("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f"), Tableau10 = colors("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab"), ramp = (scheme)=>rgbBasis(scheme[scheme.length - 1]), scheme = [
|
|
,
|
|
,
|
|
,
|
|
].concat("d8b365f5f5f55ab4ac", "a6611adfc27d80cdc1018571", "a6611adfc27df5f5f580cdc1018571", "8c510ad8b365f6e8c3c7eae55ab4ac01665e", "8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e", "8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e", "8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e", "5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30", "5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30").map(colors), BrBG = ramp(scheme), scheme$1 = [
|
|
,
|
|
,
|
|
,
|
|
].concat("af8dc3f7f7f77fbf7b", "7b3294c2a5cfa6dba0008837", "7b3294c2a5cff7f7f7a6dba0008837", "762a83af8dc3e7d4e8d9f0d37fbf7b1b7837", "762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837", "762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837", "762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837", "40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b", "40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b").map(colors), PRGn = ramp(scheme$1), scheme$2 = [
|
|
,
|
|
,
|
|
,
|
|
].concat("e9a3c9f7f7f7a1d76a", "d01c8bf1b6dab8e1864dac26", "d01c8bf1b6daf7f7f7b8e1864dac26", "c51b7de9a3c9fde0efe6f5d0a1d76a4d9221", "c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221", "c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221", "c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221", "8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419", "8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419").map(colors), PiYG = ramp(scheme$2), scheme$3 = [
|
|
,
|
|
,
|
|
,
|
|
].concat("998ec3f7f7f7f1a340", "5e3c99b2abd2fdb863e66101", "5e3c99b2abd2f7f7f7fdb863e66101", "542788998ec3d8daebfee0b6f1a340b35806", "542788998ec3d8daebf7f7f7fee0b6f1a340b35806", "5427888073acb2abd2d8daebfee0b6fdb863e08214b35806", "5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806", "2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08", "2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08").map(colors), PuOr = ramp(scheme$3), scheme$4 = [
|
|
,
|
|
,
|
|
,
|
|
].concat("ef8a62f7f7f767a9cf", "ca0020f4a58292c5de0571b0", "ca0020f4a582f7f7f792c5de0571b0", "b2182bef8a62fddbc7d1e5f067a9cf2166ac", "b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac", "b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac", "b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac", "67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061", "67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061").map(colors), RdBu = ramp(scheme$4), scheme$5 = [
|
|
,
|
|
,
|
|
,
|
|
].concat("ef8a62ffffff999999", "ca0020f4a582bababa404040", "ca0020f4a582ffffffbababa404040", "b2182bef8a62fddbc7e0e0e09999994d4d4d", "b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d", "b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d", "b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d", "67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a", "67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a").map(colors), RdGy = ramp(scheme$5), scheme$6 = [
|
|
,
|
|
,
|
|
,
|
|
].concat("fc8d59ffffbf91bfdb", "d7191cfdae61abd9e92c7bb6", "d7191cfdae61ffffbfabd9e92c7bb6", "d73027fc8d59fee090e0f3f891bfdb4575b4", "d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4", "d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4", "d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4", "a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695", "a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695").map(colors), RdYlBu = ramp(scheme$6), scheme$7 = [
|
|
,
|
|
,
|
|
,
|
|
].concat("fc8d59ffffbf91cf60", "d7191cfdae61a6d96a1a9641", "d7191cfdae61ffffbfa6d96a1a9641", "d73027fc8d59fee08bd9ef8b91cf601a9850", "d73027fc8d59fee08bffffbfd9ef8b91cf601a9850", "d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850", "d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850", "a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837", "a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837").map(colors), RdYlGn = ramp(scheme$7), scheme$8 = [
|
|
,
|
|
,
|
|
,
|
|
].concat("fc8d59ffffbf99d594", "d7191cfdae61abdda42b83ba", "d7191cfdae61ffffbfabdda42b83ba", "d53e4ffc8d59fee08be6f59899d5943288bd", "d53e4ffc8d59fee08bffffbfe6f59899d5943288bd", "d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd", "d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd", "9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2", "9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2").map(colors), Spectral = ramp(scheme$8), scheme$9 = [
|
|
,
|
|
,
|
|
,
|
|
].concat("e5f5f999d8c92ca25f", "edf8fbb2e2e266c2a4238b45", "edf8fbb2e2e266c2a42ca25f006d2c", "edf8fbccece699d8c966c2a42ca25f006d2c", "edf8fbccece699d8c966c2a441ae76238b45005824", "f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824", "f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b").map(colors), BuGn = ramp(scheme$9), scheme$a = [
|
|
,
|
|
,
|
|
,
|
|
].concat("e0ecf49ebcda8856a7", "edf8fbb3cde38c96c688419d", "edf8fbb3cde38c96c68856a7810f7c", "edf8fbbfd3e69ebcda8c96c68856a7810f7c", "edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b", "f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b", "f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b").map(colors), BuPu = ramp(scheme$a), scheme$b = [
|
|
,
|
|
,
|
|
,
|
|
].concat("e0f3dba8ddb543a2ca", "f0f9e8bae4bc7bccc42b8cbe", "f0f9e8bae4bc7bccc443a2ca0868ac", "f0f9e8ccebc5a8ddb57bccc443a2ca0868ac", "f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e", "f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e", "f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081").map(colors), GnBu = ramp(scheme$b), scheme$c = [
|
|
,
|
|
,
|
|
,
|
|
].concat("fee8c8fdbb84e34a33", "fef0d9fdcc8afc8d59d7301f", "fef0d9fdcc8afc8d59e34a33b30000", "fef0d9fdd49efdbb84fc8d59e34a33b30000", "fef0d9fdd49efdbb84fc8d59ef6548d7301f990000", "fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000", "fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000").map(colors), OrRd = ramp(scheme$c), scheme$d = [
|
|
,
|
|
,
|
|
,
|
|
].concat("ece2f0a6bddb1c9099", "f6eff7bdc9e167a9cf02818a", "f6eff7bdc9e167a9cf1c9099016c59", "f6eff7d0d1e6a6bddb67a9cf1c9099016c59", "f6eff7d0d1e6a6bddb67a9cf3690c002818a016450", "fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450", "fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636").map(colors), PuBuGn = ramp(scheme$d), scheme$e = [
|
|
,
|
|
,
|
|
,
|
|
].concat("ece7f2a6bddb2b8cbe", "f1eef6bdc9e174a9cf0570b0", "f1eef6bdc9e174a9cf2b8cbe045a8d", "f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d", "f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b", "fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b", "fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858").map(colors), PuBu = ramp(scheme$e), scheme$f = [
|
|
,
|
|
,
|
|
,
|
|
].concat("e7e1efc994c7dd1c77", "f1eef6d7b5d8df65b0ce1256", "f1eef6d7b5d8df65b0dd1c77980043", "f1eef6d4b9dac994c7df65b0dd1c77980043", "f1eef6d4b9dac994c7df65b0e7298ace125691003f", "f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f", "f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f").map(colors), PuRd = ramp(scheme$f), scheme$g = [
|
|
,
|
|
,
|
|
,
|
|
].concat("fde0ddfa9fb5c51b8a", "feebe2fbb4b9f768a1ae017e", "feebe2fbb4b9f768a1c51b8a7a0177", "feebe2fcc5c0fa9fb5f768a1c51b8a7a0177", "feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177", "fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177", "fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a").map(colors), RdPu = ramp(scheme$g), scheme$h = [
|
|
,
|
|
,
|
|
,
|
|
].concat("edf8b17fcdbb2c7fb8", "ffffcca1dab441b6c4225ea8", "ffffcca1dab441b6c42c7fb8253494", "ffffccc7e9b47fcdbb41b6c42c7fb8253494", "ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84", "ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84", "ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58").map(colors), YlGnBu = ramp(scheme$h), scheme$i = [
|
|
,
|
|
,
|
|
,
|
|
].concat("f7fcb9addd8e31a354", "ffffccc2e69978c679238443", "ffffccc2e69978c67931a354006837", "ffffccd9f0a3addd8e78c67931a354006837", "ffffccd9f0a3addd8e78c67941ab5d238443005a32", "ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32", "ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529").map(colors), YlGn = ramp(scheme$i), scheme$j = [
|
|
,
|
|
,
|
|
,
|
|
].concat("fff7bcfec44fd95f0e", "ffffd4fed98efe9929cc4c02", "ffffd4fed98efe9929d95f0e993404", "ffffd4fee391fec44ffe9929d95f0e993404", "ffffd4fee391fec44ffe9929ec7014cc4c028c2d04", "ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04", "ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506").map(colors), YlOrBr = ramp(scheme$j), scheme$k = [
|
|
,
|
|
,
|
|
,
|
|
].concat("ffeda0feb24cf03b20", "ffffb2fecc5cfd8d3ce31a1c", "ffffb2fecc5cfd8d3cf03b20bd0026", "ffffb2fed976feb24cfd8d3cf03b20bd0026", "ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026", "ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026", "ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026").map(colors), YlOrRd = ramp(scheme$k), scheme$l = [
|
|
,
|
|
,
|
|
,
|
|
].concat("deebf79ecae13182bd", "eff3ffbdd7e76baed62171b5", "eff3ffbdd7e76baed63182bd08519c", "eff3ffc6dbef9ecae16baed63182bd08519c", "eff3ffc6dbef9ecae16baed64292c62171b5084594", "f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594", "f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(colors), Blues = ramp(scheme$l), scheme$m = [
|
|
,
|
|
,
|
|
,
|
|
].concat("e5f5e0a1d99b31a354", "edf8e9bae4b374c476238b45", "edf8e9bae4b374c47631a354006d2c", "edf8e9c7e9c0a1d99b74c47631a354006d2c", "edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32", "f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32", "f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b").map(colors), Greens = ramp(scheme$m), scheme$n = [
|
|
,
|
|
,
|
|
,
|
|
].concat("f0f0f0bdbdbd636363", "f7f7f7cccccc969696525252", "f7f7f7cccccc969696636363252525", "f7f7f7d9d9d9bdbdbd969696636363252525", "f7f7f7d9d9d9bdbdbd969696737373525252252525", "fffffff0f0f0d9d9d9bdbdbd969696737373525252252525", "fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(colors), Greys = ramp(scheme$n), scheme$o = [
|
|
,
|
|
,
|
|
,
|
|
].concat("efedf5bcbddc756bb1", "f2f0f7cbc9e29e9ac86a51a3", "f2f0f7cbc9e29e9ac8756bb154278f", "f2f0f7dadaebbcbddc9e9ac8756bb154278f", "f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486", "fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486", "fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d").map(colors), Purples = ramp(scheme$o), scheme$p = [
|
|
,
|
|
,
|
|
,
|
|
].concat("fee0d2fc9272de2d26", "fee5d9fcae91fb6a4acb181d", "fee5d9fcae91fb6a4ade2d26a50f15", "fee5d9fcbba1fc9272fb6a4ade2d26a50f15", "fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d", "fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d", "fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(colors), Reds = ramp(scheme$p), scheme$q = [
|
|
,
|
|
,
|
|
,
|
|
].concat("fee6cefdae6be6550d", "feeddefdbe85fd8d3cd94701", "feeddefdbe85fd8d3ce6550da63603", "feeddefdd0a2fdae6bfd8d3ce6550da63603", "feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04", "fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04", "fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704").map(colors), Oranges = ramp(scheme$q), cubehelix$3 = cubehelixLong(cubehelix(300, 0.5, 0.0), cubehelix(-240, 0.5, 1.0)), warm = cubehelixLong(cubehelix(-100, 0.75, 0.35), cubehelix(80, 1.50, 0.8)), cool = cubehelixLong(cubehelix(260, 0.75, 0.35), cubehelix(80, 1.50, 0.8)), c$1 = cubehelix(), c$2 = rgb(), pi_1_3 = Math.PI / 3, pi_2_3 = 2 * Math.PI / 3;
|
|
function ramp$1(range) {
|
|
var n = range.length;
|
|
return function(t) {
|
|
return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))];
|
|
};
|
|
}
|
|
var viridis = ramp$1(colors("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")), magma = ramp$1(colors("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")), inferno = ramp$1(colors("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")), plasma = ramp$1(colors("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"));
|
|
function constant$a(x) {
|
|
return function() {
|
|
return x;
|
|
};
|
|
}
|
|
var abs$3 = Math.abs, atan2$1 = Math.atan2, cos$2 = Math.cos, max$3 = Math.max, min$2 = Math.min, sin$2 = Math.sin, sqrt$2 = Math.sqrt, pi$4 = Math.PI, halfPi$3 = pi$4 / 2, tau$5 = 2 * pi$4;
|
|
function asin$1(x) {
|
|
return x >= 1 ? halfPi$3 : x <= -1 ? -halfPi$3 : Math.asin(x);
|
|
}
|
|
function arcInnerRadius(d) {
|
|
return d.innerRadius;
|
|
}
|
|
function arcOuterRadius(d) {
|
|
return d.outerRadius;
|
|
}
|
|
function arcStartAngle(d) {
|
|
return d.startAngle;
|
|
}
|
|
function arcEndAngle(d) {
|
|
return d.endAngle;
|
|
}
|
|
function arcPadAngle(d) {
|
|
return d && d.padAngle;
|
|
}
|
|
function cornerTangents(x0, y0, x1, y1, r1, rc, cw) {
|
|
var x01 = x0 - x1, y01 = y0 - y1, lo = (cw ? rc : -rc) / sqrt$2(x01 * x01 + y01 * y01), ox = lo * y01, oy = -lo * x01, x11 = x0 + ox, y11 = y0 + oy, x10 = x1 + ox, y10 = y1 + oy, x00 = (x11 + x10) / 2, y00 = (y11 + y10) / 2, dx = x10 - x11, dy = y10 - y11, d2 = dx * dx + dy * dy, r = r1 - rc, D = x11 * y10 - x10 * y11, d = (dy < 0 ? -1 : 1) * sqrt$2(max$3(0, r * r * d2 - D * D)), cx0 = (D * dy - dx * d) / d2, cy0 = (-D * dx - dy * d) / d2, cx1 = (D * dy + dx * d) / d2, cy1 = (-D * dx + dy * d) / d2, dx0 = cx0 - x00, dy0 = cy0 - y00, dx1 = cx1 - x00, dy1 = cy1 - y00;
|
|
return dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1 && (cx0 = cx1, cy0 = cy1), {
|
|
cx: cx0,
|
|
cy: cy0,
|
|
x01: -ox,
|
|
y01: -oy,
|
|
x11: cx0 * (r1 / r - 1),
|
|
y11: cy0 * (r1 / r - 1)
|
|
};
|
|
}
|
|
var slice$4 = Array.prototype.slice;
|
|
function array$5(x) {
|
|
return "object" == typeof x && "length" in x ? x : Array.from(x);
|
|
}
|
|
function Linear(context) {
|
|
this._context = context;
|
|
}
|
|
function curveLinear(context) {
|
|
return new Linear(context);
|
|
}
|
|
function x$3(p) {
|
|
return p[0];
|
|
}
|
|
function y$3(p) {
|
|
return p[1];
|
|
}
|
|
function line(x, y) {
|
|
var defined = constant$a(!0), context = null, curve = curveLinear, output = null;
|
|
function line(data) {
|
|
var i, d, buffer, n = (data = array$5(data)).length, defined0 = !1;
|
|
for(null == context && (output = curve(buffer = path())), i = 0; i <= n; ++i)!(i < n && defined(d = data[i], i, data)) === defined0 && ((defined0 = !defined0) ? output.lineStart() : output.lineEnd()), defined0 && output.point(+x(d, i, data), +y(d, i, data));
|
|
if (buffer) return output = null, buffer + "" || null;
|
|
}
|
|
return x = "function" == typeof x ? x : void 0 === x ? x$3 : constant$a(x), y = "function" == typeof y ? y : void 0 === y ? y$3 : constant$a(y), line.x = function(_) {
|
|
return arguments.length ? (x = "function" == typeof _ ? _ : constant$a(+_), line) : x;
|
|
}, line.y = function(_) {
|
|
return arguments.length ? (y = "function" == typeof _ ? _ : constant$a(+_), line) : y;
|
|
}, line.defined = function(_) {
|
|
return arguments.length ? (defined = "function" == typeof _ ? _ : constant$a(!!_), line) : defined;
|
|
}, line.curve = function(_) {
|
|
return arguments.length ? (curve = _, null != context && (output = curve(context)), line) : curve;
|
|
}, line.context = function(_) {
|
|
return arguments.length ? (null == _ ? context = output = null : output = curve(context = _), line) : context;
|
|
}, line;
|
|
}
|
|
function area$3(x0, y0, y1) {
|
|
var x1 = null, defined = constant$a(!0), context = null, curve = curveLinear, output = null;
|
|
function area(data) {
|
|
var i, j, k, d, buffer, n = (data = array$5(data)).length, defined0 = !1, x0z = Array(n), y0z = Array(n);
|
|
for(null == context && (output = curve(buffer = path())), i = 0; i <= n; ++i){
|
|
if (!(i < n && defined(d = data[i], i, data)) === defined0) {
|
|
if (defined0 = !defined0) j = i, output.areaStart(), output.lineStart();
|
|
else {
|
|
for(output.lineEnd(), output.lineStart(), k = i - 1; k >= j; --k)output.point(x0z[k], y0z[k]);
|
|
output.lineEnd(), output.areaEnd();
|
|
}
|
|
}
|
|
defined0 && (x0z[i] = +x0(d, i, data), y0z[i] = +y0(d, i, data), output.point(x1 ? +x1(d, i, data) : x0z[i], y1 ? +y1(d, i, data) : y0z[i]));
|
|
}
|
|
if (buffer) return output = null, buffer + "" || null;
|
|
}
|
|
function arealine() {
|
|
return line().defined(defined).curve(curve).context(context);
|
|
}
|
|
return x0 = "function" == typeof x0 ? x0 : void 0 === x0 ? x$3 : constant$a(+x0), y0 = "function" == typeof y0 ? y0 : void 0 === y0 ? constant$a(0) : constant$a(+y0), y1 = "function" == typeof y1 ? y1 : void 0 === y1 ? y$3 : constant$a(+y1), area.x = function(_) {
|
|
return arguments.length ? (x0 = "function" == typeof _ ? _ : constant$a(+_), x1 = null, area) : x0;
|
|
}, area.x0 = function(_) {
|
|
return arguments.length ? (x0 = "function" == typeof _ ? _ : constant$a(+_), area) : x0;
|
|
}, area.x1 = function(_) {
|
|
return arguments.length ? (x1 = null == _ ? null : "function" == typeof _ ? _ : constant$a(+_), area) : x1;
|
|
}, area.y = function(_) {
|
|
return arguments.length ? (y0 = "function" == typeof _ ? _ : constant$a(+_), y1 = null, area) : y0;
|
|
}, area.y0 = function(_) {
|
|
return arguments.length ? (y0 = "function" == typeof _ ? _ : constant$a(+_), area) : y0;
|
|
}, area.y1 = function(_) {
|
|
return arguments.length ? (y1 = null == _ ? null : "function" == typeof _ ? _ : constant$a(+_), area) : y1;
|
|
}, area.lineX0 = area.lineY0 = function() {
|
|
return arealine().x(x0).y(y0);
|
|
}, area.lineY1 = function() {
|
|
return arealine().x(x0).y(y1);
|
|
}, area.lineX1 = function() {
|
|
return arealine().x(x1).y(y0);
|
|
}, area.defined = function(_) {
|
|
return arguments.length ? (defined = "function" == typeof _ ? _ : constant$a(!!_), area) : defined;
|
|
}, area.curve = function(_) {
|
|
return arguments.length ? (curve = _, null != context && (output = curve(context)), area) : curve;
|
|
}, area.context = function(_) {
|
|
return arguments.length ? (null == _ ? context = output = null : output = curve(context = _), area) : context;
|
|
}, area;
|
|
}
|
|
function descending$1(a, b) {
|
|
return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
|
|
}
|
|
function identity$8(d) {
|
|
return d;
|
|
}
|
|
Linear.prototype = {
|
|
areaStart: function() {
|
|
this._line = 0;
|
|
},
|
|
areaEnd: function() {
|
|
this._line = NaN;
|
|
},
|
|
lineStart: function() {
|
|
this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
(this._line || 0 !== this._line && 1 === this._point) && this._context.closePath(), this._line = 1 - this._line;
|
|
},
|
|
point: function(x, y) {
|
|
switch(x = +x, y = +y, this._point){
|
|
case 0:
|
|
this._point = 1, this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y);
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
default:
|
|
this._context.lineTo(x, y);
|
|
}
|
|
}
|
|
};
|
|
var curveRadialLinear = curveRadial(curveLinear);
|
|
function Radial(curve) {
|
|
this._curve = curve;
|
|
}
|
|
function curveRadial(curve) {
|
|
function radial(context) {
|
|
return new Radial(curve(context));
|
|
}
|
|
return radial._curve = curve, radial;
|
|
}
|
|
function lineRadial(l) {
|
|
var c = l.curve;
|
|
return l.angle = l.x, delete l.x, l.radius = l.y, delete l.y, l.curve = function(_) {
|
|
return arguments.length ? c(curveRadial(_)) : c()._curve;
|
|
}, l;
|
|
}
|
|
function lineRadial$1() {
|
|
return lineRadial(line().curve(curveRadialLinear));
|
|
}
|
|
function areaRadial() {
|
|
var a = area$3().curve(curveRadialLinear), c = a.curve, x0 = a.lineX0, x1 = a.lineX1, y0 = a.lineY0, y1 = a.lineY1;
|
|
return a.angle = a.x, delete a.x, a.startAngle = a.x0, delete a.x0, a.endAngle = a.x1, delete a.x1, a.radius = a.y, delete a.y, a.innerRadius = a.y0, delete a.y0, a.outerRadius = a.y1, delete a.y1, a.lineStartAngle = function() {
|
|
return lineRadial(x0());
|
|
}, delete a.lineX0, a.lineEndAngle = function() {
|
|
return lineRadial(x1());
|
|
}, delete a.lineX1, a.lineInnerRadius = function() {
|
|
return lineRadial(y0());
|
|
}, delete a.lineY0, a.lineOuterRadius = function() {
|
|
return lineRadial(y1());
|
|
}, delete a.lineY1, a.curve = function(_) {
|
|
return arguments.length ? c(curveRadial(_)) : c()._curve;
|
|
}, a;
|
|
}
|
|
function pointRadial(x, y) {
|
|
return [
|
|
(y = +y) * Math.cos(x -= Math.PI / 2),
|
|
y * Math.sin(x)
|
|
];
|
|
}
|
|
function linkSource(d) {
|
|
return d.source;
|
|
}
|
|
function linkTarget(d) {
|
|
return d.target;
|
|
}
|
|
function link$2(curve) {
|
|
var source = linkSource, target = linkTarget, x = x$3, y = y$3, context = null;
|
|
function link() {
|
|
var buffer, argv = slice$4.call(arguments), s = source.apply(this, argv), t = target.apply(this, argv);
|
|
if (context || (context = buffer = path()), curve(context, +x.apply(this, (argv[0] = s, argv)), +y.apply(this, argv), +x.apply(this, (argv[0] = t, argv)), +y.apply(this, argv)), buffer) return context = null, buffer + "" || null;
|
|
}
|
|
return link.source = function(_) {
|
|
return arguments.length ? (source = _, link) : source;
|
|
}, link.target = function(_) {
|
|
return arguments.length ? (target = _, link) : target;
|
|
}, link.x = function(_) {
|
|
return arguments.length ? (x = "function" == typeof _ ? _ : constant$a(+_), link) : x;
|
|
}, link.y = function(_) {
|
|
return arguments.length ? (y = "function" == typeof _ ? _ : constant$a(+_), link) : y;
|
|
}, link.context = function(_) {
|
|
return arguments.length ? (context = null == _ ? null : _, link) : context;
|
|
}, link;
|
|
}
|
|
function curveHorizontal(context, x0, y0, x1, y1) {
|
|
context.moveTo(x0, y0), context.bezierCurveTo(x0 = (x0 + x1) / 2, y0, x0, y1, x1, y1);
|
|
}
|
|
function curveVertical(context, x0, y0, x1, y1) {
|
|
context.moveTo(x0, y0), context.bezierCurveTo(x0, y0 = (y0 + y1) / 2, x1, y0, x1, y1);
|
|
}
|
|
function curveRadial$1(context, x0, y0, x1, y1) {
|
|
var p0 = pointRadial(x0, y0), p1 = pointRadial(x0, y0 = (y0 + y1) / 2), p2 = pointRadial(x1, y0), p3 = pointRadial(x1, y1);
|
|
context.moveTo(p0[0], p0[1]), context.bezierCurveTo(p1[0], p1[1], p2[0], p2[1], p3[0], p3[1]);
|
|
}
|
|
Radial.prototype = {
|
|
areaStart: function() {
|
|
this._curve.areaStart();
|
|
},
|
|
areaEnd: function() {
|
|
this._curve.areaEnd();
|
|
},
|
|
lineStart: function() {
|
|
this._curve.lineStart();
|
|
},
|
|
lineEnd: function() {
|
|
this._curve.lineEnd();
|
|
},
|
|
point: function(a, r) {
|
|
this._curve.point(r * Math.sin(a), -(r * Math.cos(a)));
|
|
}
|
|
};
|
|
var circle$2 = {
|
|
draw: function(context, size) {
|
|
var r = Math.sqrt(size / pi$4);
|
|
context.moveTo(r, 0), context.arc(0, 0, r, 0, tau$5);
|
|
}
|
|
}, cross$2 = {
|
|
draw: function(context, size) {
|
|
var r = Math.sqrt(size / 5) / 2;
|
|
context.moveTo(-3 * r, -r), context.lineTo(-r, -r), context.lineTo(-r, -3 * r), context.lineTo(r, -3 * r), context.lineTo(r, -r), context.lineTo(3 * r, -r), context.lineTo(3 * r, r), context.lineTo(r, r), context.lineTo(r, 3 * r), context.lineTo(-r, 3 * r), context.lineTo(-r, r), context.lineTo(-3 * r, r), context.closePath();
|
|
}
|
|
}, tan30 = Math.sqrt(1 / 3), tan30_2 = 2 * tan30, diamond = {
|
|
draw: function(context, size) {
|
|
var y = Math.sqrt(size / tan30_2), x = y * tan30;
|
|
context.moveTo(0, -y), context.lineTo(x, 0), context.lineTo(0, y), context.lineTo(-x, 0), context.closePath();
|
|
}
|
|
}, kr = Math.sin(pi$4 / 10) / Math.sin(7 * pi$4 / 10), kx = Math.sin(tau$5 / 10) * kr, ky = -Math.cos(tau$5 / 10) * kr, star = {
|
|
draw: function(context, size) {
|
|
var r = Math.sqrt(0.89081309152928522810 * size), x = kx * r, y = ky * r;
|
|
context.moveTo(0, -r), context.lineTo(x, y);
|
|
for(var i = 1; i < 5; ++i){
|
|
var a = tau$5 * i / 5, c = Math.cos(a), s = Math.sin(a);
|
|
context.lineTo(s * r, -c * r), context.lineTo(c * x - s * y, s * x + c * y);
|
|
}
|
|
context.closePath();
|
|
}
|
|
}, square$1 = {
|
|
draw: function(context, size) {
|
|
var w = Math.sqrt(size), x = -w / 2;
|
|
context.rect(x, x, w, w);
|
|
}
|
|
}, sqrt3 = Math.sqrt(3), triangle = {
|
|
draw: function(context, size) {
|
|
var y = -Math.sqrt(size / (3 * sqrt3));
|
|
context.moveTo(0, 2 * y), context.lineTo(-sqrt3 * y, -y), context.lineTo(sqrt3 * y, -y), context.closePath();
|
|
}
|
|
}, s = Math.sqrt(3) / 2, k = 1 / Math.sqrt(12), a$1 = (k / 2 + 1) * 3, wye = {
|
|
draw: function(context, size) {
|
|
var r = Math.sqrt(size / a$1), x0 = r / 2, y0 = r * k, y1 = r * k + r, x2 = -x0;
|
|
context.moveTo(x0, y0), context.lineTo(x0, y1), context.lineTo(x2, y1), context.lineTo(-0.5 * x0 - s * y0, s * x0 + -0.5 * y0), context.lineTo(-0.5 * x0 - s * y1, s * x0 + -0.5 * y1), context.lineTo(-0.5 * x2 - s * y1, s * x2 + -0.5 * y1), context.lineTo(-0.5 * x0 + s * y0, -0.5 * y0 - s * x0), context.lineTo(-0.5 * x0 + s * y1, -0.5 * y1 - s * x0), context.lineTo(-0.5 * x2 + s * y1, -0.5 * y1 - s * x2), context.closePath();
|
|
}
|
|
};
|
|
function noop$3() {}
|
|
function point$1(that, x, y) {
|
|
that._context.bezierCurveTo((2 * that._x0 + that._x1) / 3, (2 * that._y0 + that._y1) / 3, (that._x0 + 2 * that._x1) / 3, (that._y0 + 2 * that._y1) / 3, (that._x0 + 4 * that._x1 + x) / 6, (that._y0 + 4 * that._y1 + y) / 6);
|
|
}
|
|
function Basis(context) {
|
|
this._context = context;
|
|
}
|
|
function BasisClosed(context) {
|
|
this._context = context;
|
|
}
|
|
function BasisOpen(context) {
|
|
this._context = context;
|
|
}
|
|
function Bundle(context, beta) {
|
|
this._basis = new Basis(context), this._beta = beta;
|
|
}
|
|
Basis.prototype = {
|
|
areaStart: function() {
|
|
this._line = 0;
|
|
},
|
|
areaEnd: function() {
|
|
this._line = NaN;
|
|
},
|
|
lineStart: function() {
|
|
this._x0 = this._x1 = this._y0 = this._y1 = NaN, this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
switch(this._point){
|
|
case 3:
|
|
point$1(this, this._x1, this._y1);
|
|
case 2:
|
|
this._context.lineTo(this._x1, this._y1);
|
|
}
|
|
(this._line || 0 !== this._line && 1 === this._point) && this._context.closePath(), this._line = 1 - this._line;
|
|
},
|
|
point: function(x, y) {
|
|
switch(x = +x, y = +y, this._point){
|
|
case 0:
|
|
this._point = 1, this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y);
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
break;
|
|
case 2:
|
|
this._point = 3, this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6);
|
|
default:
|
|
point$1(this, x, y);
|
|
}
|
|
this._x0 = this._x1, this._x1 = x, this._y0 = this._y1, this._y1 = y;
|
|
}
|
|
}, BasisClosed.prototype = {
|
|
areaStart: noop$3,
|
|
areaEnd: noop$3,
|
|
lineStart: function() {
|
|
this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN, this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
switch(this._point){
|
|
case 1:
|
|
this._context.moveTo(this._x2, this._y2), this._context.closePath();
|
|
break;
|
|
case 2:
|
|
this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3), this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3), this._context.closePath();
|
|
break;
|
|
case 3:
|
|
this.point(this._x2, this._y2), this.point(this._x3, this._y3), this.point(this._x4, this._y4);
|
|
}
|
|
},
|
|
point: function(x, y) {
|
|
switch(x = +x, y = +y, this._point){
|
|
case 0:
|
|
this._point = 1, this._x2 = x, this._y2 = y;
|
|
break;
|
|
case 1:
|
|
this._point = 2, this._x3 = x, this._y3 = y;
|
|
break;
|
|
case 2:
|
|
this._point = 3, this._x4 = x, this._y4 = y, this._context.moveTo((this._x0 + 4 * this._x1 + x) / 6, (this._y0 + 4 * this._y1 + y) / 6);
|
|
break;
|
|
default:
|
|
point$1(this, x, y);
|
|
}
|
|
this._x0 = this._x1, this._x1 = x, this._y0 = this._y1, this._y1 = y;
|
|
}
|
|
}, BasisOpen.prototype = {
|
|
areaStart: function() {
|
|
this._line = 0;
|
|
},
|
|
areaEnd: function() {
|
|
this._line = NaN;
|
|
},
|
|
lineStart: function() {
|
|
this._x0 = this._x1 = this._y0 = this._y1 = NaN, this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
(this._line || 0 !== this._line && 3 === this._point) && this._context.closePath(), this._line = 1 - this._line;
|
|
},
|
|
point: function(x, y) {
|
|
switch(x = +x, y = +y, this._point){
|
|
case 0:
|
|
this._point = 1;
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
break;
|
|
case 2:
|
|
this._point = 3;
|
|
var x0 = (this._x0 + 4 * this._x1 + x) / 6, y0 = (this._y0 + 4 * this._y1 + y) / 6;
|
|
this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0);
|
|
break;
|
|
case 3:
|
|
this._point = 4;
|
|
default:
|
|
point$1(this, x, y);
|
|
}
|
|
this._x0 = this._x1, this._x1 = x, this._y0 = this._y1, this._y1 = y;
|
|
}
|
|
}, Bundle.prototype = {
|
|
lineStart: function() {
|
|
this._x = [], this._y = [], this._basis.lineStart();
|
|
},
|
|
lineEnd: function() {
|
|
var x = this._x, y = this._y, j = x.length - 1;
|
|
if (j > 0) for(var t, x0 = x[0], y0 = y[0], dx = x[j] - x0, dy = y[j] - y0, i = -1; ++i <= j;)t = i / j, this._basis.point(this._beta * x[i] + (1 - this._beta) * (x0 + t * dx), this._beta * y[i] + (1 - this._beta) * (y0 + t * dy));
|
|
this._x = this._y = null, this._basis.lineEnd();
|
|
},
|
|
point: function(x, y) {
|
|
this._x.push(+x), this._y.push(+y);
|
|
}
|
|
};
|
|
var bundle = function custom(beta) {
|
|
function bundle(context) {
|
|
return 1 === beta ? new Basis(context) : new Bundle(context, beta);
|
|
}
|
|
return bundle.beta = function(beta) {
|
|
return custom(+beta);
|
|
}, bundle;
|
|
}(0.85);
|
|
function point$2(that, x, y) {
|
|
that._context.bezierCurveTo(that._x1 + that._k * (that._x2 - that._x0), that._y1 + that._k * (that._y2 - that._y0), that._x2 + that._k * (that._x1 - x), that._y2 + that._k * (that._y1 - y), that._x2, that._y2);
|
|
}
|
|
function Cardinal(context, tension) {
|
|
this._context = context, this._k = (1 - tension) / 6;
|
|
}
|
|
Cardinal.prototype = {
|
|
areaStart: function() {
|
|
this._line = 0;
|
|
},
|
|
areaEnd: function() {
|
|
this._line = NaN;
|
|
},
|
|
lineStart: function() {
|
|
this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
switch(this._point){
|
|
case 2:
|
|
this._context.lineTo(this._x2, this._y2);
|
|
break;
|
|
case 3:
|
|
point$2(this, this._x1, this._y1);
|
|
}
|
|
(this._line || 0 !== this._line && 1 === this._point) && this._context.closePath(), this._line = 1 - this._line;
|
|
},
|
|
point: function(x, y) {
|
|
switch(x = +x, y = +y, this._point){
|
|
case 0:
|
|
this._point = 1, this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y);
|
|
break;
|
|
case 1:
|
|
this._point = 2, this._x1 = x, this._y1 = y;
|
|
break;
|
|
case 2:
|
|
this._point = 3;
|
|
default:
|
|
point$2(this, x, y);
|
|
}
|
|
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x, this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
|
}
|
|
};
|
|
var cardinal = function custom(tension) {
|
|
function cardinal(context) {
|
|
return new Cardinal(context, tension);
|
|
}
|
|
return cardinal.tension = function(tension) {
|
|
return custom(+tension);
|
|
}, cardinal;
|
|
}(0);
|
|
function CardinalClosed(context, tension) {
|
|
this._context = context, this._k = (1 - tension) / 6;
|
|
}
|
|
CardinalClosed.prototype = {
|
|
areaStart: noop$3,
|
|
areaEnd: noop$3,
|
|
lineStart: function() {
|
|
this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN, this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
switch(this._point){
|
|
case 1:
|
|
this._context.moveTo(this._x3, this._y3), this._context.closePath();
|
|
break;
|
|
case 2:
|
|
this._context.lineTo(this._x3, this._y3), this._context.closePath();
|
|
break;
|
|
case 3:
|
|
this.point(this._x3, this._y3), this.point(this._x4, this._y4), this.point(this._x5, this._y5);
|
|
}
|
|
},
|
|
point: function(x, y) {
|
|
switch(x = +x, y = +y, this._point){
|
|
case 0:
|
|
this._point = 1, this._x3 = x, this._y3 = y;
|
|
break;
|
|
case 1:
|
|
this._point = 2, this._context.moveTo(this._x4 = x, this._y4 = y);
|
|
break;
|
|
case 2:
|
|
this._point = 3, this._x5 = x, this._y5 = y;
|
|
break;
|
|
default:
|
|
point$2(this, x, y);
|
|
}
|
|
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x, this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
|
}
|
|
};
|
|
var cardinalClosed = function custom(tension) {
|
|
function cardinal(context) {
|
|
return new CardinalClosed(context, tension);
|
|
}
|
|
return cardinal.tension = function(tension) {
|
|
return custom(+tension);
|
|
}, cardinal;
|
|
}(0);
|
|
function CardinalOpen(context, tension) {
|
|
this._context = context, this._k = (1 - tension) / 6;
|
|
}
|
|
CardinalOpen.prototype = {
|
|
areaStart: function() {
|
|
this._line = 0;
|
|
},
|
|
areaEnd: function() {
|
|
this._line = NaN;
|
|
},
|
|
lineStart: function() {
|
|
this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
(this._line || 0 !== this._line && 3 === this._point) && this._context.closePath(), this._line = 1 - this._line;
|
|
},
|
|
point: function(x, y) {
|
|
switch(x = +x, y = +y, this._point){
|
|
case 0:
|
|
this._point = 1;
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
break;
|
|
case 2:
|
|
this._point = 3, this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2);
|
|
break;
|
|
case 3:
|
|
this._point = 4;
|
|
default:
|
|
point$2(this, x, y);
|
|
}
|
|
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x, this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
|
}
|
|
};
|
|
var cardinalOpen = function custom(tension) {
|
|
function cardinal(context) {
|
|
return new CardinalOpen(context, tension);
|
|
}
|
|
return cardinal.tension = function(tension) {
|
|
return custom(+tension);
|
|
}, cardinal;
|
|
}(0);
|
|
function point$3(that, x, y) {
|
|
var x1 = that._x1, y1 = that._y1, x2 = that._x2, y2 = that._y2;
|
|
if (that._l01_a > 1e-12) {
|
|
var a = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a, n = 3 * that._l01_a * (that._l01_a + that._l12_a);
|
|
x1 = (x1 * a - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n, y1 = (y1 * a - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n;
|
|
}
|
|
if (that._l23_a > 1e-12) {
|
|
var b = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a, m = 3 * that._l23_a * (that._l23_a + that._l12_a);
|
|
x2 = (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / m, y2 = (y2 * b + that._y1 * that._l23_2a - y * that._l12_2a) / m;
|
|
}
|
|
that._context.bezierCurveTo(x1, y1, x2, y2, that._x2, that._y2);
|
|
}
|
|
function CatmullRom(context, alpha) {
|
|
this._context = context, this._alpha = alpha;
|
|
}
|
|
CatmullRom.prototype = {
|
|
areaStart: function() {
|
|
this._line = 0;
|
|
},
|
|
areaEnd: function() {
|
|
this._line = NaN;
|
|
},
|
|
lineStart: function() {
|
|
this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
switch(this._point){
|
|
case 2:
|
|
this._context.lineTo(this._x2, this._y2);
|
|
break;
|
|
case 3:
|
|
this.point(this._x2, this._y2);
|
|
}
|
|
(this._line || 0 !== this._line && 1 === this._point) && this._context.closePath(), this._line = 1 - this._line;
|
|
},
|
|
point: function(x, y) {
|
|
if (x = +x, y = +y, this._point) {
|
|
var x23 = this._x2 - x, y23 = this._y2 - y;
|
|
this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
|
|
}
|
|
switch(this._point){
|
|
case 0:
|
|
this._point = 1, this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y);
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
break;
|
|
case 2:
|
|
this._point = 3;
|
|
default:
|
|
point$3(this, x, y);
|
|
}
|
|
this._l01_a = this._l12_a, this._l12_a = this._l23_a, this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a, this._x0 = this._x1, this._x1 = this._x2, this._x2 = x, this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
|
}
|
|
};
|
|
var catmullRom = function custom(alpha) {
|
|
function catmullRom(context) {
|
|
return alpha ? new CatmullRom(context, alpha) : new Cardinal(context, 0);
|
|
}
|
|
return catmullRom.alpha = function(alpha) {
|
|
return custom(+alpha);
|
|
}, catmullRom;
|
|
}(0.5);
|
|
function CatmullRomClosed(context, alpha) {
|
|
this._context = context, this._alpha = alpha;
|
|
}
|
|
CatmullRomClosed.prototype = {
|
|
areaStart: noop$3,
|
|
areaEnd: noop$3,
|
|
lineStart: function() {
|
|
this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN, this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
switch(this._point){
|
|
case 1:
|
|
this._context.moveTo(this._x3, this._y3), this._context.closePath();
|
|
break;
|
|
case 2:
|
|
this._context.lineTo(this._x3, this._y3), this._context.closePath();
|
|
break;
|
|
case 3:
|
|
this.point(this._x3, this._y3), this.point(this._x4, this._y4), this.point(this._x5, this._y5);
|
|
}
|
|
},
|
|
point: function(x, y) {
|
|
if (x = +x, y = +y, this._point) {
|
|
var x23 = this._x2 - x, y23 = this._y2 - y;
|
|
this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
|
|
}
|
|
switch(this._point){
|
|
case 0:
|
|
this._point = 1, this._x3 = x, this._y3 = y;
|
|
break;
|
|
case 1:
|
|
this._point = 2, this._context.moveTo(this._x4 = x, this._y4 = y);
|
|
break;
|
|
case 2:
|
|
this._point = 3, this._x5 = x, this._y5 = y;
|
|
break;
|
|
default:
|
|
point$3(this, x, y);
|
|
}
|
|
this._l01_a = this._l12_a, this._l12_a = this._l23_a, this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a, this._x0 = this._x1, this._x1 = this._x2, this._x2 = x, this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
|
}
|
|
};
|
|
var catmullRomClosed = function custom(alpha) {
|
|
function catmullRom(context) {
|
|
return alpha ? new CatmullRomClosed(context, alpha) : new CardinalClosed(context, 0);
|
|
}
|
|
return catmullRom.alpha = function(alpha) {
|
|
return custom(+alpha);
|
|
}, catmullRom;
|
|
}(0.5);
|
|
function CatmullRomOpen(context, alpha) {
|
|
this._context = context, this._alpha = alpha;
|
|
}
|
|
CatmullRomOpen.prototype = {
|
|
areaStart: function() {
|
|
this._line = 0;
|
|
},
|
|
areaEnd: function() {
|
|
this._line = NaN;
|
|
},
|
|
lineStart: function() {
|
|
this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
(this._line || 0 !== this._line && 3 === this._point) && this._context.closePath(), this._line = 1 - this._line;
|
|
},
|
|
point: function(x, y) {
|
|
if (x = +x, y = +y, this._point) {
|
|
var x23 = this._x2 - x, y23 = this._y2 - y;
|
|
this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
|
|
}
|
|
switch(this._point){
|
|
case 0:
|
|
this._point = 1;
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
break;
|
|
case 2:
|
|
this._point = 3, this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2);
|
|
break;
|
|
case 3:
|
|
this._point = 4;
|
|
default:
|
|
point$3(this, x, y);
|
|
}
|
|
this._l01_a = this._l12_a, this._l12_a = this._l23_a, this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a, this._x0 = this._x1, this._x1 = this._x2, this._x2 = x, this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
|
}
|
|
};
|
|
var catmullRomOpen = function custom(alpha) {
|
|
function catmullRom(context) {
|
|
return alpha ? new CatmullRomOpen(context, alpha) : new CardinalOpen(context, 0);
|
|
}
|
|
return catmullRom.alpha = function(alpha) {
|
|
return custom(+alpha);
|
|
}, catmullRom;
|
|
}(0.5);
|
|
function LinearClosed(context) {
|
|
this._context = context;
|
|
}
|
|
function sign$1(x) {
|
|
return x < 0 ? -1 : 1;
|
|
}
|
|
function slope3(that, x2, y2) {
|
|
var h0 = that._x1 - that._x0, h1 = x2 - that._x1, s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0), s1 = (y2 - that._y1) / (h1 || h0 < 0 && -0);
|
|
return (sign$1(s0) + sign$1(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs((s0 * h1 + s1 * h0) / (h0 + h1))) || 0;
|
|
}
|
|
function slope2(that, t) {
|
|
var h = that._x1 - that._x0;
|
|
return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t;
|
|
}
|
|
function point$4(that, t0, t1) {
|
|
var x0 = that._x0, y0 = that._y0, x1 = that._x1, y1 = that._y1, dx = (x1 - x0) / 3;
|
|
that._context.bezierCurveTo(x0 + dx, y0 + dx * t0, x1 - dx, y1 - dx * t1, x1, y1);
|
|
}
|
|
function MonotoneX(context) {
|
|
this._context = context;
|
|
}
|
|
function MonotoneY(context) {
|
|
this._context = new ReflectContext(context);
|
|
}
|
|
function ReflectContext(context) {
|
|
this._context = context;
|
|
}
|
|
function Natural(context) {
|
|
this._context = context;
|
|
}
|
|
function controlPoints(x) {
|
|
var i, m, n = x.length - 1, a = Array(n), b = Array(n), r = Array(n);
|
|
for(a[0] = 0, b[0] = 2, r[0] = x[0] + 2 * x[1], i = 1; i < n - 1; ++i)a[i] = 1, b[i] = 4, r[i] = 4 * x[i] + 2 * x[i + 1];
|
|
for(a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x[n - 1] + x[n], i = 1; i < n; ++i)m = a[i] / b[i - 1], b[i] -= m, r[i] -= m * r[i - 1];
|
|
for(a[n - 1] = r[n - 1] / b[n - 1], i = n - 2; i >= 0; --i)a[i] = (r[i] - a[i + 1]) / b[i];
|
|
for(i = 0, b[n - 1] = (x[n] + a[n - 1]) / 2; i < n - 1; ++i)b[i] = 2 * x[i + 1] - a[i + 1];
|
|
return [
|
|
a,
|
|
b
|
|
];
|
|
}
|
|
function Step(context, t) {
|
|
this._context = context, this._t = t;
|
|
}
|
|
function none$1(series, order) {
|
|
if ((n = series.length) > 1) for(var j, s0, n, i = 1, s1 = series[order[0]], m = s1.length; i < n; ++i)for(s0 = s1, s1 = series[order[i]], j = 0; j < m; ++j)s1[j][1] += s1[j][0] = isNaN(s0[j][1]) ? s0[j][0] : s0[j][1];
|
|
}
|
|
function none$2(series) {
|
|
for(var n = series.length, o = Array(n); --n >= 0;)o[n] = n;
|
|
return o;
|
|
}
|
|
function stackValue(d, key) {
|
|
return d[key];
|
|
}
|
|
function stackSeries(key) {
|
|
const series = [];
|
|
return series.key = key, series;
|
|
}
|
|
function appearance(series) {
|
|
var peaks = series.map(peak);
|
|
return none$2(series).sort(function(a, b) {
|
|
return peaks[a] - peaks[b];
|
|
});
|
|
}
|
|
function peak(series) {
|
|
for(var vi, i = -1, j = 0, n = series.length, vj = -1 / 0; ++i < n;)(vi = +series[i][1]) > vj && (vj = vi, j = i);
|
|
return j;
|
|
}
|
|
function ascending$3(series) {
|
|
var sums = series.map(sum$1);
|
|
return none$2(series).sort(function(a, b) {
|
|
return sums[a] - sums[b];
|
|
});
|
|
}
|
|
function sum$1(series) {
|
|
for(var v, s = 0, i = -1, n = series.length; ++i < n;)(v = +series[i][1]) && (s += v);
|
|
return s;
|
|
}
|
|
LinearClosed.prototype = {
|
|
areaStart: noop$3,
|
|
areaEnd: noop$3,
|
|
lineStart: function() {
|
|
this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
this._point && this._context.closePath();
|
|
},
|
|
point: function(x, y) {
|
|
x = +x, y = +y, this._point ? this._context.lineTo(x, y) : (this._point = 1, this._context.moveTo(x, y));
|
|
}
|
|
}, MonotoneX.prototype = {
|
|
areaStart: function() {
|
|
this._line = 0;
|
|
},
|
|
areaEnd: function() {
|
|
this._line = NaN;
|
|
},
|
|
lineStart: function() {
|
|
this._x0 = this._x1 = this._y0 = this._y1 = this._t0 = NaN, this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
switch(this._point){
|
|
case 2:
|
|
this._context.lineTo(this._x1, this._y1);
|
|
break;
|
|
case 3:
|
|
point$4(this, this._t0, slope2(this, this._t0));
|
|
}
|
|
(this._line || 0 !== this._line && 1 === this._point) && this._context.closePath(), this._line = 1 - this._line;
|
|
},
|
|
point: function(x, y) {
|
|
var t1 = NaN;
|
|
if (y = +y, (x = +x) !== this._x1 || y !== this._y1) {
|
|
switch(this._point){
|
|
case 0:
|
|
this._point = 1, this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y);
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
break;
|
|
case 2:
|
|
this._point = 3, point$4(this, slope2(this, t1 = slope3(this, x, y)), t1);
|
|
break;
|
|
default:
|
|
point$4(this, this._t0, t1 = slope3(this, x, y));
|
|
}
|
|
this._x0 = this._x1, this._x1 = x, this._y0 = this._y1, this._y1 = y, this._t0 = t1;
|
|
}
|
|
}
|
|
}, (MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x, y) {
|
|
MonotoneX.prototype.point.call(this, y, x);
|
|
}, ReflectContext.prototype = {
|
|
moveTo: function(x, y) {
|
|
this._context.moveTo(y, x);
|
|
},
|
|
closePath: function() {
|
|
this._context.closePath();
|
|
},
|
|
lineTo: function(x, y) {
|
|
this._context.lineTo(y, x);
|
|
},
|
|
bezierCurveTo: function(x1, y1, x2, y2, x, y) {
|
|
this._context.bezierCurveTo(y1, x1, y2, x2, y, x);
|
|
}
|
|
}, Natural.prototype = {
|
|
areaStart: function() {
|
|
this._line = 0;
|
|
},
|
|
areaEnd: function() {
|
|
this._line = NaN;
|
|
},
|
|
lineStart: function() {
|
|
this._x = [], this._y = [];
|
|
},
|
|
lineEnd: function() {
|
|
var x = this._x, y = this._y, n = x.length;
|
|
if (n) {
|
|
if (this._line ? this._context.lineTo(x[0], y[0]) : this._context.moveTo(x[0], y[0]), 2 === n) this._context.lineTo(x[1], y[1]);
|
|
else for(var px = controlPoints(x), py = controlPoints(y), i0 = 0, i1 = 1; i1 < n; ++i0, ++i1)this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x[i1], y[i1]);
|
|
}
|
|
(this._line || 0 !== this._line && 1 === n) && this._context.closePath(), this._line = 1 - this._line, this._x = this._y = null;
|
|
},
|
|
point: function(x, y) {
|
|
this._x.push(+x), this._y.push(+y);
|
|
}
|
|
}, Step.prototype = {
|
|
areaStart: function() {
|
|
this._line = 0;
|
|
},
|
|
areaEnd: function() {
|
|
this._line = NaN;
|
|
},
|
|
lineStart: function() {
|
|
this._x = this._y = NaN, this._point = 0;
|
|
},
|
|
lineEnd: function() {
|
|
0 < this._t && this._t < 1 && 2 === this._point && this._context.lineTo(this._x, this._y), (this._line || 0 !== this._line && 1 === this._point) && this._context.closePath(), this._line >= 0 && (this._t = 1 - this._t, this._line = 1 - this._line);
|
|
},
|
|
point: function(x, y) {
|
|
switch(x = +x, y = +y, this._point){
|
|
case 0:
|
|
this._point = 1, this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y);
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
default:
|
|
if (this._t <= 0) this._context.lineTo(this._x, y), this._context.lineTo(x, y);
|
|
else {
|
|
var x1 = this._x * (1 - this._t) + x * this._t;
|
|
this._context.lineTo(x1, this._y), this._context.lineTo(x1, y);
|
|
}
|
|
}
|
|
this._x = x, this._y = y;
|
|
}
|
|
};
|
|
var constant$b = (x)=>()=>x;
|
|
function ZoomEvent(type, { sourceEvent , target , transform , dispatch }) {
|
|
Object.defineProperties(this, {
|
|
type: {
|
|
value: type,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
sourceEvent: {
|
|
value: sourceEvent,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
target: {
|
|
value: target,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
transform: {
|
|
value: transform,
|
|
enumerable: !0,
|
|
configurable: !0
|
|
},
|
|
_: {
|
|
value: dispatch
|
|
}
|
|
});
|
|
}
|
|
function Transform(k, x, y) {
|
|
this.k = k, this.x = x, this.y = y;
|
|
}
|
|
Transform.prototype = {
|
|
constructor: Transform,
|
|
scale: function(k) {
|
|
return 1 === k ? this : new Transform(this.k * k, this.x, this.y);
|
|
},
|
|
translate: function(x, y) {
|
|
return 0 === x & 0 === y ? this : new Transform(this.k, this.x + this.k * x, this.y + this.k * y);
|
|
},
|
|
apply: function(point) {
|
|
return [
|
|
point[0] * this.k + this.x,
|
|
point[1] * this.k + this.y
|
|
];
|
|
},
|
|
applyX: function(x) {
|
|
return x * this.k + this.x;
|
|
},
|
|
applyY: function(y) {
|
|
return y * this.k + this.y;
|
|
},
|
|
invert: function(location) {
|
|
return [
|
|
(location[0] - this.x) / this.k,
|
|
(location[1] - this.y) / this.k
|
|
];
|
|
},
|
|
invertX: function(x) {
|
|
return (x - this.x) / this.k;
|
|
},
|
|
invertY: function(y) {
|
|
return (y - this.y) / this.k;
|
|
},
|
|
rescaleX: function(x) {
|
|
return x.copy().domain(x.range().map(this.invertX, this).map(x.invert, x));
|
|
},
|
|
rescaleY: function(y) {
|
|
return y.copy().domain(y.range().map(this.invertY, this).map(y.invert, y));
|
|
},
|
|
toString: function() {
|
|
return "translate(" + this.x + "," + this.y + ") scale(" + this.k + ")";
|
|
}
|
|
};
|
|
var identity$9 = new Transform(1, 0, 0);
|
|
function transform$1(node) {
|
|
for(; !node.__zoom;)if (!(node = node.parentNode)) return identity$9;
|
|
return node.__zoom;
|
|
}
|
|
function nopropagation$2(event) {
|
|
event.stopImmediatePropagation();
|
|
}
|
|
function noevent$2(event) {
|
|
event.preventDefault(), event.stopImmediatePropagation();
|
|
}
|
|
function defaultFilter$2(event) {
|
|
return (!event.ctrlKey || 'wheel' === event.type) && !event.button;
|
|
}
|
|
function defaultExtent$1() {
|
|
var e = this;
|
|
return e instanceof SVGElement ? (e = e.ownerSVGElement || e).hasAttribute("viewBox") ? [
|
|
[
|
|
(e = e.viewBox.baseVal).x,
|
|
e.y
|
|
],
|
|
[
|
|
e.x + e.width,
|
|
e.y + e.height
|
|
]
|
|
] : [
|
|
[
|
|
0,
|
|
0
|
|
],
|
|
[
|
|
e.width.baseVal.value,
|
|
e.height.baseVal.value
|
|
]
|
|
] : [
|
|
[
|
|
0,
|
|
0
|
|
],
|
|
[
|
|
e.clientWidth,
|
|
e.clientHeight
|
|
]
|
|
];
|
|
}
|
|
function defaultTransform() {
|
|
return this.__zoom || identity$9;
|
|
}
|
|
function defaultWheelDelta(event) {
|
|
return -event.deltaY * (1 === event.deltaMode ? 0.05 : event.deltaMode ? 1 : 0.002) * (event.ctrlKey ? 10 : 1);
|
|
}
|
|
function defaultTouchable$2() {
|
|
return navigator.maxTouchPoints || "ontouchstart" in this;
|
|
}
|
|
function defaultConstrain(transform, extent, translateExtent) {
|
|
var dx0 = transform.invertX(extent[0][0]) - translateExtent[0][0], dx1 = transform.invertX(extent[1][0]) - translateExtent[1][0], dy0 = transform.invertY(extent[0][1]) - translateExtent[0][1], dy1 = transform.invertY(extent[1][1]) - translateExtent[1][1];
|
|
return transform.translate(dx1 > dx0 ? (dx0 + dx1) / 2 : Math.min(0, dx0) || Math.max(0, dx1), dy1 > dy0 ? (dy0 + dy1) / 2 : Math.min(0, dy0) || Math.max(0, dy1));
|
|
}
|
|
transform$1.prototype = Transform.prototype, exports1.Adder = Adder, exports1.Delaunay = Delaunay, exports1.FormatSpecifier = FormatSpecifier, exports1.Voronoi = Voronoi, exports1.active = function(node, name) {
|
|
var schedule, i, schedules = node.__transition;
|
|
if (schedules) {
|
|
for(i in name = null == name ? null : name + "", schedules)if ((schedule = schedules[i]).state > 1 && schedule.name === name) return new Transition([
|
|
[
|
|
node
|
|
]
|
|
], root$1, name, +i);
|
|
}
|
|
return null;
|
|
}, exports1.arc = function() {
|
|
var innerRadius = arcInnerRadius, outerRadius = arcOuterRadius, cornerRadius = constant$a(0), padRadius = null, startAngle = arcStartAngle, endAngle = arcEndAngle, padAngle = arcPadAngle, context = null;
|
|
function arc() {
|
|
var buffer, r, r0 = +innerRadius.apply(this, arguments), r1 = +outerRadius.apply(this, arguments), a0 = startAngle.apply(this, arguments) - halfPi$3, a1 = endAngle.apply(this, arguments) - halfPi$3, da = abs$3(a1 - a0), cw = a1 > a0;
|
|
if (context || (context = buffer = path()), r1 < r0 && (r = r1, r1 = r0, r0 = r), r1 > 1e-12) {
|
|
if (da > tau$5 - 1e-12) context.moveTo(r1 * cos$2(a0), r1 * sin$2(a0)), context.arc(0, 0, r1, a0, a1, !cw), r0 > 1e-12 && (context.moveTo(r0 * cos$2(a1), r0 * sin$2(a1)), context.arc(0, 0, r0, a1, a0, cw));
|
|
else {
|
|
var t0, t1, a01 = a0, a11 = a1, a00 = a0, a10 = a1, da0 = da, da1 = da, ap = padAngle.apply(this, arguments) / 2, rp = ap > 1e-12 && (padRadius ? +padRadius.apply(this, arguments) : sqrt$2(r0 * r0 + r1 * r1)), rc = min$2(abs$3(r1 - r0) / 2, +cornerRadius.apply(this, arguments)), rc0 = rc, rc1 = rc;
|
|
if (rp > 1e-12) {
|
|
var p0 = asin$1(rp / r0 * sin$2(ap)), p1 = asin$1(rp / r1 * sin$2(ap));
|
|
(da0 -= 2 * p0) > 1e-12 ? (p0 *= cw ? 1 : -1, a00 += p0, a10 -= p0) : (da0 = 0, a00 = a10 = (a0 + a1) / 2), (da1 -= 2 * p1) > 1e-12 ? (p1 *= cw ? 1 : -1, a01 += p1, a11 -= p1) : (da1 = 0, a01 = a11 = (a0 + a1) / 2);
|
|
}
|
|
var x01 = r1 * cos$2(a01), y01 = r1 * sin$2(a01), x10 = r0 * cos$2(a10), y10 = r0 * sin$2(a10);
|
|
if (rc > 1e-12) {
|
|
var oc, x11 = r1 * cos$2(a11), y11 = r1 * sin$2(a11), x00 = r0 * cos$2(a00), y00 = r0 * sin$2(a00);
|
|
if (da < pi$4 && (oc = function(x0, y0, x1, y1, x2, y2, x3, y3) {
|
|
var x10 = x1 - x0, y10 = y1 - y0, x32 = x3 - x2, y32 = y3 - y2, t = y32 * x10 - x32 * y10;
|
|
if (!(t * t < 1e-12)) return t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / t, [
|
|
x0 + t * x10,
|
|
y0 + t * y10
|
|
];
|
|
}(x01, y01, x00, y00, x11, y11, x10, y10))) {
|
|
var x, ax = x01 - oc[0], ay = y01 - oc[1], bx = x11 - oc[0], by = y11 - oc[1], kc = 1 / sin$2(((x = (ax * bx + ay * by) / (sqrt$2(ax * ax + ay * ay) * sqrt$2(bx * bx + by * by))) > 1 ? 0 : x < -1 ? pi$4 : Math.acos(x)) / 2), lc = sqrt$2(oc[0] * oc[0] + oc[1] * oc[1]);
|
|
rc0 = min$2(rc, (r0 - lc) / (kc - 1)), rc1 = min$2(rc, (r1 - lc) / (kc + 1));
|
|
}
|
|
}
|
|
da1 > 1e-12 ? rc1 > 1e-12 ? (t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw), t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw), context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01), rc1 < rc ? context.arc(t0.cx, t0.cy, rc1, atan2$1(t0.y01, t0.x01), atan2$1(t1.y01, t1.x01), !cw) : (context.arc(t0.cx, t0.cy, rc1, atan2$1(t0.y01, t0.x01), atan2$1(t0.y11, t0.x11), !cw), context.arc(0, 0, r1, atan2$1(t0.cy + t0.y11, t0.cx + t0.x11), atan2$1(t1.cy + t1.y11, t1.cx + t1.x11), !cw), context.arc(t1.cx, t1.cy, rc1, atan2$1(t1.y11, t1.x11), atan2$1(t1.y01, t1.x01), !cw))) : (context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw)) : context.moveTo(x01, y01), r0 > 1e-12 && da0 > 1e-12 ? rc0 > 1e-12 ? (t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw), t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw), context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01), rc0 < rc ? context.arc(t0.cx, t0.cy, rc0, atan2$1(t0.y01, t0.x01), atan2$1(t1.y01, t1.x01), !cw) : (context.arc(t0.cx, t0.cy, rc0, atan2$1(t0.y01, t0.x01), atan2$1(t0.y11, t0.x11), !cw), context.arc(0, 0, r0, atan2$1(t0.cy + t0.y11, t0.cx + t0.x11), atan2$1(t1.cy + t1.y11, t1.cx + t1.x11), cw), context.arc(t1.cx, t1.cy, rc0, atan2$1(t1.y11, t1.x11), atan2$1(t1.y01, t1.x01), !cw))) : context.arc(0, 0, r0, a10, a00, cw) : context.lineTo(x10, y10);
|
|
}
|
|
} else context.moveTo(0, 0);
|
|
if (context.closePath(), buffer) return context = null, buffer + "" || null;
|
|
}
|
|
return arc.centroid = function() {
|
|
var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - pi$4 / 2;
|
|
return [
|
|
cos$2(a) * r,
|
|
sin$2(a) * r
|
|
];
|
|
}, arc.innerRadius = function(_) {
|
|
return arguments.length ? (innerRadius = "function" == typeof _ ? _ : constant$a(+_), arc) : innerRadius;
|
|
}, arc.outerRadius = function(_) {
|
|
return arguments.length ? (outerRadius = "function" == typeof _ ? _ : constant$a(+_), arc) : outerRadius;
|
|
}, arc.cornerRadius = function(_) {
|
|
return arguments.length ? (cornerRadius = "function" == typeof _ ? _ : constant$a(+_), arc) : cornerRadius;
|
|
}, arc.padRadius = function(_) {
|
|
return arguments.length ? (padRadius = null == _ ? null : "function" == typeof _ ? _ : constant$a(+_), arc) : padRadius;
|
|
}, arc.startAngle = function(_) {
|
|
return arguments.length ? (startAngle = "function" == typeof _ ? _ : constant$a(+_), arc) : startAngle;
|
|
}, arc.endAngle = function(_) {
|
|
return arguments.length ? (endAngle = "function" == typeof _ ? _ : constant$a(+_), arc) : endAngle;
|
|
}, arc.padAngle = function(_) {
|
|
return arguments.length ? (padAngle = "function" == typeof _ ? _ : constant$a(+_), arc) : padAngle;
|
|
}, arc.context = function(_) {
|
|
return arguments.length ? (context = null == _ ? null : _, arc) : context;
|
|
}, arc;
|
|
}, exports1.area = area$3, exports1.areaRadial = areaRadial, exports1.ascending = ascending, exports1.autoType = function(object) {
|
|
for(var key in object){
|
|
var number, m, value = object[key].trim();
|
|
if (value) {
|
|
if ("true" === value) value = !0;
|
|
else if ("false" === value) value = !1;
|
|
else if ("NaN" === value) value = NaN;
|
|
else if (isNaN(number = +value)) {
|
|
if (!(m = value.match(/^([-+]\d{2})?\d{4}(-\d{2}(-\d{2})?)?(T\d{2}:\d{2}(:\d{2}(\.\d{3})?)?(Z|[-+]\d{2}:\d{2})?)?$/))) continue;
|
|
fixtz && m[4] && !m[7] && (value = value.replace(/-/g, "/").replace(/T/, " ")), value = new Date(value);
|
|
} else value = number;
|
|
} else value = null;
|
|
object[key] = value;
|
|
}
|
|
return object;
|
|
}, exports1.axisBottom = function(scale) {
|
|
return axis(3, scale);
|
|
}, exports1.axisLeft = function(scale) {
|
|
return axis(4, scale);
|
|
}, exports1.axisRight = function(scale) {
|
|
return axis(2, scale);
|
|
}, exports1.axisTop = function(scale) {
|
|
return axis(1, scale);
|
|
}, exports1.bin = bin, exports1.bisect = bisectRight, exports1.bisectCenter = bisectCenter, exports1.bisectLeft = bisectLeft, exports1.bisectRight = bisectRight, exports1.bisector = bisector, exports1.blob = function(input, init) {
|
|
return fetch(input, init).then(responseBlob);
|
|
}, exports1.brush = function() {
|
|
return brush$1(XY);
|
|
}, exports1.brushSelection = function(node) {
|
|
var state = node.__brush;
|
|
return state ? state.dim.output(state.selection) : null;
|
|
}, exports1.brushX = function() {
|
|
return brush$1(X);
|
|
}, exports1.brushY = function() {
|
|
return brush$1(Y);
|
|
}, exports1.buffer = function(input, init) {
|
|
return fetch(input, init).then(responseArrayBuffer);
|
|
}, exports1.chord = function() {
|
|
return chord$1(!1, !1);
|
|
}, exports1.chordDirected = function() {
|
|
return chord$1(!0, !1);
|
|
}, exports1.chordTranspose = function() {
|
|
return chord$1(!1, !0);
|
|
}, exports1.cluster = function() {
|
|
var separation = defaultSeparation, dx = 1, dy = 1, nodeSize = !1;
|
|
function cluster(root) {
|
|
var previousNode, x = 0;
|
|
root.eachAfter(function(node) {
|
|
var children, children1 = node.children;
|
|
children1 ? (node.x = (children = children1).reduce(meanXReduce, 0) / children.length, node.y = 1 + children1.reduce(maxYReduce, 0)) : (node.x = previousNode ? x += separation(node, previousNode) : 0, node.y = 0, previousNode = node);
|
|
});
|
|
var left = function(node) {
|
|
for(var children; children = node.children;)node = children[0];
|
|
return node;
|
|
}(root), right = function(node) {
|
|
for(var children; children = node.children;)node = children[children.length - 1];
|
|
return node;
|
|
}(root), x0 = left.x - separation(left, right) / 2, x1 = right.x + separation(right, left) / 2;
|
|
return root.eachAfter(nodeSize ? function(node) {
|
|
node.x = (node.x - root.x) * dx, node.y = (root.y - node.y) * dy;
|
|
} : function(node) {
|
|
node.x = (node.x - x0) / (x1 - x0) * dx, node.y = (1 - (root.y ? node.y / root.y : 1)) * dy;
|
|
});
|
|
}
|
|
return cluster.separation = function(x) {
|
|
return arguments.length ? (separation = x, cluster) : separation;
|
|
}, cluster.size = function(x) {
|
|
return arguments.length ? (nodeSize = !1, dx = +x[0], dy = +x[1], cluster) : nodeSize ? null : [
|
|
dx,
|
|
dy
|
|
];
|
|
}, cluster.nodeSize = function(x) {
|
|
return arguments.length ? (nodeSize = !0, dx = +x[0], dy = +x[1], cluster) : nodeSize ? [
|
|
dx,
|
|
dy
|
|
] : null;
|
|
}, cluster;
|
|
}, exports1.color = color, exports1.contourDensity = function() {
|
|
var x = defaultX, y = defaultY, weight = defaultWeight, dx = 960, dy = 500, r = 20, k = 2, o = 60, n = 270, m = 155, threshold = constant$6(20);
|
|
function density(data) {
|
|
var values0 = new Float32Array(n * m), values1 = new Float32Array(n * m);
|
|
data.forEach(function(d, i, data) {
|
|
var xi = +x(d, i, data) + o >> k, yi = +y(d, i, data) + o >> k, wi = +weight(d, i, data);
|
|
xi >= 0 && xi < n && yi >= 0 && yi < m && (values0[xi + yi * n] += wi);
|
|
}), blurX({
|
|
width: n,
|
|
height: m,
|
|
data: values0
|
|
}, {
|
|
width: n,
|
|
height: m,
|
|
data: values1
|
|
}, r >> k), blurY({
|
|
width: n,
|
|
height: m,
|
|
data: values1
|
|
}, {
|
|
width: n,
|
|
height: m,
|
|
data: values0
|
|
}, r >> k), blurX({
|
|
width: n,
|
|
height: m,
|
|
data: values0
|
|
}, {
|
|
width: n,
|
|
height: m,
|
|
data: values1
|
|
}, r >> k), blurY({
|
|
width: n,
|
|
height: m,
|
|
data: values1
|
|
}, {
|
|
width: n,
|
|
height: m,
|
|
data: values0
|
|
}, r >> k), blurX({
|
|
width: n,
|
|
height: m,
|
|
data: values0
|
|
}, {
|
|
width: n,
|
|
height: m,
|
|
data: values1
|
|
}, r >> k), blurY({
|
|
width: n,
|
|
height: m,
|
|
data: values1
|
|
}, {
|
|
width: n,
|
|
height: m,
|
|
data: values0
|
|
}, r >> k);
|
|
var tz = threshold(values0);
|
|
if (!Array.isArray(tz)) {
|
|
var stop = max(values0);
|
|
tz = tickStep(0, stop, tz), (tz = sequence(0, Math.floor(stop / tz) * tz, tz)).shift();
|
|
}
|
|
return contours().thresholds(tz).size([
|
|
n,
|
|
m
|
|
])(values0).map(transform);
|
|
}
|
|
function transform(geometry) {
|
|
return geometry.value *= Math.pow(2, -2 * k), geometry.coordinates.forEach(transformPolygon), geometry;
|
|
}
|
|
function transformPolygon(coordinates) {
|
|
coordinates.forEach(transformRing);
|
|
}
|
|
function transformRing(coordinates) {
|
|
coordinates.forEach(transformPoint);
|
|
}
|
|
function transformPoint(coordinates) {
|
|
coordinates[0] = coordinates[0] * Math.pow(2, k) - o, coordinates[1] = coordinates[1] * Math.pow(2, k) - o;
|
|
}
|
|
function resize() {
|
|
return n = dx + 2 * (o = 3 * r) >> k, m = dy + 2 * o >> k, density;
|
|
}
|
|
return density.x = function(_) {
|
|
return arguments.length ? (x = "function" == typeof _ ? _ : constant$6(+_), density) : x;
|
|
}, density.y = function(_) {
|
|
return arguments.length ? (y = "function" == typeof _ ? _ : constant$6(+_), density) : y;
|
|
}, density.weight = function(_) {
|
|
return arguments.length ? (weight = "function" == typeof _ ? _ : constant$6(+_), density) : weight;
|
|
}, density.size = function(_) {
|
|
if (!arguments.length) return [
|
|
dx,
|
|
dy
|
|
];
|
|
var _0 = +_[0], _1 = +_[1];
|
|
if (!(_0 >= 0 && _1 >= 0)) throw Error("invalid size");
|
|
return dx = _0, dy = _1, resize();
|
|
}, density.cellSize = function(_) {
|
|
if (!arguments.length) return 1 << k;
|
|
if (!((_ = +_) >= 1)) throw Error("invalid cell size");
|
|
return k = Math.floor(Math.log(_) / Math.LN2), resize();
|
|
}, density.thresholds = function(_) {
|
|
return arguments.length ? (threshold = "function" == typeof _ ? _ : Array.isArray(_) ? constant$6(slice$3.call(_)) : constant$6(_), density) : threshold;
|
|
}, density.bandwidth = function(_) {
|
|
if (!arguments.length) return Math.sqrt(r * (r + 1));
|
|
if (!((_ = +_) >= 0)) throw Error("invalid bandwidth");
|
|
return r = Math.round((Math.sqrt(4 * _ * _ + 1) - 1) / 2), resize();
|
|
}, density;
|
|
}, exports1.contours = contours, exports1.count = count, exports1.create = function(name) {
|
|
return select(creator(name).call(document.documentElement));
|
|
}, exports1.creator = creator, exports1.cross = function(...values) {
|
|
var reduce;
|
|
const reduce1 = "function" == typeof values[values.length - 1] && (reduce = values.pop(), (values)=>reduce(...values));
|
|
values = values.map(arrayify);
|
|
const lengths = values.map(length), j = values.length - 1, index = Array(j + 1).fill(0), product = [];
|
|
if (j < 0 || lengths.some(empty)) return product;
|
|
for(;;){
|
|
product.push(index.map((j, i)=>values[i][j]));
|
|
let i = j;
|
|
for(; ++index[i] === lengths[i];){
|
|
if (0 === i) return reduce1 ? product.map(reduce1) : product;
|
|
index[i--] = 0;
|
|
}
|
|
}
|
|
}, exports1.csv = csv$1, exports1.csvFormat = csvFormat, exports1.csvFormatBody = csvFormatBody, exports1.csvFormatRow = csvFormatRow, exports1.csvFormatRows = csvFormatRows, exports1.csvFormatValue = csvFormatValue, exports1.csvParse = csvParse, exports1.csvParseRows = csvParseRows, exports1.cubehelix = cubehelix, exports1.cumsum = function(values, valueof) {
|
|
var sum = 0, index = 0;
|
|
return Float64Array.from(values, void 0 === valueof ? (v)=>sum += +v || 0 : (v)=>sum += +valueof(v, index++, values) || 0);
|
|
}, exports1.curveBasis = function(context) {
|
|
return new Basis(context);
|
|
}, exports1.curveBasisClosed = function(context) {
|
|
return new BasisClosed(context);
|
|
}, exports1.curveBasisOpen = function(context) {
|
|
return new BasisOpen(context);
|
|
}, exports1.curveBundle = bundle, exports1.curveCardinal = cardinal, exports1.curveCardinalClosed = cardinalClosed, exports1.curveCardinalOpen = cardinalOpen, exports1.curveCatmullRom = catmullRom, exports1.curveCatmullRomClosed = catmullRomClosed, exports1.curveCatmullRomOpen = catmullRomOpen, exports1.curveLinear = curveLinear, exports1.curveLinearClosed = function(context) {
|
|
return new LinearClosed(context);
|
|
}, exports1.curveMonotoneX = function(context) {
|
|
return new MonotoneX(context);
|
|
}, exports1.curveMonotoneY = function(context) {
|
|
return new MonotoneY(context);
|
|
}, exports1.curveNatural = function(context) {
|
|
return new Natural(context);
|
|
}, exports1.curveStep = function(context) {
|
|
return new Step(context, 0.5);
|
|
}, exports1.curveStepAfter = function(context) {
|
|
return new Step(context, 1);
|
|
}, exports1.curveStepBefore = function(context) {
|
|
return new Step(context, 0);
|
|
}, exports1.descending = function(a, b) {
|
|
return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
|
|
}, exports1.deviation = deviation, exports1.difference = function(values, ...others) {
|
|
for (const other of (values = new Set(values), others))for (const value of other)values.delete(value);
|
|
return values;
|
|
}, exports1.disjoint = function(values, other) {
|
|
const iterator = other[Symbol.iterator](), set = new Set();
|
|
for (const v of values){
|
|
let value, done;
|
|
if (set.has(v)) return !1;
|
|
for(; ({ value , done } = iterator.next()) && !done;){
|
|
if (Object.is(v, value)) return !1;
|
|
set.add(value);
|
|
}
|
|
}
|
|
return !0;
|
|
}, exports1.dispatch = dispatch, exports1.drag = function() {
|
|
var mousedownx, mousedowny, mousemoving, touchending, filter = defaultFilter, container = defaultContainer, subject = defaultSubject, touchable = defaultTouchable, gestures = {}, listeners = dispatch("start", "drag", "end"), active = 0, clickDistance2 = 0;
|
|
function drag(selection) {
|
|
selection.on("mousedown.drag", mousedowned).filter(touchable).on("touchstart.drag", touchstarted).on("touchmove.drag", touchmoved).on("touchend.drag touchcancel.drag", touchended).style("touch-action", "none").style("-webkit-tap-highlight-color", "rgba(0,0,0,0)");
|
|
}
|
|
function mousedowned(event, d) {
|
|
if (!touchending && filter.call(this, event, d)) {
|
|
var gesture = beforestart(this, container.call(this, event, d), event, d, "mouse");
|
|
gesture && (select(event.view).on("mousemove.drag", mousemoved, !0).on("mouseup.drag", mouseupped, !0), dragDisable(event.view), nopropagation(event), mousemoving = !1, mousedownx = event.clientX, mousedowny = event.clientY, gesture("start", event));
|
|
}
|
|
}
|
|
function mousemoved(event) {
|
|
if (noevent(event), !mousemoving) {
|
|
var dx = event.clientX - mousedownx, dy = event.clientY - mousedowny;
|
|
mousemoving = dx * dx + dy * dy > clickDistance2;
|
|
}
|
|
gestures.mouse("drag", event);
|
|
}
|
|
function mouseupped(event) {
|
|
select(event.view).on("mousemove.drag mouseup.drag", null), yesdrag(event.view, mousemoving), noevent(event), gestures.mouse("end", event);
|
|
}
|
|
function touchstarted(event, d) {
|
|
if (filter.call(this, event, d)) {
|
|
var i, gesture, touches = event.changedTouches, c = container.call(this, event, d), n = touches.length;
|
|
for(i = 0; i < n; ++i)(gesture = beforestart(this, c, event, d, touches[i].identifier, touches[i])) && (nopropagation(event), gesture("start", event, touches[i]));
|
|
}
|
|
}
|
|
function touchmoved(event) {
|
|
var i, gesture, touches = event.changedTouches, n = touches.length;
|
|
for(i = 0; i < n; ++i)(gesture = gestures[touches[i].identifier]) && (noevent(event), gesture("drag", event, touches[i]));
|
|
}
|
|
function touchended(event) {
|
|
var i, gesture, touches = event.changedTouches, n = touches.length;
|
|
for(touchending && clearTimeout(touchending), touchending = setTimeout(function() {
|
|
touchending = null;
|
|
}, 500), i = 0; i < n; ++i)(gesture = gestures[touches[i].identifier]) && (nopropagation(event), gesture("end", event, touches[i]));
|
|
}
|
|
function beforestart(that, container, event, d, identifier, touch) {
|
|
var dx, dy, s, dispatch = listeners.copy(), p = pointer(touch || event, container);
|
|
if (null != (s = subject.call(that, new DragEvent("beforestart", {
|
|
sourceEvent: event,
|
|
target: drag,
|
|
identifier,
|
|
active,
|
|
x: p[0],
|
|
y: p[1],
|
|
dx: 0,
|
|
dy: 0,
|
|
dispatch
|
|
}), d))) return dx = s.x - p[0] || 0, dy = s.y - p[1] || 0, function gesture(type, event, touch) {
|
|
var n, p0 = p;
|
|
switch(type){
|
|
case "start":
|
|
gestures[identifier] = gesture, n = active++;
|
|
break;
|
|
case "end":
|
|
delete gestures[identifier], --active;
|
|
case "drag":
|
|
p = pointer(touch || event, container), n = active;
|
|
}
|
|
dispatch.call(type, that, new DragEvent(type, {
|
|
sourceEvent: event,
|
|
subject: s,
|
|
target: drag,
|
|
identifier,
|
|
active: n,
|
|
x: p[0] + dx,
|
|
y: p[1] + dy,
|
|
dx: p[0] - p0[0],
|
|
dy: p[1] - p0[1],
|
|
dispatch
|
|
}), d);
|
|
};
|
|
}
|
|
return drag.filter = function(_) {
|
|
return arguments.length ? (filter = "function" == typeof _ ? _ : constant$2(!!_), drag) : filter;
|
|
}, drag.container = function(_) {
|
|
return arguments.length ? (container = "function" == typeof _ ? _ : constant$2(_), drag) : container;
|
|
}, drag.subject = function(_) {
|
|
return arguments.length ? (subject = "function" == typeof _ ? _ : constant$2(_), drag) : subject;
|
|
}, drag.touchable = function(_) {
|
|
return arguments.length ? (touchable = "function" == typeof _ ? _ : constant$2(!!_), drag) : touchable;
|
|
}, drag.on = function() {
|
|
var value = listeners.on.apply(listeners, arguments);
|
|
return value === listeners ? drag : value;
|
|
}, drag.clickDistance = function(_) {
|
|
return arguments.length ? (clickDistance2 = (_ = +_) * _, drag) : Math.sqrt(clickDistance2);
|
|
}, drag;
|
|
}, exports1.dragDisable = dragDisable, exports1.dragEnable = yesdrag, exports1.dsv = function(delimiter, input, init, row) {
|
|
3 === arguments.length && "function" == typeof init && (row = init, init = void 0);
|
|
var format = dsvFormat(delimiter);
|
|
return text(input, init).then(function(response) {
|
|
return format.parse(response, row);
|
|
});
|
|
}, exports1.dsvFormat = dsvFormat, exports1.easeBack = backInOut, exports1.easeBackIn = backIn, exports1.easeBackInOut = backInOut, exports1.easeBackOut = backOut, exports1.easeBounce = bounceOut, exports1.easeBounceIn = function(t) {
|
|
return 1 - bounceOut(1 - t);
|
|
}, exports1.easeBounceInOut = function(t) {
|
|
return ((t *= 2) <= 1 ? 1 - bounceOut(1 - t) : bounceOut(t - 1) + 1) / 2;
|
|
}, exports1.easeBounceOut = bounceOut, exports1.easeCircle = circleInOut, exports1.easeCircleIn = function(t) {
|
|
return 1 - Math.sqrt(1 - t * t);
|
|
}, exports1.easeCircleInOut = circleInOut, exports1.easeCircleOut = function(t) {
|
|
return Math.sqrt(1 - --t * t);
|
|
}, exports1.easeCubic = cubicInOut, exports1.easeCubicIn = function(t) {
|
|
return t * t * t;
|
|
}, exports1.easeCubicInOut = cubicInOut, exports1.easeCubicOut = function(t) {
|
|
return --t * t * t + 1;
|
|
}, exports1.easeElastic = elasticOut, exports1.easeElasticIn = elasticIn, exports1.easeElasticInOut = elasticInOut, exports1.easeElasticOut = elasticOut, exports1.easeExp = expInOut, exports1.easeExpIn = function(t) {
|
|
return tpmt(1 - +t);
|
|
}, exports1.easeExpInOut = expInOut, exports1.easeExpOut = function(t) {
|
|
return 1 - tpmt(t);
|
|
}, exports1.easeLinear = (t)=>+t, exports1.easePoly = polyInOut, exports1.easePolyIn = polyIn, exports1.easePolyInOut = polyInOut, exports1.easePolyOut = polyOut, exports1.easeQuad = quadInOut, exports1.easeQuadIn = function(t) {
|
|
return t * t;
|
|
}, exports1.easeQuadInOut = quadInOut, exports1.easeQuadOut = function(t) {
|
|
return t * (2 - t);
|
|
}, exports1.easeSin = sinInOut, exports1.easeSinIn = function(t) {
|
|
return 1 == +t ? 1 : 1 - Math.cos(t * halfPi);
|
|
}, exports1.easeSinInOut = sinInOut, exports1.easeSinOut = function(t) {
|
|
return Math.sin(t * halfPi);
|
|
}, exports1.every = function(values, test) {
|
|
if ("function" != typeof test) throw TypeError("test is not a function");
|
|
let index = -1;
|
|
for (const value of values)if (!test(value, ++index, values)) return !1;
|
|
return !0;
|
|
}, exports1.extent = extent, exports1.filter = function(values, test) {
|
|
if ("function" != typeof test) throw TypeError("test is not a function");
|
|
const array = [];
|
|
let index = -1;
|
|
for (const value of values)test(value, ++index, values) && array.push(value);
|
|
return array;
|
|
}, exports1.forceCenter = function(x, y) {
|
|
var nodes, strength = 1;
|
|
function force() {
|
|
var i, node, n = nodes.length, sx = 0, sy = 0;
|
|
for(i = 0; i < n; ++i)sx += (node = nodes[i]).x, sy += node.y;
|
|
for(sx = (sx / n - x) * strength, sy = (sy / n - y) * strength, i = 0; i < n; ++i)node = nodes[i], node.x -= sx, node.y -= sy;
|
|
}
|
|
return null == x && (x = 0), null == y && (y = 0), force.initialize = function(_) {
|
|
nodes = _;
|
|
}, force.x = function(_) {
|
|
return arguments.length ? (x = +_, force) : x;
|
|
}, force.y = function(_) {
|
|
return arguments.length ? (y = +_, force) : y;
|
|
}, force.strength = function(_) {
|
|
return arguments.length ? (strength = +_, force) : strength;
|
|
}, force;
|
|
}, exports1.forceCollide = function(radius) {
|
|
var nodes, radii, random, strength = 1, iterations = 1;
|
|
function force() {
|
|
for(var i, tree, node, xi, yi, ri, ri2, n = nodes.length, k = 0; k < iterations; ++k)for(i = 0, tree = quadtree(nodes, x, y).visitAfter(prepare); i < n; ++i)ri2 = (ri = radii[(node = nodes[i]).index]) * ri, xi = node.x + node.vx, yi = node.y + node.vy, tree.visit(apply);
|
|
function apply(quad, x0, y0, x1, y1) {
|
|
var data = quad.data, rj = quad.r, r = ri + rj;
|
|
if (data) {
|
|
if (data.index > node.index) {
|
|
var x = xi - data.x - data.vx, y = yi - data.y - data.vy, l = x * x + y * y;
|
|
l < r * r && (0 === x && (x = jiggle(random), l += x * x), 0 === y && (y = jiggle(random), l += y * y), l = (r - (l = Math.sqrt(l))) / l * strength, node.vx += (x *= l) * (r = (rj *= rj) / (ri2 + rj)), node.vy += (y *= l) * r, data.vx -= x * (r = 1 - r), data.vy -= y * r);
|
|
}
|
|
return;
|
|
}
|
|
return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r;
|
|
}
|
|
}
|
|
function prepare(quad) {
|
|
if (quad.data) return quad.r = radii[quad.data.index];
|
|
for(var i = quad.r = 0; i < 4; ++i)quad[i] && quad[i].r > quad.r && (quad.r = quad[i].r);
|
|
}
|
|
function initialize() {
|
|
if (nodes) {
|
|
var i, node, n = nodes.length;
|
|
for(i = 0, radii = Array(n); i < n; ++i)radii[(node = nodes[i]).index] = +radius(node, i, nodes);
|
|
}
|
|
}
|
|
return "function" != typeof radius && (radius = constant$7(null == radius ? 1 : +radius)), force.initialize = function(_nodes, _random) {
|
|
nodes = _nodes, random = _random, initialize();
|
|
}, force.iterations = function(_) {
|
|
return arguments.length ? (iterations = +_, force) : iterations;
|
|
}, force.strength = function(_) {
|
|
return arguments.length ? (strength = +_, force) : strength;
|
|
}, force.radius = function(_) {
|
|
return arguments.length ? (radius = "function" == typeof _ ? _ : constant$7(+_), initialize(), force) : radius;
|
|
}, force;
|
|
}, exports1.forceLink = function(links) {
|
|
var strengths, distances, nodes, count, bias, random, id = index$1, strength = function(link) {
|
|
return 1 / Math.min(count[link.source.index], count[link.target.index]);
|
|
}, distance = constant$7(30), iterations = 1;
|
|
function force(alpha) {
|
|
for(var k = 0, n = links.length; k < iterations; ++k)for(var link, source, target, x, y, l, b, i = 0; i < n; ++i)source = (link = links[i]).source, x = (target = link.target).x + target.vx - source.x - source.vx || jiggle(random), y = target.y + target.vy - source.y - source.vy || jiggle(random), l = ((l = Math.sqrt(x * x + y * y)) - distances[i]) / l * alpha * strengths[i], x *= l, y *= l, target.vx -= x * (b = bias[i]), target.vy -= y * b, source.vx += x * (b = 1 - b), source.vy += y * b;
|
|
}
|
|
function initialize() {
|
|
if (nodes) {
|
|
var i, link, n = nodes.length, m = links.length, nodeById = new Map(nodes.map((d, i)=>[
|
|
id(d, i, nodes),
|
|
d
|
|
]));
|
|
for(i = 0, count = Array(n); i < m; ++i)(link = links[i]).index = i, "object" != typeof link.source && (link.source = find$1(nodeById, link.source)), "object" != typeof link.target && (link.target = find$1(nodeById, link.target)), count[link.source.index] = (count[link.source.index] || 0) + 1, count[link.target.index] = (count[link.target.index] || 0) + 1;
|
|
for(i = 0, bias = Array(m); i < m; ++i)link = links[i], bias[i] = count[link.source.index] / (count[link.source.index] + count[link.target.index]);
|
|
strengths = Array(m), initializeStrength(), distances = Array(m), initializeDistance();
|
|
}
|
|
}
|
|
function initializeStrength() {
|
|
if (nodes) for(var i = 0, n = links.length; i < n; ++i)strengths[i] = +strength(links[i], i, links);
|
|
}
|
|
function initializeDistance() {
|
|
if (nodes) for(var i = 0, n = links.length; i < n; ++i)distances[i] = +distance(links[i], i, links);
|
|
}
|
|
return null == links && (links = []), force.initialize = function(_nodes, _random) {
|
|
nodes = _nodes, random = _random, initialize();
|
|
}, force.links = function(_) {
|
|
return arguments.length ? (links = _, initialize(), force) : links;
|
|
}, force.id = function(_) {
|
|
return arguments.length ? (id = _, force) : id;
|
|
}, force.iterations = function(_) {
|
|
return arguments.length ? (iterations = +_, force) : iterations;
|
|
}, force.strength = function(_) {
|
|
return arguments.length ? (strength = "function" == typeof _ ? _ : constant$7(+_), initializeStrength(), force) : strength;
|
|
}, force.distance = function(_) {
|
|
return arguments.length ? (distance = "function" == typeof _ ? _ : constant$7(+_), initializeDistance(), force) : distance;
|
|
}, force;
|
|
}, exports1.forceManyBody = function() {
|
|
var nodes, node, random, alpha, strengths, strength = constant$7(-30), distanceMin2 = 1, distanceMax2 = 1 / 0, theta2 = 0.81;
|
|
function force(_) {
|
|
var i, n = nodes.length, tree = quadtree(nodes, x$1, y$1).visitAfter(accumulate);
|
|
for(alpha = _, i = 0; i < n; ++i)node = nodes[i], tree.visit(apply);
|
|
}
|
|
function initialize() {
|
|
if (nodes) {
|
|
var i, node, n = nodes.length;
|
|
for(i = 0, strengths = Array(n); i < n; ++i)strengths[(node = nodes[i]).index] = +strength(node, i, nodes);
|
|
}
|
|
}
|
|
function accumulate(quad) {
|
|
var q, c, x, y, i, strength = 0, weight = 0;
|
|
if (quad.length) {
|
|
for(x = y = i = 0; i < 4; ++i)(q = quad[i]) && (c = Math.abs(q.value)) && (strength += q.value, weight += c, x += c * q.x, y += c * q.y);
|
|
quad.x = x / weight, quad.y = y / weight;
|
|
} else {
|
|
(q = quad).x = q.data.x, q.y = q.data.y;
|
|
do strength += strengths[q.data.index];
|
|
while (q = q.next)
|
|
}
|
|
quad.value = strength;
|
|
}
|
|
function apply(quad, x1, _, x2) {
|
|
if (!quad.value) return !0;
|
|
var x = quad.x - node.x, y = quad.y - node.y, w = x2 - x1, l = x * x + y * y;
|
|
if (w * w / theta2 < l) return l < distanceMax2 && (0 === x && (x = jiggle(random), l += x * x), 0 === y && (y = jiggle(random), l += y * y), l < distanceMin2 && (l = Math.sqrt(distanceMin2 * l)), node.vx += x * quad.value * alpha / l, node.vy += y * quad.value * alpha / l), !0;
|
|
if (!quad.length && !(l >= distanceMax2)) {
|
|
(quad.data !== node || quad.next) && (0 === x && (x = jiggle(random), l += x * x), 0 === y && (y = jiggle(random), l += y * y), l < distanceMin2 && (l = Math.sqrt(distanceMin2 * l)));
|
|
do quad.data !== node && (w = strengths[quad.data.index] * alpha / l, node.vx += x * w, node.vy += y * w);
|
|
while (quad = quad.next)
|
|
}
|
|
}
|
|
return force.initialize = function(_nodes, _random) {
|
|
nodes = _nodes, random = _random, initialize();
|
|
}, force.strength = function(_) {
|
|
return arguments.length ? (strength = "function" == typeof _ ? _ : constant$7(+_), initialize(), force) : strength;
|
|
}, force.distanceMin = function(_) {
|
|
return arguments.length ? (distanceMin2 = _ * _, force) : Math.sqrt(distanceMin2);
|
|
}, force.distanceMax = function(_) {
|
|
return arguments.length ? (distanceMax2 = _ * _, force) : Math.sqrt(distanceMax2);
|
|
}, force.theta = function(_) {
|
|
return arguments.length ? (theta2 = _ * _, force) : Math.sqrt(theta2);
|
|
}, force;
|
|
}, exports1.forceRadial = function(radius, x, y) {
|
|
var nodes, strengths, radiuses, strength = constant$7(0.1);
|
|
function force(alpha) {
|
|
for(var i = 0, n = nodes.length; i < n; ++i){
|
|
var node = nodes[i], dx = node.x - x || 1e-6, dy = node.y - y || 1e-6, r = Math.sqrt(dx * dx + dy * dy), k = (radiuses[i] - r) * strengths[i] * alpha / r;
|
|
node.vx += dx * k, node.vy += dy * k;
|
|
}
|
|
}
|
|
function initialize() {
|
|
if (nodes) {
|
|
var i, n = nodes.length;
|
|
for(i = 0, strengths = Array(n), radiuses = Array(n); i < n; ++i)radiuses[i] = +radius(nodes[i], i, nodes), strengths[i] = isNaN(radiuses[i]) ? 0 : +strength(nodes[i], i, nodes);
|
|
}
|
|
}
|
|
return "function" != typeof radius && (radius = constant$7(+radius)), null == x && (x = 0), null == y && (y = 0), force.initialize = function(_) {
|
|
nodes = _, initialize();
|
|
}, force.strength = function(_) {
|
|
return arguments.length ? (strength = "function" == typeof _ ? _ : constant$7(+_), initialize(), force) : strength;
|
|
}, force.radius = function(_) {
|
|
return arguments.length ? (radius = "function" == typeof _ ? _ : constant$7(+_), initialize(), force) : radius;
|
|
}, force.x = function(_) {
|
|
return arguments.length ? (x = +_, force) : x;
|
|
}, force.y = function(_) {
|
|
return arguments.length ? (y = +_, force) : y;
|
|
}, force;
|
|
}, exports1.forceSimulation = function(nodes) {
|
|
let s;
|
|
var simulation, alpha = 1, alphaMin = 0.001, alphaDecay = 1 - Math.pow(0.001, 1 / 300), alphaTarget = 0, velocityDecay = 0.6, forces = new Map(), stepper = timer(step), event = dispatch("tick", "end"), random = (s = 1, ()=>(s = (1664525 * s + 1013904223) % 4294967296) / 4294967296);
|
|
function step() {
|
|
tick(), event.call("tick", simulation), alpha < alphaMin && (stepper.stop(), event.call("end", simulation));
|
|
}
|
|
function tick(iterations) {
|
|
var i, node, n = nodes.length;
|
|
void 0 === iterations && (iterations = 1);
|
|
for(var k = 0; k < iterations; ++k)for(alpha += (alphaTarget - alpha) * alphaDecay, forces.forEach(function(force) {
|
|
force(alpha);
|
|
}), i = 0; i < n; ++i)null == (node = nodes[i]).fx ? node.x += node.vx *= velocityDecay : (node.x = node.fx, node.vx = 0), null == node.fy ? node.y += node.vy *= velocityDecay : (node.y = node.fy, node.vy = 0);
|
|
return simulation;
|
|
}
|
|
function initializeNodes() {
|
|
for(var node, i = 0, n = nodes.length; i < n; ++i){
|
|
if ((node = nodes[i]).index = i, null != node.fx && (node.x = node.fx), null != node.fy && (node.y = node.fy), isNaN(node.x) || isNaN(node.y)) {
|
|
var radius = 10 * Math.sqrt(0.5 + i), angle = i * initialAngle;
|
|
node.x = radius * Math.cos(angle), node.y = radius * Math.sin(angle);
|
|
}
|
|
(isNaN(node.vx) || isNaN(node.vy)) && (node.vx = node.vy = 0);
|
|
}
|
|
}
|
|
function initializeForce(force) {
|
|
return force.initialize && force.initialize(nodes, random), force;
|
|
}
|
|
return null == nodes && (nodes = []), initializeNodes(), simulation = {
|
|
tick: tick,
|
|
restart: function() {
|
|
return stepper.restart(step), simulation;
|
|
},
|
|
stop: function() {
|
|
return stepper.stop(), simulation;
|
|
},
|
|
nodes: function(_) {
|
|
return arguments.length ? (nodes = _, initializeNodes(), forces.forEach(initializeForce), simulation) : nodes;
|
|
},
|
|
alpha: function(_) {
|
|
return arguments.length ? (alpha = +_, simulation) : alpha;
|
|
},
|
|
alphaMin: function(_) {
|
|
return arguments.length ? (alphaMin = +_, simulation) : alphaMin;
|
|
},
|
|
alphaDecay: function(_) {
|
|
return arguments.length ? (alphaDecay = +_, simulation) : +alphaDecay;
|
|
},
|
|
alphaTarget: function(_) {
|
|
return arguments.length ? (alphaTarget = +_, simulation) : alphaTarget;
|
|
},
|
|
velocityDecay: function(_) {
|
|
return arguments.length ? (velocityDecay = 1 - _, simulation) : 1 - velocityDecay;
|
|
},
|
|
randomSource: function(_) {
|
|
return arguments.length ? (random = _, forces.forEach(initializeForce), simulation) : random;
|
|
},
|
|
force: function(name, _) {
|
|
return arguments.length > 1 ? (null == _ ? forces.delete(name) : forces.set(name, initializeForce(_)), simulation) : forces.get(name);
|
|
},
|
|
find: function(x, y, radius) {
|
|
var dx, dy, d2, node, closest, i = 0, n = nodes.length;
|
|
for(null == radius ? radius = 1 / 0 : radius *= radius, i = 0; i < n; ++i)(d2 = (dx = x - (node = nodes[i]).x) * dx + (dy = y - node.y) * dy) < radius && (closest = node, radius = d2);
|
|
return closest;
|
|
},
|
|
on: function(name, _) {
|
|
return arguments.length > 1 ? (event.on(name, _), simulation) : event.on(name);
|
|
}
|
|
};
|
|
}, exports1.forceX = function(x) {
|
|
var nodes, strengths, xz, strength = constant$7(0.1);
|
|
function force(alpha) {
|
|
for(var node, i = 0, n = nodes.length; i < n; ++i)node = nodes[i], node.vx += (xz[i] - node.x) * strengths[i] * alpha;
|
|
}
|
|
function initialize() {
|
|
if (nodes) {
|
|
var i, n = nodes.length;
|
|
for(i = 0, strengths = Array(n), xz = Array(n); i < n; ++i)strengths[i] = isNaN(xz[i] = +x(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);
|
|
}
|
|
}
|
|
return "function" != typeof x && (x = constant$7(null == x ? 0 : +x)), force.initialize = function(_) {
|
|
nodes = _, initialize();
|
|
}, force.strength = function(_) {
|
|
return arguments.length ? (strength = "function" == typeof _ ? _ : constant$7(+_), initialize(), force) : strength;
|
|
}, force.x = function(_) {
|
|
return arguments.length ? (x = "function" == typeof _ ? _ : constant$7(+_), initialize(), force) : x;
|
|
}, force;
|
|
}, exports1.forceY = function(y) {
|
|
var nodes, strengths, yz, strength = constant$7(0.1);
|
|
function force(alpha) {
|
|
for(var node, i = 0, n = nodes.length; i < n; ++i)node = nodes[i], node.vy += (yz[i] - node.y) * strengths[i] * alpha;
|
|
}
|
|
function initialize() {
|
|
if (nodes) {
|
|
var i, n = nodes.length;
|
|
for(i = 0, strengths = Array(n), yz = Array(n); i < n; ++i)strengths[i] = isNaN(yz[i] = +y(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);
|
|
}
|
|
}
|
|
return "function" != typeof y && (y = constant$7(null == y ? 0 : +y)), force.initialize = function(_) {
|
|
nodes = _, initialize();
|
|
}, force.strength = function(_) {
|
|
return arguments.length ? (strength = "function" == typeof _ ? _ : constant$7(+_), initialize(), force) : strength;
|
|
}, force.y = function(_) {
|
|
return arguments.length ? (y = "function" == typeof _ ? _ : constant$7(+_), initialize(), force) : y;
|
|
}, force;
|
|
}, exports1.formatDefaultLocale = defaultLocale, exports1.formatLocale = formatLocale, exports1.formatSpecifier = formatSpecifier, exports1.fsum = function(values, valueof) {
|
|
const adder = new Adder();
|
|
if (void 0 === valueof) for (let value of values)(value = +value) && adder.add(value);
|
|
else {
|
|
let index = -1;
|
|
for (let value1 of values)(value1 = +valueof(value1, ++index, values)) && adder.add(value1);
|
|
}
|
|
return +adder;
|
|
}, exports1.geoAlbers = albers, exports1.geoAlbersUsa = function() {
|
|
var cache, cacheStream, lower48Point, alaskaPoint, hawaiiPoint, point, lower48 = albers(), alaska = conicEqualArea().rotate([
|
|
154,
|
|
0
|
|
]).center([
|
|
-2,
|
|
58.5
|
|
]).parallels([
|
|
55,
|
|
65
|
|
]), hawaii = conicEqualArea().rotate([
|
|
157,
|
|
0
|
|
]).center([
|
|
-3,
|
|
19.9
|
|
]).parallels([
|
|
8,
|
|
18
|
|
]), pointStream = {
|
|
point: function(x, y) {
|
|
point = [
|
|
x,
|
|
y
|
|
];
|
|
}
|
|
};
|
|
function albersUsa(coordinates) {
|
|
var x = coordinates[0], y = coordinates[1];
|
|
return point = null, lower48Point.point(x, y), point || (alaskaPoint.point(x, y), point) || (hawaiiPoint.point(x, y), point);
|
|
}
|
|
function reset() {
|
|
return cache = cacheStream = null, albersUsa;
|
|
}
|
|
return albersUsa.invert = function(coordinates) {
|
|
var k = lower48.scale(), t = lower48.translate(), x = (coordinates[0] - t[0]) / k, y = (coordinates[1] - t[1]) / k;
|
|
return (y >= 0.120 && y < 0.234 && x >= -0.425 && x < -0.214 ? alaska : y >= 0.166 && y < 0.234 && x >= -0.214 && x < -0.115 ? hawaii : lower48).invert(coordinates);
|
|
}, albersUsa.stream = function(stream) {
|
|
var streams, n;
|
|
return cache && cacheStream === stream ? cache : (n = (streams = [
|
|
lower48.stream(cacheStream = stream),
|
|
alaska.stream(stream),
|
|
hawaii.stream(stream)
|
|
]).length, cache = {
|
|
point: function(x, y) {
|
|
for(var i = -1; ++i < n;)streams[i].point(x, y);
|
|
},
|
|
sphere: function() {
|
|
for(var i = -1; ++i < n;)streams[i].sphere();
|
|
},
|
|
lineStart: function() {
|
|
for(var i = -1; ++i < n;)streams[i].lineStart();
|
|
},
|
|
lineEnd: function() {
|
|
for(var i = -1; ++i < n;)streams[i].lineEnd();
|
|
},
|
|
polygonStart: function() {
|
|
for(var i = -1; ++i < n;)streams[i].polygonStart();
|
|
},
|
|
polygonEnd: function() {
|
|
for(var i = -1; ++i < n;)streams[i].polygonEnd();
|
|
}
|
|
});
|
|
}, albersUsa.precision = function(_) {
|
|
return arguments.length ? (lower48.precision(_), alaska.precision(_), hawaii.precision(_), reset()) : lower48.precision();
|
|
}, albersUsa.scale = function(_) {
|
|
return arguments.length ? (lower48.scale(_), alaska.scale(0.35 * _), hawaii.scale(_), albersUsa.translate(lower48.translate())) : lower48.scale();
|
|
}, albersUsa.translate = function(_) {
|
|
if (!arguments.length) return lower48.translate();
|
|
var k = lower48.scale(), x = +_[0], y = +_[1];
|
|
return lower48Point = lower48.translate(_).clipExtent([
|
|
[
|
|
x - 0.455 * k,
|
|
y - 0.238 * k
|
|
],
|
|
[
|
|
x + 0.455 * k,
|
|
y + 0.238 * k
|
|
]
|
|
]).stream(pointStream), alaskaPoint = alaska.translate([
|
|
x - 0.307 * k,
|
|
y + 0.201 * k
|
|
]).clipExtent([
|
|
[
|
|
x - 0.425 * k + 1e-6,
|
|
y + 0.120 * k + 1e-6
|
|
],
|
|
[
|
|
x - 0.214 * k - 1e-6,
|
|
y + 0.234 * k - 1e-6
|
|
]
|
|
]).stream(pointStream), hawaiiPoint = hawaii.translate([
|
|
x - 0.205 * k,
|
|
y + 0.212 * k
|
|
]).clipExtent([
|
|
[
|
|
x - 0.214 * k + 1e-6,
|
|
y + 0.166 * k + 1e-6
|
|
],
|
|
[
|
|
x - 0.115 * k - 1e-6,
|
|
y + 0.234 * k - 1e-6
|
|
]
|
|
]).stream(pointStream), reset();
|
|
}, albersUsa.fitExtent = function(extent, object) {
|
|
return fitExtent(albersUsa, extent, object);
|
|
}, albersUsa.fitSize = function(size, object) {
|
|
return fitSize(albersUsa, size, object);
|
|
}, albersUsa.fitWidth = function(width, object) {
|
|
return fitWidth(albersUsa, width, object);
|
|
}, albersUsa.fitHeight = function(height, object) {
|
|
return fitHeight(albersUsa, height, object);
|
|
}, albersUsa.scale(1070);
|
|
}, exports1.geoArea = function(object) {
|
|
return areaSum = new Adder(), geoStream(object, areaStream), 2 * areaSum;
|
|
}, exports1.geoAzimuthalEqualArea = function() {
|
|
return projection(azimuthalEqualAreaRaw).scale(124.75).clipAngle(179.999);
|
|
}, exports1.geoAzimuthalEqualAreaRaw = azimuthalEqualAreaRaw, exports1.geoAzimuthalEquidistant = function() {
|
|
return projection(azimuthalEquidistantRaw).scale(79.4188).clipAngle(179.999);
|
|
}, exports1.geoAzimuthalEquidistantRaw = azimuthalEquidistantRaw, exports1.geoBounds = function(feature) {
|
|
var i, n, a, b, merged, deltaMax, delta;
|
|
if (phi1 = lambda1 = -(lambda0$1 = phi0 = 1 / 0), ranges = [], geoStream(feature, boundsStream), n = ranges.length) {
|
|
for(ranges.sort(rangeCompare), i = 1, merged = [
|
|
a = ranges[0]
|
|
]; i < n; ++i)rangeContains(a, (b = ranges[i])[0]) || rangeContains(a, b[1]) ? (angle(a[0], b[1]) > angle(a[0], a[1]) && (a[1] = b[1]), angle(b[0], a[1]) > angle(a[0], a[1]) && (a[0] = b[0])) : merged.push(a = b);
|
|
for(deltaMax = -1 / 0, n = merged.length - 1, i = 0, a = merged[n]; i <= n; a = b, ++i)b = merged[i], (delta = angle(a[1], b[0])) > deltaMax && (deltaMax = delta, lambda0$1 = b[0], lambda1 = a[1]);
|
|
}
|
|
return ranges = range$1 = null, lambda0$1 === 1 / 0 || phi0 === 1 / 0 ? [
|
|
[
|
|
NaN,
|
|
NaN
|
|
],
|
|
[
|
|
NaN,
|
|
NaN
|
|
]
|
|
] : [
|
|
[
|
|
lambda0$1,
|
|
phi0
|
|
],
|
|
[
|
|
lambda1,
|
|
phi1
|
|
]
|
|
];
|
|
}, exports1.geoCentroid = function(object) {
|
|
W0 = W1 = X0 = Y0 = Z0 = X1 = Y1 = Z1 = 0, X2 = new Adder(), Y2 = new Adder(), Z2 = new Adder(), geoStream(object, centroidStream);
|
|
var x = +X2, y = +Y2, z = +Z2, m = hypot(x, y, z);
|
|
return m < 1e-12 && (x = X1, y = Y1, z = Z1, W1 < 1e-6 && (x = X0, y = Y0, z = Z0), (m = hypot(x, y, z)) < 1e-12) ? [
|
|
NaN,
|
|
NaN
|
|
] : [
|
|
atan2(y, x) * degrees$2,
|
|
asin(z / m) * degrees$2
|
|
];
|
|
}, exports1.geoCircle = function() {
|
|
var ring, rotate, center = constant$8([
|
|
0,
|
|
0
|
|
]), radius = constant$8(90), precision = constant$8(6), stream = {
|
|
point: function(x, y) {
|
|
ring.push(x = rotate(x, y)), x[0] *= degrees$2, x[1] *= degrees$2;
|
|
}
|
|
};
|
|
function circle() {
|
|
var c = center.apply(this, arguments), r = radius.apply(this, arguments) * radians$1, p = precision.apply(this, arguments) * radians$1;
|
|
return ring = [], rotate = rotateRadians(-c[0] * radians$1, -c[1] * radians$1, 0).invert, circleStream(stream, r, p, 1), c = {
|
|
type: "Polygon",
|
|
coordinates: [
|
|
ring
|
|
]
|
|
}, ring = rotate = null, c;
|
|
}
|
|
return circle.center = function(_) {
|
|
return arguments.length ? (center = "function" == typeof _ ? _ : constant$8([
|
|
+_[0],
|
|
+_[1]
|
|
]), circle) : center;
|
|
}, circle.radius = function(_) {
|
|
return arguments.length ? (radius = "function" == typeof _ ? _ : constant$8(+_), circle) : radius;
|
|
}, circle.precision = function(_) {
|
|
return arguments.length ? (precision = "function" == typeof _ ? _ : constant$8(+_), circle) : precision;
|
|
}, circle;
|
|
}, exports1.geoClipAntimeridian = clipAntimeridian, exports1.geoClipCircle = clipCircle, exports1.geoClipExtent = function() {
|
|
var cache, cacheStream, clip, x0 = 0, y0 = 0, x1 = 960, y1 = 500;
|
|
return clip = {
|
|
stream: function(stream) {
|
|
return cache && cacheStream === stream ? cache : cache = clipRectangle(x0, y0, x1, y1)(cacheStream = stream);
|
|
},
|
|
extent: function(_) {
|
|
return arguments.length ? (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1], cache = cacheStream = null, clip) : [
|
|
[
|
|
x0,
|
|
y0
|
|
],
|
|
[
|
|
x1,
|
|
y1
|
|
]
|
|
];
|
|
}
|
|
};
|
|
}, exports1.geoClipRectangle = clipRectangle, exports1.geoConicConformal = function() {
|
|
return conicProjection(conicConformalRaw).scale(109.5).parallels([
|
|
30,
|
|
30
|
|
]);
|
|
}, exports1.geoConicConformalRaw = conicConformalRaw, exports1.geoConicEqualArea = conicEqualArea, exports1.geoConicEqualAreaRaw = conicEqualAreaRaw, exports1.geoConicEquidistant = function() {
|
|
return conicProjection(conicEquidistantRaw).scale(131.154).center([
|
|
0,
|
|
13.9389
|
|
]);
|
|
}, exports1.geoConicEquidistantRaw = conicEquidistantRaw, exports1.geoContains = function(object, point) {
|
|
return (object && containsObjectType.hasOwnProperty(object.type) ? containsObjectType[object.type] : containsGeometry)(object, point);
|
|
}, exports1.geoDistance = distance, exports1.geoEqualEarth = function() {
|
|
return projection(equalEarthRaw).scale(177.158);
|
|
}, exports1.geoEqualEarthRaw = equalEarthRaw, exports1.geoEquirectangular = function() {
|
|
return projection(equirectangularRaw).scale(152.63);
|
|
}, exports1.geoEquirectangularRaw = equirectangularRaw, exports1.geoGnomonic = function() {
|
|
return projection(gnomonicRaw).scale(144.049).clipAngle(60);
|
|
}, exports1.geoGnomonicRaw = gnomonicRaw, exports1.geoGraticule = graticule, exports1.geoGraticule10 = function() {
|
|
return graticule()();
|
|
}, exports1.geoIdentity = function() {
|
|
var ca, sa, y0, x1, y1, cache, cacheStream, k = 1, tx = 0, ty = 0, sx = 1, sy = 1, alpha = 0, x0 = null, kx = 1, ky = 1, transform = transformer({
|
|
point: function(x, y) {
|
|
var p = projection([
|
|
x,
|
|
y
|
|
]);
|
|
this.stream.point(p[0], p[1]);
|
|
}
|
|
}), postclip = identity$4;
|
|
function reset() {
|
|
return kx = k * sx, ky = k * sy, cache = cacheStream = null, projection;
|
|
}
|
|
function projection(p) {
|
|
var x = p[0] * kx, y = p[1] * ky;
|
|
if (alpha) {
|
|
var t = y * ca - x * sa;
|
|
x = x * ca + y * sa, y = t;
|
|
}
|
|
return [
|
|
x + tx,
|
|
y + ty
|
|
];
|
|
}
|
|
return projection.invert = function(p) {
|
|
var x = p[0] - tx, y = p[1] - ty;
|
|
if (alpha) {
|
|
var t = y * ca + x * sa;
|
|
x = x * ca - y * sa, y = t;
|
|
}
|
|
return [
|
|
x / kx,
|
|
y / ky
|
|
];
|
|
}, projection.stream = function(stream) {
|
|
return cache && cacheStream === stream ? cache : cache = transform(postclip(cacheStream = stream));
|
|
}, projection.postclip = function(_) {
|
|
return arguments.length ? (postclip = _, x0 = y0 = x1 = y1 = null, reset()) : postclip;
|
|
}, projection.clipExtent = function(_) {
|
|
return arguments.length ? (postclip = null == _ ? (x0 = y0 = x1 = y1 = null, identity$4) : clipRectangle(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : null == x0 ? null : [
|
|
[
|
|
x0,
|
|
y0
|
|
],
|
|
[
|
|
x1,
|
|
y1
|
|
]
|
|
];
|
|
}, projection.scale = function(_) {
|
|
return arguments.length ? (k = +_, reset()) : k;
|
|
}, projection.translate = function(_) {
|
|
return arguments.length ? (tx = +_[0], ty = +_[1], reset()) : [
|
|
tx,
|
|
ty
|
|
];
|
|
}, projection.angle = function(_) {
|
|
return arguments.length ? (sa = sin$1(alpha = _ % 360 * radians$1), ca = cos$1(alpha), reset()) : alpha * degrees$2;
|
|
}, projection.reflectX = function(_) {
|
|
return arguments.length ? (sx = _ ? -1 : 1, reset()) : sx < 0;
|
|
}, projection.reflectY = function(_) {
|
|
return arguments.length ? (sy = _ ? -1 : 1, reset()) : sy < 0;
|
|
}, projection.fitExtent = function(extent, object) {
|
|
return fitExtent(projection, extent, object);
|
|
}, projection.fitSize = function(size, object) {
|
|
return fitSize(projection, size, object);
|
|
}, projection.fitWidth = function(width, object) {
|
|
return fitWidth(projection, width, object);
|
|
}, projection.fitHeight = function(height, object) {
|
|
return fitHeight(projection, height, object);
|
|
}, projection;
|
|
}, exports1.geoInterpolate = function(a, b) {
|
|
var x0 = a[0] * radians$1, y0 = a[1] * radians$1, x1 = b[0] * radians$1, y1 = b[1] * radians$1, cy0 = cos$1(y0), sy0 = sin$1(y0), cy1 = cos$1(y1), sy1 = sin$1(y1), kx0 = cy0 * cos$1(x0), ky0 = cy0 * sin$1(x0), kx1 = cy1 * cos$1(x1), ky1 = cy1 * sin$1(x1), d = 2 * asin(sqrt(haversin(y1 - y0) + cy0 * cy1 * haversin(x1 - x0))), k = sin$1(d), interpolate = d ? function(t) {
|
|
var B = sin$1(t *= d) / k, A = sin$1(d - t) / k, x = A * kx0 + B * kx1, y = A * ky0 + B * ky1;
|
|
return [
|
|
atan2(y, x) * degrees$2,
|
|
atan2(A * sy0 + B * sy1, sqrt(x * x + y * y)) * degrees$2
|
|
];
|
|
} : function() {
|
|
return [
|
|
x0 * degrees$2,
|
|
y0 * degrees$2
|
|
];
|
|
};
|
|
return interpolate.distance = d, interpolate;
|
|
}, exports1.geoLength = length$2, exports1.geoMercator = function() {
|
|
return mercatorProjection(mercatorRaw).scale(961 / tau$4);
|
|
}, exports1.geoMercatorRaw = mercatorRaw, exports1.geoNaturalEarth1 = function() {
|
|
return projection(naturalEarth1Raw).scale(175.295);
|
|
}, exports1.geoNaturalEarth1Raw = naturalEarth1Raw, exports1.geoOrthographic = function() {
|
|
return projection(orthographicRaw).scale(249.5).clipAngle(90.000001);
|
|
}, exports1.geoOrthographicRaw = orthographicRaw, exports1.geoPath = function(projection, context) {
|
|
var projectionStream, contextStream, pointRadius = 4.5;
|
|
function path(object) {
|
|
return object && ("function" == typeof pointRadius && contextStream.pointRadius(+pointRadius.apply(this, arguments)), geoStream(object, projectionStream(contextStream))), contextStream.result();
|
|
}
|
|
return path.area = function(object) {
|
|
return geoStream(object, projectionStream(areaStream$1)), areaStream$1.result();
|
|
}, path.measure = function(object) {
|
|
return geoStream(object, projectionStream(lengthStream$1)), lengthStream$1.result();
|
|
}, path.bounds = function(object) {
|
|
return geoStream(object, projectionStream(boundsStream$1)), boundsStream$1.result();
|
|
}, path.centroid = function(object) {
|
|
return geoStream(object, projectionStream(centroidStream$1)), centroidStream$1.result();
|
|
}, path.projection = function(_) {
|
|
return arguments.length ? (projectionStream = null == _ ? (projection = null, identity$4) : (projection = _).stream, path) : projection;
|
|
}, path.context = function(_) {
|
|
return arguments.length ? (contextStream = null == _ ? (context = null, new PathString) : new PathContext(context = _), "function" != typeof pointRadius && contextStream.pointRadius(pointRadius), path) : context;
|
|
}, path.pointRadius = function(_) {
|
|
return arguments.length ? (pointRadius = "function" == typeof _ ? _ : (contextStream.pointRadius(+_), +_), path) : pointRadius;
|
|
}, path.projection(projection).context(context);
|
|
}, exports1.geoProjection = projection, exports1.geoProjectionMutator = projectionMutator, exports1.geoRotation = rotation, exports1.geoStereographic = function() {
|
|
return projection(stereographicRaw).scale(250).clipAngle(142);
|
|
}, exports1.geoStereographicRaw = stereographicRaw, exports1.geoStream = geoStream, exports1.geoTransform = function(methods) {
|
|
return {
|
|
stream: transformer(methods)
|
|
};
|
|
}, exports1.geoTransverseMercator = function() {
|
|
var m = mercatorProjection(transverseMercatorRaw), center = m.center, rotate = m.rotate;
|
|
return m.center = function(_) {
|
|
return arguments.length ? center([
|
|
-_[1],
|
|
_[0]
|
|
]) : [
|
|
(_ = center())[1],
|
|
-_[0]
|
|
];
|
|
}, m.rotate = function(_) {
|
|
return arguments.length ? rotate([
|
|
_[0],
|
|
_[1],
|
|
_.length > 2 ? _[2] + 90 : 90
|
|
]) : [
|
|
(_ = rotate())[0],
|
|
_[1],
|
|
_[2] - 90
|
|
];
|
|
}, rotate([
|
|
0,
|
|
0,
|
|
90
|
|
]).scale(159.155);
|
|
}, exports1.geoTransverseMercatorRaw = transverseMercatorRaw, exports1.gray = function(l, opacity) {
|
|
return new Lab(l, 0, 0, null == opacity ? 1 : opacity);
|
|
}, exports1.greatest = function(values, compare = ascending) {
|
|
let max;
|
|
let defined = !1;
|
|
if (1 === compare.length) {
|
|
let maxValue;
|
|
for (const element of values){
|
|
const value = compare(element);
|
|
(defined ? ascending(value, maxValue) > 0 : 0 === ascending(value, value)) && (max = element, maxValue = value, defined = !0);
|
|
}
|
|
} else for (const value1 of values)(defined ? compare(value1, max) > 0 : 0 === compare(value1, value1)) && (max = value1, defined = !0);
|
|
return max;
|
|
}, exports1.greatestIndex = function(values, compare = ascending) {
|
|
let maxValue;
|
|
if (1 === compare.length) return maxIndex(values, compare);
|
|
let max = -1, index = -1;
|
|
for (const value of values)++index, (max < 0 ? 0 === compare(value, value) : compare(value, maxValue) > 0) && (maxValue = value, max = index);
|
|
return max;
|
|
}, exports1.group = function(values, ...keys) {
|
|
return nest(values, identity, identity, keys);
|
|
}, exports1.groups = function(values, ...keys) {
|
|
return nest(values, Array.from, identity, keys);
|
|
}, exports1.hcl = hcl, exports1.hierarchy = hierarchy, exports1.histogram = bin, exports1.hsl = hsl, exports1.html = html, exports1.image = function(input, init) {
|
|
return new Promise(function(resolve, reject) {
|
|
var image = new Image;
|
|
for(var key in init)image[key] = init[key];
|
|
image.onerror = reject, image.onload = function() {
|
|
resolve(image);
|
|
}, image.src = input;
|
|
});
|
|
}, exports1.index = function(values, ...keys) {
|
|
return nest(values, identity, unique, keys);
|
|
}, exports1.indexes = function(values, ...keys) {
|
|
return nest(values, Array.from, unique, keys);
|
|
}, exports1.interpolate = interpolate, exports1.interpolateArray = function(a, b) {
|
|
return (isNumberArray(b) ? numberArray : genericArray)(a, b);
|
|
}, exports1.interpolateBasis = basis$1, exports1.interpolateBasisClosed = basisClosed, exports1.interpolateBlues = Blues, exports1.interpolateBrBG = BrBG, exports1.interpolateBuGn = BuGn, exports1.interpolateBuPu = BuPu, exports1.interpolateCividis = function(t) {
|
|
return "rgb(" + Math.max(0, Math.min(255, Math.round(-4.54 - (t = Math.max(0, Math.min(1, t))) * (35.34 - t * (2381.73 - t * (6402.7 - t * (7024.72 - 2710.57 * t))))))) + ", " + Math.max(0, Math.min(255, Math.round(32.49 + t * (170.73 + t * (52.82 - t * (131.46 - t * (176.58 - 67.37 * t))))))) + ", " + Math.max(0, Math.min(255, Math.round(81.24 + t * (442.36 - t * (2482.43 - t * (6167.24 - t * (6614.94 - 2475.67 * t))))))) + ")";
|
|
}, exports1.interpolateCool = cool, exports1.interpolateCubehelix = cubehelix$2, exports1.interpolateCubehelixDefault = cubehelix$3, exports1.interpolateCubehelixLong = cubehelixLong, exports1.interpolateDate = date, exports1.interpolateDiscrete = function(range) {
|
|
var n = range.length;
|
|
return function(t) {
|
|
return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))];
|
|
};
|
|
}, exports1.interpolateGnBu = GnBu, exports1.interpolateGreens = Greens, exports1.interpolateGreys = Greys, exports1.interpolateHcl = hcl$2, exports1.interpolateHclLong = hclLong, exports1.interpolateHsl = hsl$2, exports1.interpolateHslLong = hslLong, exports1.interpolateHue = function(a, b) {
|
|
var i = hue(+a, +b);
|
|
return function(t) {
|
|
var x = i(t);
|
|
return x - 360 * Math.floor(x / 360);
|
|
};
|
|
}, exports1.interpolateInferno = inferno, exports1.interpolateLab = function(start, end) {
|
|
var l = nogamma((start = lab(start)).l, (end = lab(end)).l), a = nogamma(start.a, end.a), b = nogamma(start.b, end.b), opacity = nogamma(start.opacity, end.opacity);
|
|
return function(t) {
|
|
return start.l = l(t), start.a = a(t), start.b = b(t), start.opacity = opacity(t), start + "";
|
|
};
|
|
}, exports1.interpolateMagma = magma, exports1.interpolateNumber = interpolateNumber, exports1.interpolateNumberArray = numberArray, exports1.interpolateObject = object, exports1.interpolateOrRd = OrRd, exports1.interpolateOranges = Oranges, exports1.interpolatePRGn = PRGn, exports1.interpolatePiYG = PiYG, exports1.interpolatePlasma = plasma, exports1.interpolatePuBu = PuBu, exports1.interpolatePuBuGn = PuBuGn, exports1.interpolatePuOr = PuOr, exports1.interpolatePuRd = PuRd, exports1.interpolatePurples = Purples, exports1.interpolateRainbow = function(t) {
|
|
(t < 0 || t > 1) && (t -= Math.floor(t));
|
|
var ts = Math.abs(t - 0.5);
|
|
return c$1.h = 360 * t - 100, c$1.s = 1.5 - 1.5 * ts, c$1.l = 0.8 - 0.9 * ts, c$1 + "";
|
|
}, exports1.interpolateRdBu = RdBu, exports1.interpolateRdGy = RdGy, exports1.interpolateRdPu = RdPu, exports1.interpolateRdYlBu = RdYlBu, exports1.interpolateRdYlGn = RdYlGn, exports1.interpolateReds = Reds, exports1.interpolateRgb = interpolateRgb, exports1.interpolateRgbBasis = rgbBasis, exports1.interpolateRgbBasisClosed = rgbBasisClosed, exports1.interpolateRound = interpolateRound, exports1.interpolateSinebow = function(t) {
|
|
var x;
|
|
return t = (0.5 - t) * Math.PI, c$2.r = 255 * (x = Math.sin(t)) * x, c$2.g = 255 * (x = Math.sin(t + pi_1_3)) * x, c$2.b = 255 * (x = Math.sin(t + pi_2_3)) * x, c$2 + "";
|
|
}, exports1.interpolateSpectral = Spectral, exports1.interpolateString = interpolateString, exports1.interpolateTransformCss = interpolateTransformCss, exports1.interpolateTransformSvg = interpolateTransformSvg, exports1.interpolateTurbo = function(t) {
|
|
return "rgb(" + Math.max(0, Math.min(255, Math.round(34.61 + (t = Math.max(0, Math.min(1, t))) * (1172.33 - t * (10793.56 - t * (33300.12 - t * (38394.49 - 14825.05 * t))))))) + ", " + Math.max(0, Math.min(255, Math.round(23.31 + t * (557.33 + t * (1225.33 - t * (3574.96 - t * (1073.77 + 707.56 * t))))))) + ", " + Math.max(0, Math.min(255, Math.round(27.2 + t * (3211.1 - t * (15327.97 - t * (27814 - t * (22569.18 - 6838.66 * t))))))) + ")";
|
|
}, exports1.interpolateViridis = viridis, exports1.interpolateWarm = warm, exports1.interpolateYlGn = YlGn, exports1.interpolateYlGnBu = YlGnBu, exports1.interpolateYlOrBr = YlOrBr, exports1.interpolateYlOrRd = YlOrRd, exports1.interpolateZoom = interpolateZoom, exports1.interrupt = interrupt, exports1.intersection = function(values, ...others) {
|
|
values = new Set(values), others = others.map(set);
|
|
out: for (const value of values)for (const other of others)if (!other.has(value)) {
|
|
values.delete(value);
|
|
continue out;
|
|
}
|
|
return values;
|
|
}, exports1.interval = function(callback, delay, time) {
|
|
var t = new Timer, total = delay;
|
|
return null == delay ? (t.restart(callback, delay, time), t) : (t._restart = t.restart, t.restart = function(callback, delay, time) {
|
|
delay = +delay, time = null == time ? now() : +time, t._restart(function tick(elapsed) {
|
|
elapsed += total, t._restart(tick, total += delay, time), callback(elapsed);
|
|
}, delay, time);
|
|
}, t.restart(callback, delay, time), t);
|
|
}, exports1.isoFormat = formatIso, exports1.isoParse = parseIso, exports1.json = function(input, init) {
|
|
return fetch(input, init).then(responseJson);
|
|
}, exports1.lab = lab, exports1.lch = function(l, c, h, opacity) {
|
|
return 1 === arguments.length ? hclConvert(l) : new Hcl(h, c, l, null == opacity ? 1 : opacity);
|
|
}, exports1.least = function(values, compare = ascending) {
|
|
let min;
|
|
let defined = !1;
|
|
if (1 === compare.length) {
|
|
let minValue;
|
|
for (const element of values){
|
|
const value = compare(element);
|
|
(defined ? 0 > ascending(value, minValue) : 0 === ascending(value, value)) && (min = element, minValue = value, defined = !0);
|
|
}
|
|
} else for (const value1 of values)(defined ? 0 > compare(value1, min) : 0 === compare(value1, value1)) && (min = value1, defined = !0);
|
|
return min;
|
|
}, exports1.leastIndex = leastIndex, exports1.line = line, exports1.lineRadial = lineRadial$1, exports1.linkHorizontal = function() {
|
|
return link$2(curveHorizontal);
|
|
}, exports1.linkRadial = function() {
|
|
var l = link$2(curveRadial$1);
|
|
return l.angle = l.x, delete l.x, l.radius = l.y, delete l.y, l;
|
|
}, exports1.linkVertical = function() {
|
|
return link$2(curveVertical);
|
|
}, exports1.local = local, exports1.map = function(values, mapper) {
|
|
if ("function" != typeof values[Symbol.iterator]) throw TypeError("values is not iterable");
|
|
if ("function" != typeof mapper) throw TypeError("mapper is not a function");
|
|
return Array.from(values, (value, index)=>mapper(value, index, values));
|
|
}, exports1.matcher = matcher, exports1.max = max, exports1.maxIndex = maxIndex, exports1.mean = function(values, valueof) {
|
|
let count = 0, sum = 0;
|
|
if (void 0 === valueof) for (let value of values)null != value && (value = +value) >= value && (++count, sum += value);
|
|
else {
|
|
let index = -1;
|
|
for (let value1 of values)null != (value1 = valueof(value1, ++index, values)) && (value1 = +value1) >= value1 && (++count, sum += value1);
|
|
}
|
|
if (count) return sum / count;
|
|
}, exports1.median = function(values, valueof) {
|
|
return quantile(values, 0.5, valueof);
|
|
}, exports1.merge = merge, exports1.min = min, exports1.minIndex = minIndex, exports1.namespace = namespace, exports1.namespaces = namespaces, exports1.nice = nice, exports1.now = now, exports1.pack = function() {
|
|
var radius = null, dx = 1, dy = 1, padding = constantZero;
|
|
function pack(root) {
|
|
return root.x = dx / 2, root.y = dy / 2, radius ? root.eachBefore(radiusLeaf(radius)).eachAfter(packChildren(padding, 0.5)).eachBefore(translateChild(1)) : root.eachBefore(radiusLeaf(defaultRadius$1)).eachAfter(packChildren(constantZero, 1)).eachAfter(packChildren(padding, root.r / Math.min(dx, dy))).eachBefore(translateChild(Math.min(dx, dy) / (2 * root.r))), root;
|
|
}
|
|
return pack.radius = function(x) {
|
|
var f;
|
|
return arguments.length ? (radius = null == x ? null : required(x), pack) : radius;
|
|
}, pack.size = function(x) {
|
|
return arguments.length ? (dx = +x[0], dy = +x[1], pack) : [
|
|
dx,
|
|
dy
|
|
];
|
|
}, pack.padding = function(x) {
|
|
return arguments.length ? (padding = "function" == typeof x ? x : constant$9(+x), pack) : padding;
|
|
}, pack;
|
|
}, exports1.packEnclose = enclose, exports1.packSiblings = function(circles) {
|
|
return packEnclose(circles), circles;
|
|
}, exports1.pairs = function(values, pairof = pair) {
|
|
let previous;
|
|
const pairs = [];
|
|
let first = !1;
|
|
for (const value of values)first && pairs.push(pairof(previous, value)), previous = value, first = !0;
|
|
return pairs;
|
|
}, exports1.partition = function() {
|
|
var dx = 1, dy = 1, padding = 0, round = !1;
|
|
function partition(root) {
|
|
var dy1, n, n1 = root.height + 1;
|
|
return root.x0 = root.y0 = padding, root.x1 = dx, root.y1 = dy / n1, root.eachBefore((dy1 = dy, n = n1, function(node) {
|
|
node.children && treemapDice(node, node.x0, dy1 * (node.depth + 1) / n, node.x1, dy1 * (node.depth + 2) / n);
|
|
var x0 = node.x0, y0 = node.y0, x1 = node.x1 - padding, y1 = node.y1 - padding;
|
|
x1 < x0 && (x0 = x1 = (x0 + x1) / 2), y1 < y0 && (y0 = y1 = (y0 + y1) / 2), node.x0 = x0, node.y0 = y0, node.x1 = x1, node.y1 = y1;
|
|
})), round && root.eachBefore(roundNode), root;
|
|
}
|
|
return partition.round = function(x) {
|
|
return arguments.length ? (round = !!x, partition) : round;
|
|
}, partition.size = function(x) {
|
|
return arguments.length ? (dx = +x[0], dy = +x[1], partition) : [
|
|
dx,
|
|
dy
|
|
];
|
|
}, partition.padding = function(x) {
|
|
return arguments.length ? (padding = +x, partition) : padding;
|
|
}, partition;
|
|
}, exports1.path = path, exports1.permute = permute, exports1.pie = function() {
|
|
var value = identity$8, sortValues = descending$1, sort = null, startAngle = constant$a(0), endAngle = constant$a(tau$5), padAngle = constant$a(0);
|
|
function pie(data) {
|
|
var i, j, k, a1, v, n = (data = array$5(data)).length, sum = 0, index = Array(n), arcs = Array(n), a0 = +startAngle.apply(this, arguments), da = Math.min(tau$5, Math.max(-tau$5, endAngle.apply(this, arguments) - a0)), p = Math.min(Math.abs(da) / n, padAngle.apply(this, arguments)), pa = p * (da < 0 ? -1 : 1);
|
|
for(i = 0; i < n; ++i)(v = arcs[index[i] = i] = +value(data[i], i, data)) > 0 && (sum += v);
|
|
for(null != sortValues ? index.sort(function(i, j) {
|
|
return sortValues(arcs[i], arcs[j]);
|
|
}) : null != sort && index.sort(function(i, j) {
|
|
return sort(data[i], data[j]);
|
|
}), i = 0, k = sum ? (da - n * pa) / sum : 0; i < n; ++i, a0 = a1)a1 = a0 + ((v = arcs[j = index[i]]) > 0 ? v * k : 0) + pa, arcs[j] = {
|
|
data: data[j],
|
|
index: i,
|
|
value: v,
|
|
startAngle: a0,
|
|
endAngle: a1,
|
|
padAngle: p
|
|
};
|
|
return arcs;
|
|
}
|
|
return pie.value = function(_) {
|
|
return arguments.length ? (value = "function" == typeof _ ? _ : constant$a(+_), pie) : value;
|
|
}, pie.sortValues = function(_) {
|
|
return arguments.length ? (sortValues = _, sort = null, pie) : sortValues;
|
|
}, pie.sort = function(_) {
|
|
return arguments.length ? (sort = _, sortValues = null, pie) : sort;
|
|
}, pie.startAngle = function(_) {
|
|
return arguments.length ? (startAngle = "function" == typeof _ ? _ : constant$a(+_), pie) : startAngle;
|
|
}, pie.endAngle = function(_) {
|
|
return arguments.length ? (endAngle = "function" == typeof _ ? _ : constant$a(+_), pie) : endAngle;
|
|
}, pie.padAngle = function(_) {
|
|
return arguments.length ? (padAngle = "function" == typeof _ ? _ : constant$a(+_), pie) : padAngle;
|
|
}, pie;
|
|
}, exports1.piecewise = piecewise, exports1.pointRadial = pointRadial, exports1.pointer = pointer, exports1.pointers = function(events, node) {
|
|
return events.target && (events = sourceEvent(events), void 0 === node && (node = events.currentTarget), events = events.touches || [
|
|
events
|
|
]), Array.from(events, (event)=>pointer(event, node));
|
|
}, exports1.polygonArea = function(polygon) {
|
|
for(var a, i = -1, n = polygon.length, b = polygon[n - 1], area = 0; ++i < n;)a = b, b = polygon[i], area += a[1] * b[0] - a[0] * b[1];
|
|
return area / 2;
|
|
}, exports1.polygonCentroid = function(polygon) {
|
|
for(var a, c, i = -1, n = polygon.length, x = 0, y = 0, b = polygon[n - 1], k = 0; ++i < n;)a = b, b = polygon[i], k += c = a[0] * b[1] - b[0] * a[1], x += (a[0] + b[0]) * c, y += (a[1] + b[1]) * c;
|
|
return [
|
|
x / (k *= 3),
|
|
y / k
|
|
];
|
|
}, exports1.polygonContains = function(polygon, point) {
|
|
for(var x1, y1, n = polygon.length, p = polygon[n - 1], x = point[0], y = point[1], x0 = p[0], y0 = p[1], inside = !1, i = 0; i < n; ++i)x1 = (p = polygon[i])[0], (y1 = p[1]) > y != y0 > y && x < (x0 - x1) * (y - y1) / (y0 - y1) + x1 && (inside = !inside), x0 = x1, y0 = y1;
|
|
return inside;
|
|
}, exports1.polygonHull = function(points) {
|
|
if ((n = points.length) < 3) return null;
|
|
var i, n, sortedPoints = Array(n), flippedPoints = Array(n);
|
|
for(i = 0; i < n; ++i)sortedPoints[i] = [
|
|
+points[i][0],
|
|
+points[i][1],
|
|
i
|
|
];
|
|
for(sortedPoints.sort(lexicographicOrder), i = 0; i < n; ++i)flippedPoints[i] = [
|
|
sortedPoints[i][0],
|
|
-sortedPoints[i][1]
|
|
];
|
|
var upperIndexes = computeUpperHullIndexes(sortedPoints), lowerIndexes = computeUpperHullIndexes(flippedPoints), skipLeft = lowerIndexes[0] === upperIndexes[0], skipRight = lowerIndexes[lowerIndexes.length - 1] === upperIndexes[upperIndexes.length - 1], hull = [];
|
|
for(i = upperIndexes.length - 1; i >= 0; --i)hull.push(points[sortedPoints[upperIndexes[i]][2]]);
|
|
for(i = +skipLeft; i < lowerIndexes.length - skipRight; ++i)hull.push(points[sortedPoints[lowerIndexes[i]][2]]);
|
|
return hull;
|
|
}, exports1.polygonLength = function(polygon) {
|
|
for(var xa, ya, i = -1, n = polygon.length, b = polygon[n - 1], xb = b[0], yb = b[1], perimeter = 0; ++i < n;)xa = xb, ya = yb, xb = (b = polygon[i])[0], yb = b[1], xa -= xb, ya -= yb, perimeter += Math.hypot(xa, ya);
|
|
return perimeter;
|
|
}, exports1.precisionFixed = precisionFixed, exports1.precisionPrefix = precisionPrefix, exports1.precisionRound = precisionRound, exports1.quadtree = quadtree, exports1.quantile = quantile, exports1.quantileSorted = quantileSorted, exports1.quantize = function(interpolator, n) {
|
|
for(var samples = Array(n), i = 0; i < n; ++i)samples[i] = interpolator(i / (n - 1));
|
|
return samples;
|
|
}, exports1.quickselect = quickselect, exports1.radialArea = areaRadial, exports1.radialLine = lineRadial$1, exports1.randomBates = bates, exports1.randomBernoulli = bernoulli, exports1.randomBeta = beta, exports1.randomBinomial = binomial, exports1.randomCauchy = cauchy, exports1.randomExponential = exponential$1, exports1.randomGamma = gamma$1, exports1.randomGeometric = geometric, exports1.randomInt = int, exports1.randomIrwinHall = irwinHall, exports1.randomLcg = function(seed = Math.random()) {
|
|
let state = (0 <= seed && seed < 1 ? seed / eps : Math.abs(seed)) | 0;
|
|
return ()=>eps * ((state = 0x19660D * state + 0x3C6EF35F | 0) >>> 0);
|
|
}, exports1.randomLogNormal = logNormal, exports1.randomLogistic = logistic, exports1.randomNormal = normal, exports1.randomPareto = pareto, exports1.randomPoisson = poisson, exports1.randomUniform = uniform, exports1.randomWeibull = weibull, exports1.range = sequence, exports1.reduce = function(values, reducer, value) {
|
|
if ("function" != typeof reducer) throw TypeError("reducer is not a function");
|
|
const iterator = values[Symbol.iterator]();
|
|
let done, next, index = -1;
|
|
if (arguments.length < 3) {
|
|
if ({ done , value } = iterator.next(), done) return;
|
|
++index;
|
|
}
|
|
for(; { done , value: next } = iterator.next(), !done;)value = reducer(value, next, ++index, values);
|
|
return value;
|
|
}, exports1.reverse = function(values) {
|
|
if ("function" != typeof values[Symbol.iterator]) throw TypeError("values is not iterable");
|
|
return Array.from(values).reverse();
|
|
}, exports1.rgb = rgb, exports1.ribbon = function() {
|
|
return ribbon();
|
|
}, exports1.ribbonArrow = function() {
|
|
return ribbon(defaultArrowheadRadius);
|
|
}, exports1.rollup = function(values, reduce, ...keys) {
|
|
return nest(values, identity, reduce, keys);
|
|
}, exports1.rollups = function(values, reduce, ...keys) {
|
|
return nest(values, Array.from, reduce, keys);
|
|
}, exports1.scaleBand = band, exports1.scaleDiverging = function diverging() {
|
|
var scale = linearish(transformer$3()(identity$6));
|
|
return scale.copy = function() {
|
|
return copy$1(scale, diverging());
|
|
}, initInterpolator.apply(scale, arguments);
|
|
}, exports1.scaleDivergingLog = function divergingLog() {
|
|
var scale = loggish(transformer$3()).domain([
|
|
0.1,
|
|
1,
|
|
10
|
|
]);
|
|
return scale.copy = function() {
|
|
return copy$1(scale, divergingLog()).base(scale.base());
|
|
}, initInterpolator.apply(scale, arguments);
|
|
}, exports1.scaleDivergingPow = divergingPow, exports1.scaleDivergingSqrt = function() {
|
|
return divergingPow.apply(null, arguments).exponent(0.5);
|
|
}, exports1.scaleDivergingSymlog = function divergingSymlog() {
|
|
var scale = symlogish(transformer$3());
|
|
return scale.copy = function() {
|
|
return copy$1(scale, divergingSymlog()).constant(scale.constant());
|
|
}, initInterpolator.apply(scale, arguments);
|
|
}, exports1.scaleIdentity = function identity$7(domain) {
|
|
var unknown;
|
|
function scale(x) {
|
|
return isNaN(x = +x) ? unknown : x;
|
|
}
|
|
return scale.invert = scale, scale.domain = scale.range = function(_) {
|
|
return arguments.length ? (domain = Array.from(_, number$2), scale) : domain.slice();
|
|
}, scale.unknown = function(_) {
|
|
return arguments.length ? (unknown = _, scale) : unknown;
|
|
}, scale.copy = function() {
|
|
return identity$7(domain).unknown(unknown);
|
|
}, domain = arguments.length ? Array.from(domain, number$2) : [
|
|
0,
|
|
1
|
|
], linearish(scale);
|
|
}, exports1.scaleImplicit = implicit, exports1.scaleLinear = function linear$2() {
|
|
var scale = continuous();
|
|
return scale.copy = function() {
|
|
return copy(scale, linear$2());
|
|
}, initRange.apply(scale, arguments), linearish(scale);
|
|
}, exports1.scaleLog = function log$1() {
|
|
var scale = loggish(transformer$1()).domain([
|
|
1,
|
|
10
|
|
]);
|
|
return scale.copy = function() {
|
|
return copy(scale, log$1()).base(scale.base());
|
|
}, initRange.apply(scale, arguments), scale;
|
|
}, exports1.scaleOrdinal = ordinal, exports1.scalePoint = function() {
|
|
return function pointish(scale) {
|
|
var copy = scale.copy;
|
|
return scale.padding = scale.paddingOuter, delete scale.paddingInner, delete scale.paddingOuter, scale.copy = function() {
|
|
return pointish(copy());
|
|
}, scale;
|
|
}(band.apply(null, arguments).paddingInner(1));
|
|
}, exports1.scalePow = pow$2, exports1.scaleQuantile = function quantile$1() {
|
|
var unknown, domain = [], range = [], thresholds = [];
|
|
function rescale() {
|
|
var i = 0, n = Math.max(1, range.length);
|
|
for(thresholds = Array(n - 1); ++i < n;)thresholds[i - 1] = quantileSorted(domain, i / n);
|
|
return scale;
|
|
}
|
|
function scale(x) {
|
|
return isNaN(x = +x) ? unknown : range[bisectRight(thresholds, x)];
|
|
}
|
|
return scale.invertExtent = function(y) {
|
|
var i = range.indexOf(y);
|
|
return i < 0 ? [
|
|
NaN,
|
|
NaN
|
|
] : [
|
|
i > 0 ? thresholds[i - 1] : domain[0],
|
|
i < thresholds.length ? thresholds[i] : domain[domain.length - 1]
|
|
];
|
|
}, scale.domain = function(_) {
|
|
if (!arguments.length) return domain.slice();
|
|
for (let d of (domain = [], _))null == d || isNaN(d = +d) || domain.push(d);
|
|
return domain.sort(ascending), rescale();
|
|
}, scale.range = function(_) {
|
|
return arguments.length ? (range = Array.from(_), rescale()) : range.slice();
|
|
}, scale.unknown = function(_) {
|
|
return arguments.length ? (unknown = _, scale) : unknown;
|
|
}, scale.quantiles = function() {
|
|
return thresholds.slice();
|
|
}, scale.copy = function() {
|
|
return quantile$1().domain(domain).range(range).unknown(unknown);
|
|
}, initRange.apply(scale, arguments);
|
|
}, exports1.scaleQuantize = function quantize$1() {
|
|
var unknown, x0 = 0, x1 = 1, n = 1, domain = [
|
|
0.5
|
|
], range = [
|
|
0,
|
|
1
|
|
];
|
|
function scale(x) {
|
|
return x <= x ? range[bisectRight(domain, x, 0, n)] : unknown;
|
|
}
|
|
function rescale() {
|
|
var i = -1;
|
|
for(domain = Array(n); ++i < n;)domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1);
|
|
return scale;
|
|
}
|
|
return scale.domain = function(_) {
|
|
return arguments.length ? ([x0, x1] = _, x0 = +x0, x1 = +x1, rescale()) : [
|
|
x0,
|
|
x1
|
|
];
|
|
}, scale.range = function(_) {
|
|
return arguments.length ? (n = (range = Array.from(_)).length - 1, rescale()) : range.slice();
|
|
}, scale.invertExtent = function(y) {
|
|
var i = range.indexOf(y);
|
|
return i < 0 ? [
|
|
NaN,
|
|
NaN
|
|
] : i < 1 ? [
|
|
x0,
|
|
domain[0]
|
|
] : i >= n ? [
|
|
domain[n - 1],
|
|
x1
|
|
] : [
|
|
domain[i - 1],
|
|
domain[i]
|
|
];
|
|
}, scale.unknown = function(_) {
|
|
return arguments.length && (unknown = _), scale;
|
|
}, scale.thresholds = function() {
|
|
return domain.slice();
|
|
}, scale.copy = function() {
|
|
return quantize$1().domain([
|
|
x0,
|
|
x1
|
|
]).range(range).unknown(unknown);
|
|
}, initRange.apply(linearish(scale), arguments);
|
|
}, exports1.scaleRadial = function radial$1() {
|
|
var unknown, squared = continuous(), range = [
|
|
0,
|
|
1
|
|
], round = !1;
|
|
function scale(x) {
|
|
var x1, y = Math.sign(x1 = squared(x)) * Math.sqrt(Math.abs(x1));
|
|
return isNaN(y) ? unknown : round ? Math.round(y) : y;
|
|
}
|
|
return scale.invert = function(y) {
|
|
return squared.invert(square(y));
|
|
}, scale.domain = function(_) {
|
|
return arguments.length ? (squared.domain(_), scale) : squared.domain();
|
|
}, scale.range = function(_) {
|
|
return arguments.length ? (squared.range((range = Array.from(_, number$2)).map(square)), scale) : range.slice();
|
|
}, scale.rangeRound = function(_) {
|
|
return scale.range(_).round(!0);
|
|
}, scale.round = function(_) {
|
|
return arguments.length ? (round = !!_, scale) : round;
|
|
}, scale.clamp = function(_) {
|
|
return arguments.length ? (squared.clamp(_), scale) : squared.clamp();
|
|
}, scale.unknown = function(_) {
|
|
return arguments.length ? (unknown = _, scale) : unknown;
|
|
}, scale.copy = function() {
|
|
return radial$1(squared.domain(), range).round(round).clamp(squared.clamp()).unknown(unknown);
|
|
}, initRange.apply(scale, arguments), linearish(scale);
|
|
}, exports1.scaleSequential = function sequential() {
|
|
var scale = linearish(transformer$2()(identity$6));
|
|
return scale.copy = function() {
|
|
return copy$1(scale, sequential());
|
|
}, initInterpolator.apply(scale, arguments);
|
|
}, exports1.scaleSequentialLog = function sequentialLog() {
|
|
var scale = loggish(transformer$2()).domain([
|
|
1,
|
|
10
|
|
]);
|
|
return scale.copy = function() {
|
|
return copy$1(scale, sequentialLog()).base(scale.base());
|
|
}, initInterpolator.apply(scale, arguments);
|
|
}, exports1.scaleSequentialPow = sequentialPow, exports1.scaleSequentialQuantile = function sequentialQuantile() {
|
|
var domain = [], interpolator = identity$6;
|
|
function scale(x) {
|
|
if (!isNaN(x = +x)) return interpolator((bisectRight(domain, x, 1) - 1) / (domain.length - 1));
|
|
}
|
|
return scale.domain = function(_) {
|
|
if (!arguments.length) return domain.slice();
|
|
for (let d of (domain = [], _))null == d || isNaN(d = +d) || domain.push(d);
|
|
return domain.sort(ascending), scale;
|
|
}, scale.interpolator = function(_) {
|
|
return arguments.length ? (interpolator = _, scale) : interpolator;
|
|
}, scale.range = function() {
|
|
return domain.map((d, i)=>interpolator(i / (domain.length - 1)));
|
|
}, scale.quantiles = function(n) {
|
|
return Array.from({
|
|
length: n + 1
|
|
}, (_, i)=>quantile(domain, i / n));
|
|
}, scale.copy = function() {
|
|
return sequentialQuantile(interpolator).domain(domain);
|
|
}, initInterpolator.apply(scale, arguments);
|
|
}, exports1.scaleSequentialSqrt = function() {
|
|
return sequentialPow.apply(null, arguments).exponent(0.5);
|
|
}, exports1.scaleSequentialSymlog = function sequentialSymlog() {
|
|
var scale = symlogish(transformer$2());
|
|
return scale.copy = function() {
|
|
return copy$1(scale, sequentialSymlog()).constant(scale.constant());
|
|
}, initInterpolator.apply(scale, arguments);
|
|
}, exports1.scaleSqrt = function() {
|
|
return pow$2.apply(null, arguments).exponent(0.5);
|
|
}, exports1.scaleSymlog = function symlog() {
|
|
var scale = symlogish(transformer$1());
|
|
return scale.copy = function() {
|
|
return copy(scale, symlog()).constant(scale.constant());
|
|
}, initRange.apply(scale, arguments);
|
|
}, exports1.scaleThreshold = function threshold() {
|
|
var unknown, domain = [
|
|
0.5
|
|
], range = [
|
|
0,
|
|
1
|
|
], n = 1;
|
|
function scale(x) {
|
|
return x <= x ? range[bisectRight(domain, x, 0, n)] : unknown;
|
|
}
|
|
return scale.domain = function(_) {
|
|
return arguments.length ? (n = Math.min((domain = Array.from(_)).length, range.length - 1), scale) : domain.slice();
|
|
}, scale.range = function(_) {
|
|
return arguments.length ? (range = Array.from(_), n = Math.min(domain.length, range.length - 1), scale) : range.slice();
|
|
}, scale.invertExtent = function(y) {
|
|
var i = range.indexOf(y);
|
|
return [
|
|
domain[i - 1],
|
|
domain[i]
|
|
];
|
|
}, scale.unknown = function(_) {
|
|
return arguments.length ? (unknown = _, scale) : unknown;
|
|
}, scale.copy = function() {
|
|
return threshold().domain(domain).range(range).unknown(unknown);
|
|
}, initRange.apply(scale, arguments);
|
|
}, exports1.scaleTime = function() {
|
|
return initRange.apply(calendar(year, month, sunday, day, hour, minute, second, millisecond, exports1.timeFormat).domain([
|
|
new Date(2000, 0, 1),
|
|
new Date(2000, 0, 2)
|
|
]), arguments);
|
|
}, exports1.scaleUtc = function() {
|
|
return initRange.apply(calendar(utcYear, utcMonth, utcSunday, utcDay, utcHour, utcMinute, second, millisecond, exports1.utcFormat).domain([
|
|
Date.UTC(2000, 0, 1),
|
|
Date.UTC(2000, 0, 2)
|
|
]), arguments);
|
|
}, exports1.scan = function(values, compare) {
|
|
const index = leastIndex(values, compare);
|
|
return index < 0 ? void 0 : index;
|
|
}, exports1.schemeAccent = Accent, exports1.schemeBlues = scheme$l, exports1.schemeBrBG = scheme, exports1.schemeBuGn = scheme$9, exports1.schemeBuPu = scheme$a, exports1.schemeCategory10 = category10, exports1.schemeDark2 = Dark2, exports1.schemeGnBu = scheme$b, exports1.schemeGreens = scheme$m, exports1.schemeGreys = scheme$n, exports1.schemeOrRd = scheme$c, exports1.schemeOranges = scheme$q, exports1.schemePRGn = scheme$1, exports1.schemePaired = Paired, exports1.schemePastel1 = Pastel1, exports1.schemePastel2 = Pastel2, exports1.schemePiYG = scheme$2, exports1.schemePuBu = scheme$e, exports1.schemePuBuGn = scheme$d, exports1.schemePuOr = scheme$3, exports1.schemePuRd = scheme$f, exports1.schemePurples = scheme$o, exports1.schemeRdBu = scheme$4, exports1.schemeRdGy = scheme$5, exports1.schemeRdPu = scheme$g, exports1.schemeRdYlBu = scheme$6, exports1.schemeRdYlGn = scheme$7, exports1.schemeReds = scheme$p, exports1.schemeSet1 = Set1, exports1.schemeSet2 = Set2, exports1.schemeSet3 = Set3, exports1.schemeSpectral = scheme$8, exports1.schemeTableau10 = Tableau10, exports1.schemeYlGn = scheme$i, exports1.schemeYlGnBu = scheme$h, exports1.schemeYlOrBr = scheme$j, exports1.schemeYlOrRd = scheme$k, exports1.select = select, exports1.selectAll = function(selector) {
|
|
return "string" == typeof selector ? new Selection([
|
|
document.querySelectorAll(selector)
|
|
], [
|
|
document.documentElement
|
|
]) : new Selection([
|
|
null == selector ? [] : array$1(selector)
|
|
], root);
|
|
}, exports1.selection = selection, exports1.selector = selector, exports1.selectorAll = selectorAll, exports1.shuffle = shuffle, exports1.shuffler = shuffler, exports1.some = function(values, test) {
|
|
if ("function" != typeof test) throw TypeError("test is not a function");
|
|
let index = -1;
|
|
for (const value of values)if (test(value, ++index, values)) return !0;
|
|
return !1;
|
|
}, exports1.sort = function(values, f = ascending) {
|
|
if ("function" != typeof values[Symbol.iterator]) throw TypeError("values is not iterable");
|
|
return (values = Array.from(values), 1 === f.length) ? (f = values.map(f), permute(values, values.map((d, i)=>i).sort((i, j)=>ascending(f[i], f[j])))) : values.sort(f);
|
|
}, exports1.stack = function() {
|
|
var keys = constant$a([]), order = none$2, offset = none$1, value = stackValue;
|
|
function stack(data) {
|
|
var i, oz, sz = Array.from(keys.apply(this, arguments), stackSeries), n = sz.length, j = -1;
|
|
for (const d of data)for(i = 0, ++j; i < n; ++i)(sz[i][j] = [
|
|
0,
|
|
+value(d, sz[i].key, j, data)
|
|
]).data = d;
|
|
for(i = 0, oz = array$5(order(sz)); i < n; ++i)sz[oz[i]].index = i;
|
|
return offset(sz, oz), sz;
|
|
}
|
|
return stack.keys = function(_) {
|
|
return arguments.length ? (keys = "function" == typeof _ ? _ : constant$a(Array.from(_)), stack) : keys;
|
|
}, stack.value = function(_) {
|
|
return arguments.length ? (value = "function" == typeof _ ? _ : constant$a(+_), stack) : value;
|
|
}, stack.order = function(_) {
|
|
return arguments.length ? (order = null == _ ? none$2 : "function" == typeof _ ? _ : constant$a(Array.from(_)), stack) : order;
|
|
}, stack.offset = function(_) {
|
|
return arguments.length ? (offset = null == _ ? none$1 : _, stack) : offset;
|
|
}, stack;
|
|
}, exports1.stackOffsetDiverging = function(series, order) {
|
|
if ((n = series.length) > 0) for(var i, d, dy, yp, yn, n, j = 0, m = series[order[0]].length; j < m; ++j)for(yp = yn = 0, i = 0; i < n; ++i)(dy = (d = series[order[i]][j])[1] - d[0]) > 0 ? (d[0] = yp, d[1] = yp += dy) : dy < 0 ? (d[1] = yn, d[0] = yn += dy) : (d[0] = 0, d[1] = dy);
|
|
}, exports1.stackOffsetExpand = function(series, order) {
|
|
if ((n = series.length) > 0) {
|
|
for(var i, n, y, j = 0, m = series[0].length; j < m; ++j){
|
|
for(y = i = 0; i < n; ++i)y += series[i][j][1] || 0;
|
|
if (y) for(i = 0; i < n; ++i)series[i][j][1] /= y;
|
|
}
|
|
none$1(series, order);
|
|
}
|
|
}, exports1.stackOffsetNone = none$1, exports1.stackOffsetSilhouette = function(series, order) {
|
|
if ((n = series.length) > 0) {
|
|
for(var n, j = 0, s0 = series[order[0]], m = s0.length; j < m; ++j){
|
|
for(var i = 0, y = 0; i < n; ++i)y += series[i][j][1] || 0;
|
|
s0[j][1] += s0[j][0] = -y / 2;
|
|
}
|
|
none$1(series, order);
|
|
}
|
|
}, exports1.stackOffsetWiggle = function(series, order) {
|
|
if ((n = series.length) > 0 && (m = (s0 = series[order[0]]).length) > 0) {
|
|
for(var s0, m, n, y = 0, j = 1; j < m; ++j){
|
|
for(var i = 0, s1 = 0, s2 = 0; i < n; ++i){
|
|
for(var si = series[order[i]], sij0 = si[j][1] || 0, s3 = (sij0 - (si[j - 1][1] || 0)) / 2, k = 0; k < i; ++k){
|
|
var sk = series[order[k]];
|
|
s3 += (sk[j][1] || 0) - (sk[j - 1][1] || 0);
|
|
}
|
|
s1 += sij0, s2 += s3 * sij0;
|
|
}
|
|
s0[j - 1][1] += s0[j - 1][0] = y, s1 && (y -= s2 / s1);
|
|
}
|
|
s0[j - 1][1] += s0[j - 1][0] = y, none$1(series, order);
|
|
}
|
|
}, exports1.stackOrderAppearance = appearance, exports1.stackOrderAscending = ascending$3, exports1.stackOrderDescending = function(series) {
|
|
return ascending$3(series).reverse();
|
|
}, exports1.stackOrderInsideOut = function(series) {
|
|
var i, j, n = series.length, sums = series.map(sum$1), order = appearance(series), top = 0, bottom = 0, tops = [], bottoms = [];
|
|
for(i = 0; i < n; ++i)j = order[i], top < bottom ? (top += sums[j], tops.push(j)) : (bottom += sums[j], bottoms.push(j));
|
|
return bottoms.reverse().concat(tops);
|
|
}, exports1.stackOrderNone = none$2, exports1.stackOrderReverse = function(series) {
|
|
return none$2(series).reverse();
|
|
}, exports1.stratify = function() {
|
|
var id = defaultId, parentId = defaultParentId;
|
|
function stratify(data) {
|
|
var d, i, root, parent, node, nodeId, nodeKey, nodes = Array.from(data), n = nodes.length, nodeByKey = new Map;
|
|
for(i = 0; i < n; ++i)d = nodes[i], node = nodes[i] = new Node(d), null != (nodeId = id(d, i, data)) && (nodeId += "") && (nodeKey = node.id = nodeId, nodeByKey.set(nodeKey, nodeByKey.has(nodeKey) ? ambiguous : node)), null != (nodeId = parentId(d, i, data)) && (nodeId += "") && (node.parent = nodeId);
|
|
for(i = 0; i < n; ++i)if (nodeId = (node = nodes[i]).parent) {
|
|
if (!(parent = nodeByKey.get(nodeId))) throw Error("missing: " + nodeId);
|
|
if (parent === ambiguous) throw Error("ambiguous: " + nodeId);
|
|
parent.children ? parent.children.push(node) : parent.children = [
|
|
node
|
|
], node.parent = parent;
|
|
} else {
|
|
if (root) throw Error("multiple roots");
|
|
root = node;
|
|
}
|
|
if (!root) throw Error("no root");
|
|
if (root.parent = preroot, root.eachBefore(function(node) {
|
|
node.depth = node.parent.depth + 1, --n;
|
|
}).eachBefore(computeHeight), root.parent = null, n > 0) throw Error("cycle");
|
|
return root;
|
|
}
|
|
return stratify.id = function(x) {
|
|
return arguments.length ? (id = required(x), stratify) : id;
|
|
}, stratify.parentId = function(x) {
|
|
return arguments.length ? (parentId = required(x), stratify) : parentId;
|
|
}, stratify;
|
|
}, exports1.style = styleValue, exports1.subset = function(values, other) {
|
|
return superset(other, values);
|
|
}, exports1.sum = function(values, valueof) {
|
|
let sum = 0;
|
|
if (void 0 === valueof) for (let value of values)(value = +value) && (sum += value);
|
|
else {
|
|
let index = -1;
|
|
for (let value1 of values)(value1 = +valueof(value1, ++index, values)) && (sum += value1);
|
|
}
|
|
return sum;
|
|
}, exports1.superset = superset, exports1.svg = svg, exports1.symbol = function(type, size) {
|
|
var context = null;
|
|
function symbol() {
|
|
var buffer;
|
|
if (context || (context = buffer = path()), type.apply(this, arguments).draw(context, +size.apply(this, arguments)), buffer) return context = null, buffer + "" || null;
|
|
}
|
|
return type = "function" == typeof type ? type : constant$a(type || circle$2), size = "function" == typeof size ? size : constant$a(void 0 === size ? 64 : +size), symbol.type = function(_) {
|
|
return arguments.length ? (type = "function" == typeof _ ? _ : constant$a(_), symbol) : type;
|
|
}, symbol.size = function(_) {
|
|
return arguments.length ? (size = "function" == typeof _ ? _ : constant$a(+_), symbol) : size;
|
|
}, symbol.context = function(_) {
|
|
return arguments.length ? (context = null == _ ? null : _, symbol) : context;
|
|
}, symbol;
|
|
}, exports1.symbolCircle = circle$2, exports1.symbolCross = cross$2, exports1.symbolDiamond = diamond, exports1.symbolSquare = square$1, exports1.symbolStar = star, exports1.symbolTriangle = triangle, exports1.symbolWye = wye, exports1.symbols = [
|
|
circle$2,
|
|
cross$2,
|
|
diamond,
|
|
square$1,
|
|
star,
|
|
triangle,
|
|
wye
|
|
], exports1.text = text, exports1.thresholdFreedmanDiaconis = function(values, min, max) {
|
|
return Math.ceil((max - min) / (2 * (quantile(values, 0.75) - quantile(values, 0.25)) * Math.pow(count(values), -1 / 3)));
|
|
}, exports1.thresholdScott = function(values, min, max) {
|
|
return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(count(values), -1 / 3)));
|
|
}, exports1.thresholdSturges = thresholdSturges, exports1.tickFormat = tickFormat, exports1.tickIncrement = tickIncrement, exports1.tickStep = tickStep, exports1.ticks = ticks, exports1.timeDay = day, exports1.timeDays = days, exports1.timeFormatDefaultLocale = defaultLocale$1, exports1.timeFormatLocale = formatLocale$1, exports1.timeFriday = friday, exports1.timeFridays = fridays, exports1.timeHour = hour, exports1.timeHours = hours, exports1.timeInterval = newInterval, exports1.timeMillisecond = millisecond, exports1.timeMilliseconds = milliseconds, exports1.timeMinute = minute, exports1.timeMinutes = minutes, exports1.timeMonday = monday, exports1.timeMondays = mondays, exports1.timeMonth = month, exports1.timeMonths = months, exports1.timeSaturday = saturday, exports1.timeSaturdays = saturdays, exports1.timeSecond = second, exports1.timeSeconds = seconds, exports1.timeSunday = sunday, exports1.timeSundays = sundays, exports1.timeThursday = thursday, exports1.timeThursdays = thursdays, exports1.timeTuesday = tuesday, exports1.timeTuesdays = tuesdays, exports1.timeWednesday = wednesday, exports1.timeWednesdays = wednesdays, exports1.timeWeek = sunday, exports1.timeWeeks = sundays, exports1.timeYear = year, exports1.timeYears = years, exports1.timeout = timeout$1, exports1.timer = timer, exports1.timerFlush = timerFlush, exports1.transition = transition, exports1.transpose = transpose, exports1.tree = function() {
|
|
var separation = defaultSeparation$1, dx = 1, dy = 1, nodeSize = null;
|
|
function tree(root) {
|
|
var t = function(root) {
|
|
for(var node, child, children, i, n, tree = new TreeNode(root, 0), nodes = [
|
|
tree
|
|
]; node = nodes.pop();)if (children = node._.children) for(node.children = Array(n = children.length), i = n - 1; i >= 0; --i)nodes.push(child = node.children[i] = new TreeNode(children[i], i)), child.parent = node;
|
|
return (tree.parent = new TreeNode(null, 0)).children = [
|
|
tree
|
|
], tree;
|
|
}(root);
|
|
if (t.eachAfter(firstWalk), t.parent.m = -t.z, t.eachBefore(secondWalk), nodeSize) root.eachBefore(sizeNode);
|
|
else {
|
|
var left = root, right = root, bottom = root;
|
|
root.eachBefore(function(node) {
|
|
node.x < left.x && (left = node), node.x > right.x && (right = node), node.depth > bottom.depth && (bottom = node);
|
|
});
|
|
var s = left === right ? 1 : separation(left, right) / 2, tx = s - left.x, kx = dx / (right.x + s + tx), ky = dy / (bottom.depth || 1);
|
|
root.eachBefore(function(node) {
|
|
node.x = (node.x + tx) * kx, node.y = node.depth * ky;
|
|
});
|
|
}
|
|
return root;
|
|
}
|
|
function firstWalk(v) {
|
|
var children = v.children, siblings = v.parent.children, w = v.i ? siblings[v.i - 1] : null;
|
|
if (children) {
|
|
!function(v) {
|
|
for(var w, shift = 0, change = 0, children = v.children, i = children.length; --i >= 0;)w = children[i], w.z += shift, w.m += shift, shift += w.s + (change += w.c);
|
|
}(v);
|
|
var midpoint = (children[0].z + children[children.length - 1].z) / 2;
|
|
w ? (v.z = w.z + separation(v._, w._), v.m = v.z - midpoint) : v.z = midpoint;
|
|
} else w && (v.z = w.z + separation(v._, w._));
|
|
v.parent.A = function(v, w, ancestor) {
|
|
if (w) {
|
|
for(var vim, v1, ancestor1, shift, vip = v, vop = v, vim1 = w, vom = vip.parent.children[0], sip = vip.m, sop = vop.m, sim = vim1.m, som = vom.m; vim1 = nextRight(vim1), vip = nextLeft(vip), vim1 && vip;)vom = nextLeft(vom), (vop = nextRight(vop)).a = v, (shift = vim1.z + sim - vip.z - sip + separation(vim1._, vip._)) > 0 && (function(wm, wp, shift) {
|
|
var change = shift / (wp.i - wm.i);
|
|
wp.c -= change, wp.s += shift, wm.c += change, wp.z += shift, wp.m += shift;
|
|
}((vim = vim1, v1 = v, ancestor1 = ancestor, vim.a.parent === v1.parent ? vim.a : ancestor1), v, shift), sip += shift, sop += shift), sim += vim1.m, sip += vip.m, som += vom.m, sop += vop.m;
|
|
vim1 && !nextRight(vop) && (vop.t = vim1, vop.m += sim - sop), vip && !nextLeft(vom) && (vom.t = vip, vom.m += sip - som, ancestor = v);
|
|
}
|
|
return ancestor;
|
|
}(v, w, v.parent.A || siblings[0]);
|
|
}
|
|
function secondWalk(v) {
|
|
v._.x = v.z + v.parent.m, v.m += v.parent.m;
|
|
}
|
|
function sizeNode(node) {
|
|
node.x *= dx, node.y = node.depth * dy;
|
|
}
|
|
return tree.separation = function(x) {
|
|
return arguments.length ? (separation = x, tree) : separation;
|
|
}, tree.size = function(x) {
|
|
return arguments.length ? (nodeSize = !1, dx = +x[0], dy = +x[1], tree) : nodeSize ? null : [
|
|
dx,
|
|
dy
|
|
];
|
|
}, tree.nodeSize = function(x) {
|
|
return arguments.length ? (nodeSize = !0, dx = +x[0], dy = +x[1], tree) : nodeSize ? [
|
|
dx,
|
|
dy
|
|
] : null;
|
|
}, tree;
|
|
}, exports1.treemap = function() {
|
|
var tile = squarify, round = !1, dx = 1, dy = 1, paddingStack = [
|
|
0
|
|
], paddingInner = constantZero, paddingTop = constantZero, paddingRight = constantZero, paddingBottom = constantZero, paddingLeft = constantZero;
|
|
function treemap(root) {
|
|
return root.x0 = root.y0 = 0, root.x1 = dx, root.y1 = dy, root.eachBefore(positionNode), paddingStack = [
|
|
0
|
|
], round && root.eachBefore(roundNode), root;
|
|
}
|
|
function positionNode(node) {
|
|
var p = paddingStack[node.depth], x0 = node.x0 + p, y0 = node.y0 + p, x1 = node.x1 - p, y1 = node.y1 - p;
|
|
x1 < x0 && (x0 = x1 = (x0 + x1) / 2), y1 < y0 && (y0 = y1 = (y0 + y1) / 2), node.x0 = x0, node.y0 = y0, node.x1 = x1, node.y1 = y1, node.children && (p = paddingStack[node.depth + 1] = paddingInner(node) / 2, x0 += paddingLeft(node) - p, y0 += paddingTop(node) - p, x1 -= paddingRight(node) - p, y1 -= paddingBottom(node) - p, x1 < x0 && (x0 = x1 = (x0 + x1) / 2), y1 < y0 && (y0 = y1 = (y0 + y1) / 2), tile(node, x0, y0, x1, y1));
|
|
}
|
|
return treemap.round = function(x) {
|
|
return arguments.length ? (round = !!x, treemap) : round;
|
|
}, treemap.size = function(x) {
|
|
return arguments.length ? (dx = +x[0], dy = +x[1], treemap) : [
|
|
dx,
|
|
dy
|
|
];
|
|
}, treemap.tile = function(x) {
|
|
return arguments.length ? (tile = required(x), treemap) : tile;
|
|
}, treemap.padding = function(x) {
|
|
return arguments.length ? treemap.paddingInner(x).paddingOuter(x) : treemap.paddingInner();
|
|
}, treemap.paddingInner = function(x) {
|
|
return arguments.length ? (paddingInner = "function" == typeof x ? x : constant$9(+x), treemap) : paddingInner;
|
|
}, treemap.paddingOuter = function(x) {
|
|
return arguments.length ? treemap.paddingTop(x).paddingRight(x).paddingBottom(x).paddingLeft(x) : treemap.paddingTop();
|
|
}, treemap.paddingTop = function(x) {
|
|
return arguments.length ? (paddingTop = "function" == typeof x ? x : constant$9(+x), treemap) : paddingTop;
|
|
}, treemap.paddingRight = function(x) {
|
|
return arguments.length ? (paddingRight = "function" == typeof x ? x : constant$9(+x), treemap) : paddingRight;
|
|
}, treemap.paddingBottom = function(x) {
|
|
return arguments.length ? (paddingBottom = "function" == typeof x ? x : constant$9(+x), treemap) : paddingBottom;
|
|
}, treemap.paddingLeft = function(x) {
|
|
return arguments.length ? (paddingLeft = "function" == typeof x ? x : constant$9(+x), treemap) : paddingLeft;
|
|
}, treemap;
|
|
}, exports1.treemapBinary = function(parent, x0, y0, x1, y1) {
|
|
var i, sum, nodes = parent.children, n = nodes.length, sums = Array(n + 1);
|
|
for(sums[0] = sum = i = 0; i < n; ++i)sums[i + 1] = sum += nodes[i].value;
|
|
(function partition(i, j, value, x0, y0, x1, y1) {
|
|
if (i >= j - 1) {
|
|
var node = nodes[i];
|
|
node.x0 = x0, node.y0 = y0, node.x1 = x1, node.y1 = y1;
|
|
return;
|
|
}
|
|
for(var valueOffset = sums[i], valueTarget = value / 2 + valueOffset, k = i + 1, hi = j - 1; k < hi;){
|
|
var mid = k + hi >>> 1;
|
|
sums[mid] < valueTarget ? k = mid + 1 : hi = mid;
|
|
}
|
|
valueTarget - sums[k - 1] < sums[k] - valueTarget && i + 1 < k && --k;
|
|
var valueLeft = sums[k] - valueOffset, valueRight = value - valueLeft;
|
|
if (x1 - x0 > y1 - y0) {
|
|
var xk = value ? (x0 * valueRight + x1 * valueLeft) / value : x1;
|
|
partition(i, k, valueLeft, x0, y0, xk, y1), partition(k, j, valueRight, xk, y0, x1, y1);
|
|
} else {
|
|
var yk = value ? (y0 * valueRight + y1 * valueLeft) / value : y1;
|
|
partition(i, k, valueLeft, x0, y0, x1, yk), partition(k, j, valueRight, x0, yk, x1, y1);
|
|
}
|
|
})(0, n, parent.value, x0, y0, x1, y1);
|
|
}, exports1.treemapDice = treemapDice, exports1.treemapResquarify = resquarify, exports1.treemapSlice = treemapSlice, exports1.treemapSliceDice = function(parent, x0, y0, x1, y1) {
|
|
(1 & parent.depth ? treemapSlice : treemapDice)(parent, x0, y0, x1, y1);
|
|
}, exports1.treemapSquarify = squarify, exports1.tsv = tsv$1, exports1.tsvFormat = tsvFormat, exports1.tsvFormatBody = tsvFormatBody, exports1.tsvFormatRow = tsvFormatRow, exports1.tsvFormatRows = tsvFormatRows, exports1.tsvFormatValue = tsvFormatValue, exports1.tsvParse = tsvParse, exports1.tsvParseRows = tsvParseRows, exports1.union = function(...others) {
|
|
const set = new Set();
|
|
for (const other of others)for (const o of other)set.add(o);
|
|
return set;
|
|
}, exports1.utcDay = utcDay, exports1.utcDays = utcDays, exports1.utcFriday = utcFriday, exports1.utcFridays = utcFridays, exports1.utcHour = utcHour, exports1.utcHours = utcHours, exports1.utcMillisecond = millisecond, exports1.utcMilliseconds = milliseconds, exports1.utcMinute = utcMinute, exports1.utcMinutes = utcMinutes, exports1.utcMonday = utcMonday, exports1.utcMondays = utcMondays, exports1.utcMonth = utcMonth, exports1.utcMonths = utcMonths, exports1.utcSaturday = utcSaturday, exports1.utcSaturdays = utcSaturdays, exports1.utcSecond = second, exports1.utcSeconds = seconds, exports1.utcSunday = utcSunday, exports1.utcSundays = utcSundays, exports1.utcThursday = utcThursday, exports1.utcThursdays = utcThursdays, exports1.utcTuesday = utcTuesday, exports1.utcTuesdays = utcTuesdays, exports1.utcWednesday = utcWednesday, exports1.utcWednesdays = utcWednesdays, exports1.utcWeek = utcSunday, exports1.utcWeeks = utcSundays, exports1.utcYear = utcYear, exports1.utcYears = utcYears, exports1.variance = variance, exports1.version = "6.3.1", exports1.window = defaultView, exports1.xml = xml, exports1.zip = function() {
|
|
return transpose(arguments);
|
|
}, exports1.zoom = function() {
|
|
var touchstarting, touchfirst, touchending, filter = defaultFilter$2, extent = defaultExtent$1, constrain = defaultConstrain, wheelDelta = defaultWheelDelta, touchable = defaultTouchable$2, scaleExtent = [
|
|
0,
|
|
1 / 0
|
|
], translateExtent = [
|
|
[
|
|
-1 / 0,
|
|
-1 / 0
|
|
],
|
|
[
|
|
1 / 0,
|
|
1 / 0
|
|
]
|
|
], duration = 250, interpolate = interpolateZoom, listeners = dispatch("start", "zoom", "end"), clickDistance2 = 0, tapDistance = 10;
|
|
function zoom(selection) {
|
|
selection.property("__zoom", defaultTransform).on("wheel.zoom", wheeled).on("mousedown.zoom", mousedowned).on("dblclick.zoom", dblclicked).filter(touchable).on("touchstart.zoom", touchstarted).on("touchmove.zoom", touchmoved).on("touchend.zoom touchcancel.zoom", touchended).style("-webkit-tap-highlight-color", "rgba(0,0,0,0)");
|
|
}
|
|
function scale(transform, k) {
|
|
return (k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], k))) === transform.k ? transform : new Transform(k, transform.x, transform.y);
|
|
}
|
|
function translate(transform, p0, p1) {
|
|
var x = p0[0] - p1[0] * transform.k, y = p0[1] - p1[1] * transform.k;
|
|
return x === transform.x && y === transform.y ? transform : new Transform(transform.k, x, y);
|
|
}
|
|
function centroid(extent) {
|
|
return [
|
|
(+extent[0][0] + +extent[1][0]) / 2,
|
|
(+extent[0][1] + +extent[1][1]) / 2
|
|
];
|
|
}
|
|
function schedule(transition, transform, point, event) {
|
|
transition.on("start.zoom", function() {
|
|
gesture(this, arguments).event(event).start();
|
|
}).on("interrupt.zoom end.zoom", function() {
|
|
gesture(this, arguments).event(event).end();
|
|
}).tween("zoom", function() {
|
|
var args = arguments, g = gesture(this, args).event(event), e = extent.apply(this, args), p = null == point ? centroid(e) : "function" == typeof point ? point.apply(this, args) : point, w = Math.max(e[1][0] - e[0][0], e[1][1] - e[0][1]), a = this.__zoom, b = "function" == typeof transform ? transform.apply(this, args) : transform, i = interpolate(a.invert(p).concat(w / a.k), b.invert(p).concat(w / b.k));
|
|
return function(t) {
|
|
if (1 === t) t = b;
|
|
else {
|
|
var l = i(t), k = w / l[2];
|
|
t = new Transform(k, p[0] - l[0] * k, p[1] - l[1] * k);
|
|
}
|
|
g.zoom(null, t);
|
|
};
|
|
});
|
|
}
|
|
function gesture(that, args, clean) {
|
|
return !clean && that.__zooming || new Gesture(that, args);
|
|
}
|
|
function Gesture(that, args) {
|
|
this.that = that, this.args = args, this.active = 0, this.sourceEvent = null, this.extent = extent.apply(that, args), this.taps = 0;
|
|
}
|
|
function wheeled(event, ...args) {
|
|
if (filter.apply(this, arguments)) {
|
|
var g = gesture(this, args).event(event), t = this.__zoom, k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], t.k * Math.pow(2, wheelDelta.apply(this, arguments)))), p = pointer(event);
|
|
if (g.wheel) (g.mouse[0][0] !== p[0] || g.mouse[0][1] !== p[1]) && (g.mouse[1] = t.invert(g.mouse[0] = p)), clearTimeout(g.wheel);
|
|
else {
|
|
if (t.k === k) return;
|
|
g.mouse = [
|
|
p,
|
|
t.invert(p)
|
|
], interrupt(this), g.start();
|
|
}
|
|
noevent$2(event), g.wheel = setTimeout(function() {
|
|
g.wheel = null, g.end();
|
|
}, 150), g.zoom("mouse", constrain(translate(scale(t, k), g.mouse[0], g.mouse[1]), g.extent, translateExtent));
|
|
}
|
|
}
|
|
function mousedowned(event, ...args) {
|
|
if (!touchending && filter.apply(this, arguments)) {
|
|
var g = gesture(this, args, !0).event(event), v = select(event.view).on("mousemove.zoom", function(event) {
|
|
if (noevent$2(event), !g.moved) {
|
|
var dx = event.clientX - x0, dy = event.clientY - y0;
|
|
g.moved = dx * dx + dy * dy > clickDistance2;
|
|
}
|
|
g.event(event).zoom("mouse", constrain(translate(g.that.__zoom, g.mouse[0] = pointer(event, currentTarget), g.mouse[1]), g.extent, translateExtent));
|
|
}, !0).on("mouseup.zoom", function(event) {
|
|
v.on("mousemove.zoom mouseup.zoom", null), yesdrag(event.view, g.moved), noevent$2(event), g.event(event).end();
|
|
}, !0), p = pointer(event, currentTarget), currentTarget = event.currentTarget, x0 = event.clientX, y0 = event.clientY;
|
|
dragDisable(event.view), nopropagation$2(event), g.mouse = [
|
|
p,
|
|
this.__zoom.invert(p)
|
|
], interrupt(this), g.start();
|
|
}
|
|
}
|
|
function dblclicked(event, ...args) {
|
|
if (filter.apply(this, arguments)) {
|
|
var t0 = this.__zoom, p0 = pointer(event.changedTouches ? event.changedTouches[0] : event, this), p1 = t0.invert(p0), k1 = t0.k * (event.shiftKey ? 0.5 : 2), t1 = constrain(translate(scale(t0, k1), p0, p1), extent.apply(this, args), translateExtent);
|
|
noevent$2(event), duration > 0 ? select(this).transition().duration(duration).call(schedule, t1, p0, event) : select(this).call(zoom.transform, t1, p0, event);
|
|
}
|
|
}
|
|
function touchstarted(event, ...args) {
|
|
if (filter.apply(this, arguments)) {
|
|
var started, i, t, p, touches = event.touches, n = touches.length, g = gesture(this, args, event.changedTouches.length === n).event(event);
|
|
for(nopropagation$2(event), i = 0; i < n; ++i)p = [
|
|
p = pointer(t = touches[i], this),
|
|
this.__zoom.invert(p),
|
|
t.identifier
|
|
], g.touch0 ? g.touch1 || g.touch0[2] === p[2] || (g.touch1 = p, g.taps = 0) : (g.touch0 = p, started = !0, g.taps = 1 + !!touchstarting);
|
|
touchstarting && (touchstarting = clearTimeout(touchstarting)), started && (g.taps < 2 && (touchfirst = p[0], touchstarting = setTimeout(function() {
|
|
touchstarting = null;
|
|
}, 500)), interrupt(this), g.start());
|
|
}
|
|
}
|
|
function touchmoved(event, ...args) {
|
|
if (this.__zooming) {
|
|
var i, t, p, l, g = gesture(this, args).event(event), touches = event.changedTouches, n = touches.length;
|
|
for(noevent$2(event), i = 0; i < n; ++i)p = pointer(t = touches[i], this), g.touch0 && g.touch0[2] === t.identifier ? g.touch0[0] = p : g.touch1 && g.touch1[2] === t.identifier && (g.touch1[0] = p);
|
|
if (t = g.that.__zoom, g.touch1) {
|
|
var p0 = g.touch0[0], l0 = g.touch0[1], p1 = g.touch1[0], l1 = g.touch1[1], dp = (dp = p1[0] - p0[0]) * dp + (dp = p1[1] - p0[1]) * dp, dl = (dl = l1[0] - l0[0]) * dl + (dl = l1[1] - l0[1]) * dl;
|
|
t = scale(t, Math.sqrt(dp / dl)), p = [
|
|
(p0[0] + p1[0]) / 2,
|
|
(p0[1] + p1[1]) / 2
|
|
], l = [
|
|
(l0[0] + l1[0]) / 2,
|
|
(l0[1] + l1[1]) / 2
|
|
];
|
|
} else {
|
|
if (!g.touch0) return;
|
|
p = g.touch0[0], l = g.touch0[1];
|
|
}
|
|
g.zoom("touch", constrain(translate(t, p, l), g.extent, translateExtent));
|
|
}
|
|
}
|
|
function touchended(event, ...args) {
|
|
if (this.__zooming) {
|
|
var i, t, g = gesture(this, args).event(event), touches = event.changedTouches, n = touches.length;
|
|
for(nopropagation$2(event), touchending && clearTimeout(touchending), touchending = setTimeout(function() {
|
|
touchending = null;
|
|
}, 500), i = 0; i < n; ++i)t = touches[i], g.touch0 && g.touch0[2] === t.identifier ? delete g.touch0 : g.touch1 && g.touch1[2] === t.identifier && delete g.touch1;
|
|
if (g.touch1 && !g.touch0 && (g.touch0 = g.touch1, delete g.touch1), g.touch0) g.touch0[1] = this.__zoom.invert(g.touch0[0]);
|
|
else if (g.end(), 2 === g.taps && (t = pointer(t, this), Math.hypot(touchfirst[0] - t[0], touchfirst[1] - t[1]) < tapDistance)) {
|
|
var p = select(this).on("dblclick.zoom");
|
|
p && p.apply(this, arguments);
|
|
}
|
|
}
|
|
}
|
|
return zoom.transform = function(collection, transform, point, event) {
|
|
var selection = collection.selection ? collection.selection() : collection;
|
|
selection.property("__zoom", defaultTransform), collection !== selection ? schedule(collection, transform, point, event) : selection.interrupt().each(function() {
|
|
gesture(this, arguments).event(event).start().zoom(null, "function" == typeof transform ? transform.apply(this, arguments) : transform).end();
|
|
});
|
|
}, zoom.scaleBy = function(selection, k, p, event) {
|
|
zoom.scaleTo(selection, function() {
|
|
var k0 = this.__zoom.k, k1 = "function" == typeof k ? k.apply(this, arguments) : k;
|
|
return k0 * k1;
|
|
}, p, event);
|
|
}, zoom.scaleTo = function(selection, k, p, event) {
|
|
zoom.transform(selection, function() {
|
|
var e = extent.apply(this, arguments), t0 = this.__zoom, p0 = null == p ? centroid(e) : "function" == typeof p ? p.apply(this, arguments) : p, p1 = t0.invert(p0), k1 = "function" == typeof k ? k.apply(this, arguments) : k;
|
|
return constrain(translate(scale(t0, k1), p0, p1), e, translateExtent);
|
|
}, p, event);
|
|
}, zoom.translateBy = function(selection, x, y, event) {
|
|
zoom.transform(selection, function() {
|
|
return constrain(this.__zoom.translate("function" == typeof x ? x.apply(this, arguments) : x, "function" == typeof y ? y.apply(this, arguments) : y), extent.apply(this, arguments), translateExtent);
|
|
}, null, event);
|
|
}, zoom.translateTo = function(selection, x, y, p, event) {
|
|
zoom.transform(selection, function() {
|
|
var e = extent.apply(this, arguments), t = this.__zoom, p0 = null == p ? centroid(e) : "function" == typeof p ? p.apply(this, arguments) : p;
|
|
return constrain(identity$9.translate(p0[0], p0[1]).scale(t.k).translate("function" == typeof x ? -x.apply(this, arguments) : -x, "function" == typeof y ? -y.apply(this, arguments) : -y), e, translateExtent);
|
|
}, p, event);
|
|
}, Gesture.prototype = {
|
|
event: function(event) {
|
|
return event && (this.sourceEvent = event), this;
|
|
},
|
|
start: function() {
|
|
return 1 == ++this.active && (this.that.__zooming = this, this.emit("start")), this;
|
|
},
|
|
zoom: function(key, transform) {
|
|
return this.mouse && "mouse" !== key && (this.mouse[1] = transform.invert(this.mouse[0])), this.touch0 && "touch" !== key && (this.touch0[1] = transform.invert(this.touch0[0])), this.touch1 && "touch" !== key && (this.touch1[1] = transform.invert(this.touch1[0])), this.that.__zoom = transform, this.emit("zoom"), this;
|
|
},
|
|
end: function() {
|
|
return 0 == --this.active && (delete this.that.__zooming, this.emit("end")), this;
|
|
},
|
|
emit: function(type) {
|
|
var d = select(this.that).datum();
|
|
listeners.call(type, this.that, new ZoomEvent(type, {
|
|
sourceEvent: this.sourceEvent,
|
|
target: zoom,
|
|
type,
|
|
transform: this.that.__zoom,
|
|
dispatch: listeners
|
|
}), d);
|
|
}
|
|
}, zoom.wheelDelta = function(_) {
|
|
return arguments.length ? (wheelDelta = "function" == typeof _ ? _ : constant$b(+_), zoom) : wheelDelta;
|
|
}, zoom.filter = function(_) {
|
|
return arguments.length ? (filter = "function" == typeof _ ? _ : constant$b(!!_), zoom) : filter;
|
|
}, zoom.touchable = function(_) {
|
|
return arguments.length ? (touchable = "function" == typeof _ ? _ : constant$b(!!_), zoom) : touchable;
|
|
}, zoom.extent = function(_) {
|
|
return arguments.length ? (extent = "function" == typeof _ ? _ : constant$b([
|
|
[
|
|
+_[0][0],
|
|
+_[0][1]
|
|
],
|
|
[
|
|
+_[1][0],
|
|
+_[1][1]
|
|
]
|
|
]), zoom) : extent;
|
|
}, zoom.scaleExtent = function(_) {
|
|
return arguments.length ? (scaleExtent[0] = +_[0], scaleExtent[1] = +_[1], zoom) : [
|
|
scaleExtent[0],
|
|
scaleExtent[1]
|
|
];
|
|
}, zoom.translateExtent = function(_) {
|
|
return arguments.length ? (translateExtent[0][0] = +_[0][0], translateExtent[1][0] = +_[1][0], translateExtent[0][1] = +_[0][1], translateExtent[1][1] = +_[1][1], zoom) : [
|
|
[
|
|
translateExtent[0][0],
|
|
translateExtent[0][1]
|
|
],
|
|
[
|
|
translateExtent[1][0],
|
|
translateExtent[1][1]
|
|
]
|
|
];
|
|
}, zoom.constrain = function(_) {
|
|
return arguments.length ? (constrain = _, zoom) : constrain;
|
|
}, zoom.duration = function(_) {
|
|
return arguments.length ? (duration = +_, zoom) : duration;
|
|
}, zoom.interpolate = function(_) {
|
|
return arguments.length ? (interpolate = _, zoom) : interpolate;
|
|
}, zoom.on = function() {
|
|
var value = listeners.on.apply(listeners, arguments);
|
|
return value === listeners ? zoom : value;
|
|
}, zoom.clickDistance = function(_) {
|
|
return arguments.length ? (clickDistance2 = (_ = +_) * _, zoom) : Math.sqrt(clickDistance2);
|
|
}, zoom.tapDistance = function(_) {
|
|
return arguments.length ? (tapDistance = +_, zoom) : tapDistance;
|
|
}, zoom;
|
|
}, exports1.zoomIdentity = identity$9, exports1.zoomTransform = transform$1, Object.defineProperty(exports1, '__esModule', {
|
|
value: !0
|
|
});
|
|
});
|