swc/crates/swc_ecma_minifier/tests/benches-full/d3.js

!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) {
        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, compare = (d, x)=>ascending(f(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 value of values)null != (value = valueof(value, ++index, values)) && (value = +value) >= value && ++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 value of values)null != (value = valueof(value, ++index, values)) && (value = +value) >= value && (delta = value - mean, mean += delta / ++count, sum += delta * (value - 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 value of values)null != (value = valueof(value, ++index, values)) && (void 0 === min ? value >= value && (min = max = value) : (min > value && (min = value), max < value && (max = value)));
        }
        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 [key, values] of groups)groups.set(key, regroup(values, 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 value of values)null != (value = valueof(value, ++index, values)) && (max < value || void 0 === max && value >= value) && (max = value);
        }
        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 value of values)null != (value = valueof(value, ++index, values)) && (min > value || void 0 === min && value >= value) && (min = value);
        }
        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 value of values)null != (value = valueof(value, ++index, values)) && (value = +value) >= value && (yield value);
            }
        }(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));
            return value0 + (min(values.subarray(i0 + 1)) - 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);
            return value0 + (+valueof(values[i0 + 1], i0 + 1, values) - 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 value of values)null != (value = valueof(value, ++index, values)) && (max < value || void 0 === max && value >= value) && (max = value, 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 value of values)null != (value = valueof(value, ++index, values)) && (min > value || void 0 === min && value >= value) && (min = value, 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 t, _ = this._, T = (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 o, on = this.__on, listener = 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 = listener, o.options = options), o.value = value;
                    return;
                }
            }
            this.addEventListener(typename.type, listener, options), o = {
                type: typename.type,
                name: typename.name,
                value: value,
                listener: listener,
                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);
                bind(parent, group, enterGroup, updateGroup, exit[j] = Array(groupLength), 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, a2, b2, s = [], q = [];
            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, s, q), (a1 = a.rotate) !== (b1 = b.rotate) ? (a1 - b1 > 180 ? b1 += 360 : b1 - a1 > 180 && (a1 += 360), q.push({
                i: s.push(pop(s) + "rotate(", null, degParen) - 2,
                x: interpolateNumber(a1, b1)
            })) : b1 && s.push(pop(s) + "rotate(" + b1 + degParen), (a2 = a.skewX) !== (b2 = b.skewX) ? q.push({
                i: s.push(pop(s) + "skewX(", null, degParen) - 2,
                x: interpolateNumber(a2, b2)
            }) : b2 && s.push(pop(s) + "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, s, q), a = b = null, function(t) {
                for(var o, i = -1, n = q.length; ++i < n;)s[(o = q[i]).i] = o.x(t);
                return s.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, _4 = _2 * _2;
            return zoomRho(_1, _2, _4);
        }, 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 i = value.apply(this, arguments);
            return i !== i0 && (t0 = (i0 = i) && function(t) {
                this.setAttributeNS(fullname.space, fullname.local, i.call(this, t));
            }), t0;
        }
        return tween._value = value, tween;
    }
    function attrTween(name, value) {
        var t0, i0;
        function tween() {
            var i = value.apply(this, arguments);
            return i !== i0 && (t0 = (i0 = i) && function(t) {
                this.setAttribute(name, 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);
    }
    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 = ++id, 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 on0, on1, sit, id = this._id;
            return arguments.length < 2 ? get$1(this.node(), id).on.on(name) : this.each((sit = (name + "").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(name, listener), 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, string00, string10, interpolate0, name2, value1, string001, string101, interpolate01, id, name3, on0, on1, listener0, remove, key, event, name4, 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 i = value.apply(this, arguments);
                    return i !== i0 && (t = (i0 = i) && function(t) {
                        this.style.setProperty(name, i.call(this, t), priority);
                    }), 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 = value.apply(this, arguments);
                    return i !== i0 && (t0 = (i0 = i) && 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;
            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 id1, timing;
        name instanceof Transition ? (id1 = name._id, name = name._name) : (id1 = ++id, (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, id1, 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, id1));
        return new Transition(groups, this._parents, name, id1);
    };
    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 point of points)point.cur && (point[0] = point.cur[0], point[1] = point.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 x = 0;
                for (const i of (sortGroups && groupIndex.sort((a, b)=>sortGroups(groupSums[a], groupSums[b])), groupIndex)){
                    const x0 = x;
                    if (directed) {
                        const subgroupIndex = range(~n + 1, n).filter((j)=>j < 0 ? matrix[~j * n + i] : matrix[i * n + j]);
                        for (const j of (sortSubgroups && subgroupIndex.sort((a, b)=>sortSubgroups(a < 0 ? -matrix[~a * n + i] : matrix[i * n + a], b < 0 ? -matrix[~b * n + i] : matrix[i * n + b])), subgroupIndex))if (j < 0) {
                            const chord = chords[~j * n + i] || (chords[~j * n + i] = {
                                source: null,
                                target: null
                            });
                            chord.target = {
                                index: i,
                                startAngle: x,
                                endAngle: x += matrix[~j * n + i] * k,
                                value: matrix[~j * n + i]
                            };
                        } else {
                            const chord = chords[i * n + j] || (chords[i * n + j] = {
                                source: null,
                                target: null
                            });
                            chord.source = {
                                index: i,
                                startAngle: x,
                                endAngle: x += matrix[i * n + j] * k,
                                value: matrix[i * n + j]
                            };
                        }
                        groups[i] = {
                            index: i,
                            startAngle: x0,
                            endAngle: x,
                            value: groupSums[i]
                        };
                    } else {
                        const subgroupIndex = range(0, n).filter((j)=>matrix[i * n + j] || matrix[j * n + i]);
                        for (const j of (sortSubgroups && subgroupIndex.sort((a, b)=>sortSubgroups(matrix[i * n + a], matrix[i * n + b])), subgroupIndex)){
                            let chord;
                            if (i < j ? (chord = chords[i * n + j] || (chords[i * n + j] = {
                                source: null,
                                target: null
                            })).source = {
                                index: i,
                                startAngle: x,
                                endAngle: x += matrix[i * n + j] * k,
                                value: matrix[i * n + j]
                            } : ((chord = chords[j * n + i] || (chords[j * n + i] = {
                                source: null,
                                target: null
                            })).target = {
                                index: i,
                                startAngle: x,
                                endAngle: x += matrix[i * n + j] * k,
                                value: matrix[i * n + j]
                            }, i === j && (chord.source = chord.target)), chord.source && chord.target && chord.source.value < chord.target.value) {
                                const source = chord.source;
                                chord.source = chord.target, chord.target = source;
                            }
                        }
                        groups[i] = {
                            index: i,
                            startAngle: x0,
                            endAngle: x,
                            value: groupSums[i]
                        };
                    }
                    x += 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(_) {
            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, p, q, r;
                                return (b[0] - a[0]) * (c[1] - a[1]) == (c[0] - a[0]) * (b[1] - a[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() {
            let i0, i1, i2;
            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 i = 0; i < n; i++){
                const d = dist(cx, cy, coords[2 * i], coords[2 * i + 1]);
                d < minDist && (i0 = i, minDist = d);
            }
            const i0x = coords[2 * i0], i0y = coords[2 * i0 + 1];
            minDist = 1 / 0;
            for(let i = 0; i < n; i++){
                if (i === i0) continue;
                const d = dist(i0x, i0y, coords[2 * i], coords[2 * i + 1]);
                d < minDist && d > 0 && (i1 = i, minDist = d);
            }
            let i1x = coords[2 * i1], i1y = coords[2 * i1 + 1], minRadius = 1 / 0;
            for(let i = 0; i < n; i++){
                if (i === i0 || i === i1) 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 * i], coords[2 * i + 1]);
                r < minRadius && (i2 = i, minRadius = r);
            }
            let i2x = coords[2 * i2], i2y = coords[2 * i2 + 1];
            if (minRadius === 1 / 0) {
                for(let i = 0; i < n; i++)this._dists[i] = coords[2 * i] - coords[0] || coords[2 * i + 1] - coords[1];
                quicksort(this._ids, this._dists, 0, n - 1);
                const hull = new Uint32Array(n);
                let j = 0;
                for(let i = 0, d0 = -1 / 0; i < n; i++){
                    const id = this._ids[i];
                    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 i = i1, x = i1x, y = i1y;
                i1 = i2, i1x = i2x, i1y = i2y, i2 = i, i2x = x, i2y = y;
            }
            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 i = 0; i < n; i++)this._dists[i] = dist(coords[2 * i], coords[2 * i + 1], center.x, center.y);
            quicksort(this._ids, this._dists, 0, n - 1), this._hullStart = i0;
            let hullSize = 3;
            hullNext[i0] = hullPrev[i2] = i1, hullNext[i1] = hullPrev[i0] = i2, hullNext[i2] = hullPrev[i1] = i0, hullTri[i0] = 0, hullTri[i1] = 1, hullTri[i2] = 2, hullHash.fill(-1), hullHash[this._hashKey(i0x, i0y)] = i0, hullHash[this._hashKey(i1x, i1y)] = i1, hullHash[this._hashKey(i2x, i2y)] = i2, this.trianglesLen = 0, this._addTriangle(i0, i1, i2, -1, -1, -1);
            for(let k = 0, xp, yp; k < this._ids.length; k++){
                const i = this._ids[k], x = coords[2 * i], y = coords[2 * i + 1];
                if (k > 0 && 0.0000000000000002220446049250313 >= Math.abs(x - xp) && 0.0000000000000002220446049250313 >= Math.abs(y - yp) || (xp = x, yp = y, i === i0 || i === i1 || i === i2)) continue;
                let start = 0;
                for(let j = 0, key = this._hashKey(x, y); j < this._hashSize && (-1 === (start = hullHash[(key + j) % this._hashSize]) || start === hullNext[start]); j++);
                let e = start = hullPrev[start], q;
                for(; q = hullNext[e], !orient(x, y, 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, i, hullNext[e], -1, -1, hullTri[e]);
                hullTri[i] = this._legalize(t + 2), hullTri[e] = t, hullSize++;
                let n = hullNext[e];
                for(; q = hullNext[n], orient(x, y, coords[2 * n], coords[2 * n + 1], coords[2 * q], coords[2 * q + 1]);)t = this._addTriangle(n, i, q, hullTri[i], -1, hullTri[n]), hullTri[i] = this._legalize(t + 2), hullNext[n] = n, hullSize--, n = q;
                if (e === start) for(; orient(x, y, coords[2 * (q = hullPrev[e])], coords[2 * q + 1], coords[2 * e], coords[2 * e + 1]);)t = this._addTriangle(q, i, e, -1, hullTri[e], hullTri[q]), this._legalize(t + 2), hullTri[q] = t, hullNext[e] = e, hullSize--, e = q;
                this._hullStart = hullPrev[i] = e, hullNext[e] = hullPrev[n] = i, hullNext[i] = n, hullHash[this._hashKey(x, y)] = i, hullHash[this._hashKey(coords[2 * e], coords[2 * e + 1])] = e;
            }
            this.hull = new Uint32Array(hullSize);
            for(let i = 0, e = this._hullStart; i < hullSize; i++)this.hull[i] = e, e = hullNext[e];
            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 {
            const median = left + right >> 1;
            let i = left + 1, j = right;
            swap$1(ids, median, i), dists[ids[left]] > dists[ids[right]] && swap$1(ids, left, right), dists[ids[i]] > dists[ids[right]] && swap$1(ids, i, right), dists[ids[left]] > dists[ids[i]] && swap$1(ids, left, i);
            const temp = ids[i], tempDist = dists[temp];
            for(;;){
                do i++;
                while (dists[ids[i]] < tempDist)
                do j--;
                while (dists[ids[j]] > tempDist)
                if (j < i) break;
                swap$1(ids, i, j);
            }
            ids[left + 1] = ids[j], ids[j] = temp, right - i + 1 >= j - left ? (quicksort(ids, dists, i, right), quicksort(ids, dists, left, j - 1)) : (quicksort(ids, dists, left, j - 1), quicksort(ids, dists, i, 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, x1 = points[2 * h], y0, y1 = points[2 * h + 1];
            vectors.fill(0);
            for(let i = 0; i < hull.length; ++i)h = hull[i], p0 = p1, x0 = x1, y0 = y1, p1 = 4 * h, x1 = points[2 * h], y1 = points[2 * h + 1], vectors[p0 + 2] = vectors[p1] = y0 - y1, vectors[p0 + 3] = vectors[p1 + 1] = x1 - 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 i = 0; i < hull.length; ++i){
                h0 = h1, h1 = hull[i];
                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 i = 2; i < n; i += 2)(points[i] !== points[i - 2] || points[i + 1] !== points[i - 1]) && context.lineTo(points[i], points[i + 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) {
            let e0, e1;
            const n = points.length;
            let P = null, 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 i = 0; i < P.length; i += 2){
                const j = (i + 2) % P.length, k = (i + 4) % P.length;
                (P[i] === P[j] && P[j] === P[k] || P[i + 1] === P[j + 1] && P[j + 1] === P[k + 1]) && (P.splice(j, 2), i -= 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;
                    const p = [
                        (x = points[2 * i]) + 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 e = 0, n = halfedges.length; e < n; ++e){
                const p = triangles[e % 3 == 2 ? e - 2 : e + 1];
                (-1 === halfedges[e] || -1 === inedges[p]) && (inedges[p] = e);
            }
            for(let i = 0, n = hull.length; i < n; ++i)hullIndex[hull[i]] = i;
            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 h = 2 * hull[i];
                context.lineTo(points[h], points[h + 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 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 : 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._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 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);
        centroidPointCartesian(x0 = cosPhi * cos$1(lambda), y0 = cosPhi * sin$1(lambda), z0 = sin$1(phi));
    }
    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, 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, phi0 = abs$2(sinLambda0Lambda1 = sin$1(lambda01 - (lambda11 = lambda1))) > 1e-6 ? atan((sin$1(phi01) * (cosPhi1 = cos$1(phi1)) * sin$1(lambda11) - sin$1(phi1) * (cosPhi0 = cos$1(phi01)) * sin$1(lambda01)) / (cosPhi0 * cosPhi1 * sinLambda0Lambda1)) : (phi01 + phi1) / 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 c1 = cr * n2n2 / determinant, c2 = -cr * n1n2 / determinant, n1xn2 = cartesianCross(n1, n2), A = cartesianScale(n1, c1);
            cartesianAddInPlace(A, cartesianScale(n2, c2));
            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), meridian = polar || delta < 1e-6;
                if (!polar && phi1 < phi0 && (z = phi0, phi0 = phi1, phi1 = z), meridian ? 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), x = cosPhi * sin$1(delta), 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 0 === distance(object.coordinates, point);
        },
        MultiPoint: function(object, point) {
            for(var coordinates = object.coordinates, i = -1, n = coordinates.length; ++i < n;)if (0 === distance(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 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) {
        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) : transformer({
            point: function(x, y) {
                x = project(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, 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;)nodes.push(start = start.parent);
            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), max = Math.floor(max) - (min = Math.floor(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 r = (x = 2 * source() - 1) * x + (y = 2 * source() - 1) * 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, g = G(sign ? pp : 1 - pp), 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 pad$1((d = dISO(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 pad$1((d = day >= 4 || 0 === day ? thursday(d) : thursday.ceil(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 pad$1((d = UTCdISO(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 pad$1((d = day >= 4 || 0 === day ? utcThursday(d) : utcThursday.ceil(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);
    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,
                2592000000
            ],
            [
                month,
                3,
                7776000000
            ],
            [
                year,
                1,
                31536000000
            ]
        ];
        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 / 31536000000, stop / 31536000000, 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] = _, k10 = (t0 = transform(x0 = +x0)) === (t1 = transform(x1 = +x1)) ? 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, k10 = (t0 = t(x0)) === (t1 = t(x1)) ? 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();
        }
    }, symbols = [
        circle$2,
        cross$2,
        diamond,
        square$1,
        star,
        triangle,
        wye
    ];
    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 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 ((s0 < 0 ? -1 : 1) + (s1 < 0 ? -1 : 1)) * 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 = node.children;
                children ? (node.x = children.reduce(meanXReduce, 0) / children.length, node.y = 1 + children.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 && (l += (x = jiggle(random)) * x), 0 === y && (l += (y = jiggle(random)) * 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, l = ((l = Math.sqrt((x = (target = link.target).x + target.vx - source.x - source.vx || jiggle(random)) * x + (y = target.y + target.vy - source.y - source.vy || jiggle(random)) * 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 && (l += (x = jiggle(random)) * x), 0 === y && (l += (y = jiggle(random)) * 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 && (l += (x = jiggle(random)) * x), 0 === y && (l += (y = jiggle(random)) * 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 value of values)(value = +valueof(value, ++index, values)) && adder.add(value);
        }
        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 x, x1, x0 = a[0] * radians$1, y0 = a[1] * radians$1, x11 = 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(x11), ky1 = cy1 * sin$1(x11), d = 2 * asin(sqrt((x = sin$1((x = y1 - y0) / 2)) * x + cy0 * cy1 * ((x1 = sin$1((x1 = x11 - x0) / 2)) * x1))), 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 value of values)(defined ? compare(value, max) > 0 : 0 === compare(value, value)) && (max = value, 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 = 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 value of values)(defined ? 0 > compare(value, min) : 0 === compare(value, value)) && (min = value, 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 value of values)null != (value = valueof(value, ++index, values)) && (value = +value) >= value && (++count, sum += value);
        }
        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) {
            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 = root.height + 1;
            return root.x0 = root.y0 = padding, root.x1 = dx, root.y1 = dy / n, root.eachBefore((dy1 = dy, 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)v = arcs[j = index[i]], a1 = a0 + (v > 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 value of values)(value = +valueof(value, ++index, values)) && (sum += value);
        }
        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 = symbols, 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, 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, ancestor1 = ancestor, vim.a.parent === v.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
    });
});