https://trainfo.ca/wp-content/plugins/relish-freemium/js/vendor/d3.js?ver=6.5.12

1// https://d3js.org v5.16.0 Copyright 2020 Mike Bostock
2(function (global, factory) {
3typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
4typeof define === 'function' && define.amd ? define(['exports'], factory) :
5(global = global || self, factory(global.d3 = global.d3 || {}));
6}(this, function (exports) { 'use strict';
7
8var version = "5.16.0";
9
10function ascending(a, b) {
11  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
12}
13
14function bisector(compare) {
15  if (compare.length === 1) compare = ascendingComparator(compare);
16  return {
17    left: function(a, x, lo, hi) {
18      if (lo == null) lo = 0;
19      if (hi == null) hi = a.length;
20      while (lo < hi) {
21        var mid = lo + hi >>> 1;
22        if (compare(a[mid], x) < 0) lo = mid + 1;
23        else hi = mid;
24      }
25      return lo;
26    },
27    right: function(a, x, lo, hi) {
28      if (lo == null) lo = 0;
29      if (hi == null) hi = a.length;
30      while (lo < hi) {
31        var mid = lo + hi >>> 1;
32        if (compare(a[mid], x) > 0) hi = mid;
33        else lo = mid + 1;
34      }
35      return lo;
36    }
37  };
38}
39
40function ascendingComparator(f) {
41  return function(d, x) {
42    return ascending(f(d), x);
43  };
44}
45
46var ascendingBisect = bisector(ascending);
47var bisectRight = ascendingBisect.right;
48var bisectLeft = ascendingBisect.left;
49
50function pairs(array, f) {
51  if (f == null) f = pair;
52  var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n);
53  while (i < n) pairs[i] = f(p, p = array[++i]);
54  return pairs;
55}
56
57function pair(a, b) {
58  return [a, b];
59}
60
61function cross(values0, values1, reduce) {
62  var n0 = values0.length,
63      n1 = values1.length,
64      values = new Array(n0 * n1),
65      i0,
66      i1,
67      i,
68      value0;
69
70  if (reduce == null) reduce = pair;
71
72  for (i0 = i = 0; i0 < n0; ++i0) {
73    for (value0 = values0[i0], i1 = 0; i1 < n1; ++i1, ++i) {
74      values[i] = reduce(value0, values1[i1]);
75    }
76  }
77
78  return values;
79}
80
81function descending(a, b) {
82  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
83}
84
85function number(x) {
86  return x === null ? NaN : +x;
87}
88
89function variance(values, valueof) {
90  var n = values.length,
91      m = 0,
92      i = -1,
93      mean = 0,
94      value,
95      delta,
96      sum = 0;
97
98  if (valueof == null) {
99    while (++i < n) {
100      if (!isNaN(value = number(values[i]))) {
101        delta = value - mean;
102        mean += delta / ++m;
103        sum += delta * (value - mean);
104      }
105    }
106  }
107
108  else {
109    while (++i < n) {
110      if (!isNaN(value = number(valueof(values[i], i, values)))) {
111        delta = value - mean;
112        mean += delta / ++m;
113        sum += delta * (value - mean);
114      }
115    }
116  }
117
118  if (m > 1) return sum / (m - 1);
119}
120
121function deviation(array, f) {
122  var v = variance(array, f);
123  return v ? Math.sqrt(v) : v;
124}
125
126function extent(values, valueof) {
127  var n = values.length,
128      i = -1,
129      value,
130      min,
131      max;
132
133  if (valueof == null) {
134    while (++i < n) { // Find the first comparable value.
135      if ((value = values[i]) != null && value >= value) {
136        min = max = value;
137        while (++i < n) { // Compare the remaining values.
138          if ((value = values[i]) != null) {
139            if (min > value) min = value;
140            if (max < value) max = value;
141          }
142        }
143      }
144    }
145  }
146
147  else {
148    while (++i < n) { // Find the first comparable value.
149      if ((value = valueof(values[i], i, values)) != null && value >= value) {
150        min = max = value;
151        while (++i < n) { // Compare the remaining values.
152          if ((value = valueof(values[i], i, values)) != null) {
153            if (min > value) min = value;
154            if (max < value) max = value;
155          }
156        }
157      }
158    }
159  }
160
161  return [min, max];
162}
163
164var array = Array.prototype;
165
166var slice = array.slice;
167var map = array.map;
168
169function constant(x) {
170  return function() {
171    return x;
172  };
173}
174
175function identity(x) {
176  return x;
177}
178
179function sequence(start, stop, step) {
180  start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
181
182  var i = -1,
183      n = Math.max(0, Math.ceil((stop - start) / step)) | 0,
184      range = new Array(n);
185
186  while (++i < n) {
187    range[i] = start + i * step;
188  }
189
190  return range;
191}
192
193var e10 = Math.sqrt(50),
194    e5 = Math.sqrt(10),
195    e2 = Math.sqrt(2);
196
197function ticks(start, stop, count) {
198  var reverse,
199      i = -1,
200      n,
201      ticks,
202      step;
203
204  stop = +stop, start = +start, count = +count;
205  if (start === stop && count > 0) return [start];
206  if (reverse = stop < start) n = start, start = stop, stop = n;
207  if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return [];
208
209  if (step > 0) {
210    start = Math.ceil(start / step);
211    stop = Math.floor(stop / step);
212    ticks = new Array(n = Math.ceil(stop - start + 1));
213    while (++i < n) ticks[i] = (start + i) * step;
214  } else {
215    start = Math.floor(start * step);
216    stop = Math.ceil(stop * step);
217    ticks = new Array(n = Math.ceil(start - stop + 1));
218    while (++i < n) ticks[i] = (start - i) / step;
219  }
220
221  if (reverse) ticks.reverse();
222
223  return ticks;
224}
225
226function tickIncrement(start, stop, count) {
227  var step = (stop - start) / Math.max(0, count),
228      power = Math.floor(Math.log(step) / Math.LN10),
229      error = step / Math.pow(10, power);
230  return power >= 0
231      ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power)
232      : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);
233}
234
235function tickStep(start, stop, count) {
236  var step0 = Math.abs(stop - start) / Math.max(0, count),
237      step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),
238      error = step0 / step1;
239  if (error >= e10) step1 *= 10;
240  else if (error >= e5) step1 *= 5;
241  else if (error >= e2) step1 *= 2;
242  return stop < start ? -step1 : step1;
243}
244
245function thresholdSturges(values) {
246  return Math.ceil(Math.log(values.length) / Math.LN2) + 1;
247}
248
249function histogram() {
250  var value = identity,
251      domain = extent,
252      threshold = thresholdSturges;
253
254  function histogram(data) {
255    var i,
256        n = data.length,
257        x,
258        values = new Array(n);
259
260    for (i = 0; i < n; ++i) {
261      values[i] = value(data[i], i, data);
262    }
263
264    var xz = domain(values),
265        x0 = xz[0],
266        x1 = xz[1],
267        tz = threshold(values, x0, x1);
268
269    // Convert number of thresholds into uniform thresholds.
270    if (!Array.isArray(tz)) {
271      tz = tickStep(x0, x1, tz);
272      tz = sequence(Math.ceil(x0 / tz) * tz, x1, tz); // exclusive
273    }
274
275    // Remove any thresholds outside the domain.
276    var m = tz.length;
277    while (tz[0] <= x0) tz.shift(), --m;
278    while (tz[m - 1] > x1) tz.pop(), --m;
279
280    var bins = new Array(m + 1),
281        bin;
282
283    // Initialize bins.
284    for (i = 0; i <= m; ++i) {
285      bin = bins[i] = [];
286      bin.x0 = i > 0 ? tz[i - 1] : x0;
287      bin.x1 = i < m ? tz[i] : x1;
288    }
289
290    // Assign data to bins by value, ignoring any outside the domain.
291    for (i = 0; i < n; ++i) {
292      x = values[i];
293      if (x0 <= x && x <= x1) {
294        bins[bisectRight(tz, x, 0, m)].push(data[i]);
295      }
296    }
297
298    return bins;
299  }
300
301  histogram.value = function(_) {
302    return arguments.length ? (value = typeof _ === "function" ? _ : constant(_), histogram) : value;
303  };
304
305  histogram.domain = function(_) {
306    return arguments.length ? (domain = typeof _ === "function" ? _ : constant([_[0], _[1]]), histogram) : domain;
307  };
308
309  histogram.thresholds = function(_) {
310    return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold;
311  };
312
313  return histogram;
314}
315
316function threshold(values, p, valueof) {
317  if (valueof == null) valueof = number;
318  if (!(n = values.length)) return;
319  if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);
320  if (p >= 1) return +valueof(values[n - 1], n - 1, values);
321  var n,
322      i = (n - 1) * p,
323      i0 = Math.floor(i),
324      value0 = +valueof(values[i0], i0, values),
325      value1 = +valueof(values[i0 + 1], i0 + 1, values);
326  return value0 + (value1 - value0) * (i - i0);
327}
328
329function freedmanDiaconis(values, min, max) {
330  values = map.call(values, number).sort(ascending);
331  return Math.ceil((max - min) / (2 * (threshold(values, 0.75) - threshold(values, 0.25)) * Math.pow(values.length, -1 / 3)));
332}
333
334function scott(values, min, max) {
335  return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3)));
336}
337
338function max(values, valueof) {
339  var n = values.length,
340      i = -1,
341      value,
342      max;
343
344  if (valueof == null) {
345    while (++i < n) { // Find the first comparable value.
346      if ((value = values[i]) != null && value >= value) {
347        max = value;
348        while (++i < n) { // Compare the remaining values.
349          if ((value = values[i]) != null && value > max) {
350            max = value;
351          }
352        }
353      }
354    }
355  }
356
357  else {
358    while (++i < n) { // Find the first comparable value.
359      if ((value = valueof(values[i], i, values)) != null && value >= value) {
360        max = value;
361        while (++i < n) { // Compare the remaining values.
362          if ((value = valueof(values[i], i, values)) != null && value > max) {
363            max = value;
364          }
365        }
366      }
367    }
368  }
369
370  return max;
371}
372
373function mean(values, valueof) {
374  var n = values.length,
375      m = n,
376      i = -1,
377      value,
378      sum = 0;
379
380  if (valueof == null) {
381    while (++i < n) {
382      if (!isNaN(value = number(values[i]))) sum += value;
383      else --m;
384    }
385  }
386
387  else {
388    while (++i < n) {
389      if (!isNaN(value = number(valueof(values[i], i, values)))) sum += value;
390      else --m;
391    }
392  }
393
394  if (m) return sum / m;
395}
396
397function median(values, valueof) {
398  var n = values.length,
399      i = -1,
400      value,
401      numbers = [];
402
403  if (valueof == null) {
404    while (++i < n) {
405      if (!isNaN(value = number(values[i]))) {
406        numbers.push(value);
407      }
408    }
409  }
410
411  else {
412    while (++i < n) {
413      if (!isNaN(value = number(valueof(values[i], i, values)))) {
414        numbers.push(value);
415      }
416    }
417  }
418
419  return threshold(numbers.sort(ascending), 0.5);
420}
421
422function merge(arrays) {
423  var n = arrays.length,
424      m,
425      i = -1,
426      j = 0,
427      merged,
428      array;
429
430  while (++i < n) j += arrays[i].length;
431  merged = new Array(j);
432
433  while (--n >= 0) {
434    array = arrays[n];
435    m = array.length;
436    while (--m >= 0) {
437      merged[--j] = array[m];
438    }
439  }
440
441  return merged;
442}
443
444function min(values, valueof) {
445  var n = values.length,
446      i = -1,
447      value,
448      min;
449
450  if (valueof == null) {
451    while (++i < n) { // Find the first comparable value.
452      if ((value = values[i]) != null && value >= value) {
453        min = value;
454        while (++i < n) { // Compare the remaining values.
455          if ((value = values[i]) != null && min > value) {
456            min = value;
457          }
458        }
459      }
460    }
461  }
462
463  else {
464    while (++i < n) { // Find the first comparable value.
465      if ((value = valueof(values[i], i, values)) != null && value >= value) {
466        min = value;
467        while (++i < n) { // Compare the remaining values.
468          if ((value = valueof(values[i], i, values)) != null && min > value) {
469            min = value;
470          }
471        }
472      }
473    }
474  }
475
476  return min;
477}
478
479function permute(array, indexes) {
480  var i = indexes.length, permutes = new Array(i);
481  while (i--) permutes[i] = array[indexes[i]];
482  return permutes;
483}
484
485function scan(values, compare) {
486  if (!(n = values.length)) return;
487  var n,
488      i = 0,
489      j = 0,
490      xi,
491      xj = values[j];
492
493  if (compare == null) compare = ascending;
494
495  while (++i < n) {
496    if (compare(xi = values[i], xj) < 0 || compare(xj, xj) !== 0) {
497      xj = xi, j = i;
498    }
499  }
500
501  if (compare(xj, xj) === 0) return j;
502}
503
504function shuffle(array, i0, i1) {
505  var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0),
506      t,
507      i;
508
509  while (m) {
510    i = Math.random() * m-- | 0;
511    t = array[m + i0];
512    array[m + i0] = array[i + i0];
513    array[i + i0] = t;
514  }
515
516  return array;
517}
518
519function sum(values, valueof) {
520  var n = values.length,
521      i = -1,
522      value,
523      sum = 0;
524
525  if (valueof == null) {
526    while (++i < n) {
527      if (value = +values[i]) sum += value; // Note: zero and null are equivalent.
528    }
529  }
530
531  else {
532    while (++i < n) {
533      if (value = +valueof(values[i], i, values)) sum += value;
534    }
535  }
536
537  return sum;
538}
539
540function transpose(matrix) {
541  if (!(n = matrix.length)) return [];

542  for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) {
543    for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) {
544      row[j] = matrix[j][i];
545    }
546  }
547  return transpose;
548}
549
550function length(d) {
551  return d.length;
552}
553
554function zip() {
555  return transpose(arguments);
556}
557
558var slice$1 = Array.prototype.slice;
559
560function identity$1(x) {
561  return x;
562}
563
564var top = 1,
565    right = 2,
566    bottom = 3,
567    left = 4,
568    epsilon = 1e-6;
569
570function translateX(x) {
571  return "translate(" + (x + 0.5) + ",0)";
572}
573
574function translateY(y) {
575  return "translate(0," + (y + 0.5) + ")";
576}
577
578function number$1(scale) {
579  return function(d) {
580    return +scale(d);
581  };
582}
583
584function center(scale) {
585  var offset = Math.max(0, scale.bandwidth() - 1) / 2; // Adjust for 0.5px offset.
586  if (scale.round()) offset = Math.round(offset);
587  return function(d) {
588    return +scale(d) + offset;
589  };
590}
591
592function entering() {
593  return !this.__axis;
594}
595
596function axis(orient, scale) {
597  var tickArguments = [],
598      tickValues = null,
599      tickFormat = null,
600      tickSizeInner = 6,
601      tickSizeOuter = 6,
602      tickPadding = 3,
603      k = orient === top || orient === left ? -1 : 1,
604      x = orient === left || orient === right ? "x" : "y",
605      transform = orient === top || orient === bottom ? translateX : translateY;
606
607  function axis(context) {
608    var values = tickValues == null ? (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) : tickValues,
609        format = tickFormat == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : identity$1) : tickFormat,
610        spacing = Math.max(tickSizeInner, 0) + tickPadding,
611        range = scale.range(),
612        range0 = +range[0] + 0.5,
613        range1 = +range[range.length - 1] + 0.5,
614        position = (scale.bandwidth ? center : number$1)(scale.copy()),
615        selection = context.selection ? context.selection() : context,
616        path = selection.selectAll(".domain").data([null]),
617        tick = selection.selectAll(".tick").data(values, scale).order(),
618        tickExit = tick.exit(),
619        tickEnter = tick.enter().append("g").attr("class", "tick"),
620        line = tick.select("line"),
621        text = tick.select("text");
622
623    path = path.merge(path.enter().insert("path", ".tick")
624        .attr("class", "domain")
625        .attr("stroke", "currentColor"));
626
627    tick = tick.merge(tickEnter);
628
629    line = line.merge(tickEnter.append("line")
630        .attr("stroke", "currentColor")
631        .attr(x + "2", k * tickSizeInner));
632
633    text = text.merge(tickEnter.append("text")
634        .attr("fill", "currentColor")
635        .attr(x, k * spacing)
636        .attr("dy", orient === top ? "0em" : orient === bottom ? "0.71em" : "0.32em"));
637
638    if (context !== selection) {
639      path = path.transition(context);
640      tick = tick.transition(context);
641      line = line.transition(context);
642      text = text.transition(context);
643
644      tickExit = tickExit.transition(context)
645          .attr("opacity", epsilon)
646          .attr("transform", function(d) { return isFinite(d = position(d)) ? transform(d) : this.getAttribute("transform"); });
647
648      tickEnter
649          .attr("opacity", epsilon)
650          .attr("transform", function(d) { var p = this.parentNode.__axis; return transform(p && isFinite(p = p(d)) ? p : position(d)); });
651    }
652
653    tickExit.remove();
654
655    path
656        .attr("d", orient === left || orient == right
657            ? (tickSizeOuter ? "M" + k * tickSizeOuter + "," + range0 + "H0.5V" + range1 + "H" + k * tickSizeOuter : "M0.5," + range0 + "V" + range1)
658            : (tickSizeOuter ? "M" + range0 + "," + k * tickSizeOuter + "V0.5H" + range1 + "V" + k * tickSizeOuter : "M" + range0 + ",0.5H" + range1));
659
660    tick
661        .attr("opacity", 1)
662        .attr("transform", function(d) { return transform(position(d)); });
663
664    line
665        .attr(x + "2", k * tickSizeInner);
666
667    text
668        .attr(x, k * spacing)
669        .text(format);
670
671    selection.filter(entering)
672        .attr("fill", "none")
673        .attr("font-size", 10)
674        .attr("font-family", "sans-serif")
675        .attr("text-anchor", orient === right ? "start" : orient === left ? "end" : "middle");
676
677    selection
678        .each(function() { this.__axis = position; });
679  }
680
681  axis.scale = function(_) {
682    return arguments.length ? (scale = _, axis) : scale;
683  };
684
685  axis.ticks = function() {
686    return tickArguments = slice$1.call(arguments), axis;
687  };
688
689  axis.tickArguments = function(_) {
690    return arguments.length ? (tickArguments = _ == null ? [] : slice$1.call(_), axis) : tickArguments.slice();
691  };
692
693  axis.tickValues = function(_) {
694    return arguments.length ? (tickValues = _ == null ? null : slice$1.call(_), axis) : tickValues && tickValues.slice();
695  };
696
697  axis.tickFormat = function(_) {
698    return arguments.length ? (tickFormat = _, axis) : tickFormat;
699  };
700
701  axis.tickSize = function(_) {
702    return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis) : tickSizeInner;
703  };
704
705  axis.tickSizeInner = function(_) {
706    return arguments.length ? (tickSizeInner = +_, axis) : tickSizeInner;
707  };
708
709  axis.tickSizeOuter = function(_) {
710    return arguments.length ? (tickSizeOuter = +_, axis) : tickSizeOuter;
711  };
712
713  axis.tickPadding = function(_) {
714    return arguments.length ? (tickPadding = +_, axis) : tickPadding;
715  };
716
717  return axis;
718}
719
720function axisTop(scale) {
721  return axis(top, scale);
722}
723
724function axisRight(scale) {
725  return axis(right, scale);
726}
727
728function axisBottom(scale) {
729  return axis(bottom, scale);
730}
731
732function axisLeft(scale) {
733  return axis(left, scale);
734}
735
736var noop = {value: function() {}};
737
738function dispatch() {
739  for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) {
740    if (!(t = arguments[i] + "") || (t in _) || /[\s.]/.test(t)) throw new Error("illegal type: " + t);
741    _[t] = [];
742  }
743  return new Dispatch(_);
744}
745
746function Dispatch(_) {
747  this._ = _;
748}
749
750function parseTypenames(typenames, types) {
751  return typenames.trim().split(/^|\s+/).map(function(t) {
752    var name = "", i = t.indexOf(".");
753    if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);
754    if (t && !types.hasOwnProperty(t)) throw new Error("unknown type: " + t);
755    return {type: t, name: name};
756  });
757}
758
759Dispatch.prototype = dispatch.prototype = {
760  constructor: Dispatch,
761  on: function(typename, callback) {
762    var _ = this._,
763        T = parseTypenames(typename + "", _),

764        t,
765        i = -1,
766        n = T.length;
767
768    // If no callback was specified, return the callback of the given type and name.
769    if (arguments.length < 2) {
770      while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;
771      return;
772    }
773
774    // If a type was specified, set the callback for the given type and name.
775    // Otherwise, if a null callback was specified, remove callbacks of the given name.
776    if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback);
777    while (++i < n) {
778      if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback);
779      else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null);
780    }
781
782    return this;
783  },
784  copy: function() {
785    var copy = {}, _ = this._;
786    for (var t in _) copy[t] = _[t].slice();
787    return new Dispatch(copy);
788  },
789  call: function(type, that) {
790    if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2];
791    if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type);
792    for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);
793  },
794  apply: function(type, that, args) {
795    if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type);
796    for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);
797  }
798};
799
800function get(type, name) {
801  for (var i = 0, n = type.length, c; i < n; ++i) {
802    if ((c = type[i]).name === name) {
803      return c.value;
804    }
805  }
806}
807
808function set(type, name, callback) {
809  for (var i = 0, n = type.length; i < n; ++i) {
810    if (type[i].name === name) {
811      type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1));
812      break;
813    }
814  }
815  if (callback != null) type.push({name: name, value: callback});
816  return type;
817}
818
819var xhtml = "http://www.w3.org/1999/xhtml";
820
821var namespaces = {
822  svg: "http://www.w3.org/2000/svg",
823  xhtml: xhtml,
824  xlink: "http://www.w3.org/1999/xlink",
825  xml: "http://www.w3.org/XML/1998/namespace",
826  xmlns: "http://www.w3.org/2000/xmlns/"
827};
828
829function namespace(name) {
830  var prefix = name += "", i = prefix.indexOf(":");
831  if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1);
832  return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name;
833}
834
835function creatorInherit(name) {
836  return function() {
837    var document = this.ownerDocument,
838        uri = this.namespaceURI;
839    return uri === xhtml && document.documentElement.namespaceURI === xhtml
840        ? document.createElement(name)
841        : document.createElementNS(uri, name);
842  };
843}
844
845function creatorFixed(fullname) {
846  return function() {
847    return this.ownerDocument.createElementNS(fullname.space, fullname.local);
848  };
849}
850
851function creator(name) {
852  var fullname = namespace(name);
853  return (fullname.local
854      ? creatorFixed
855      : creatorInherit)(fullname);
856}
857
858function none() {}
859
860function selector(selector) {
861  return selector == null ? none : function() {
862    return this.querySelector(selector);
863  };
864}
865
866function selection_select(select) {
867  if (typeof select !== "function") select = selector(select);
868
869  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
870    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {
871      if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {
872        if ("__data__" in node) subnode.__data__ = node.__data__;
873        subgroup[i] = subnode;
874      }
875    }
876  }
877
878  return new Selection(subgroups, this._parents);
879}
880
881function empty() {
882  return [];
883}
884
885function selectorAll(selector) {
886  return selector == null ? empty : function() {
887    return this.querySelectorAll(selector);
888  };
889}
890
891function selection_selectAll(select) {
892  if (typeof select !== "function") select = selectorAll(select);
893
894  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {
895    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
896      if (node = group[i]) {
897        subgroups.push(select.call(node, node.__data__, i, group));
898        parents.push(node);
899      }
900    }
901  }
902
903  return new Selection(subgroups, parents);
904}
905
906function matcher(selector) {
907  return function() {
908    return this.matches(selector);
909  };
910}
911
912function selection_filter(match) {
913  if (typeof match !== "function") match = matcher(match);
914
915  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
916    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {
917      if ((node = group[i]) && match.call(node, node.__data__, i, group)) {
918        subgroup.push(node);
919      }
920    }
921  }
922
923  return new Selection(subgroups, this._parents);
924}
925
926function sparse(update) {
927  return new Array(update.length);
928}
929
930function selection_enter() {
931  return new Selection(this._enter || this._groups.map(sparse), this._parents);
932}
933
934function EnterNode(parent, datum) {
935  this.ownerDocument = parent.ownerDocument;
936  this.namespaceURI = parent.namespaceURI;
937  this._next = null;
938  this._parent = parent;
939  this.__data__ = datum;
940}
941
942EnterNode.prototype = {
943  constructor: EnterNode,
944  appendChild: function(child) { return this._parent.insertBefore(child, this._next); },
945  insertBefore: function(child, next) { return this._parent.insertBefore(child, next); },
946  querySelector: function(selector) { return this._parent.querySelector(selector); },
947  querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); }
948};
949
950function constant$1(x) {
951  return function() {
952    return x;
953  };
954}
955
956var keyPrefix = "$"; // Protect against keys like “__proto__”.
957
958function bindIndex(parent, group, enter, update, exit, data) {
959  var i = 0,
960      node,
961      groupLength = group.length,
962      dataLength = data.length;
963
964  // Put any non-null nodes that fit into update.
965  // Put any null nodes into enter.
966  // Put any remaining data into enter.
967  for (; i < dataLength; ++i) {
968    if (node = group[i]) {
969      node.__data__ = data[i];
970      update[i] = node;
971    } else {
972      enter[i] = new EnterNode(parent, data[i]);
973    }
974  }
975
976  // Put any non-null nodes that don’t fit into exit.
977  for (; i < groupLength; ++i) {
978    if (node = group[i]) {
979      exit[i] = node;
980    }
981  }
982}
983
984function bindKey(parent, group, enter, update, exit, data, key) {
985  var i,
986      node,
987      nodeByKeyValue = {},
988      groupLength = group.length,
989      dataLength = data.length,
990      keyValues = new Array(groupLength),
991      keyValue;
992
993  // Compute the key for each node.
994  // If multiple nodes have the same key, the duplicates are added to exit.
995  for (i = 0; i < groupLength; ++i) {
996    if (node = group[i]) {
997      keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group);
998      if (keyValue in nodeByKeyValue) {
999        exit[i] = node;
1000      } else {
1001        nodeByKeyValue[keyValue] = node;
1002      }
1003    }
1004  }
1005
1006  // Compute the key for each datum.
1007  // If there a node associated with this key, join and add it to update.
1008  // If there is not (or the key is a duplicate), add it to enter.
1009  for (i = 0; i < dataLength; ++i) {
1010    keyValue = keyPrefix + key.call(parent, data[i], i, data);
1011    if (node = nodeByKeyValue[keyValue]) {
1012      update[i] = node;
1013      node.__data__ = data[i];
1014      nodeByKeyValue[keyValue] = null;
1015    } else {
1016      enter[i] = new EnterNode(parent, data[i]);
1017    }
1018  }
1019
1020  // Add any remaining nodes that were not bound to data to exit.
1021  for (i = 0; i < groupLength; ++i) {
1022    if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) {
1023      exit[i] = node;
1024    }
1025  }
1026}
1027
1028function selection_data(value, key) {
1029  if (!value) {

1030    data = new Array(this.size()), j = -1;
1031    this.each(function(d) { data[++j] = d; });
1032    return data;
1033  }
1034
1035  var bind = key ? bindKey : bindIndex,
1036      parents = this._parents,
1037      groups = this._groups;
1038
1039  if (typeof value !== "function") value = constant$1(value);
1040
1041  for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) {
1042    var parent = parents[j],
1043        group = groups[j],
1044        groupLength = group.length,
1045        data = value.call(parent, parent && parent.__data__, j, parents),
1046        dataLength = data.length,
1047        enterGroup = enter[j] = new Array(dataLength),
1048        updateGroup = update[j] = new Array(dataLength),
1049        exitGroup = exit[j] = new Array(groupLength);
1050
1051    bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);
1052
1053    // Now connect the enter nodes to their following update node, such that
1054    // appendChild can insert the materialized enter node before this node,
1055    // rather than at the end of the parent node.
1056    for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) {
1057      if (previous = enterGroup[i0]) {
1058        if (i0 >= i1) i1 = i0 + 1;
1059        while (!(next = updateGroup[i1]) && ++i1 < dataLength);
1060        previous._next = next || null;
1061      }
1062    }
1063  }
1064
1065  update = new Selection(update, parents);
1066  update._enter = enter;
1067  update._exit = exit;
1068  return update;
1069}
1070
1071function selection_exit() {
1072  return new Selection(this._exit || this._groups.map(sparse), this._parents);
1073}
1074
1075function selection_join(onenter, onupdate, onexit) {
1076  var enter = this.enter(), update = this, exit = this.exit();
1077  enter = typeof onenter === "function" ? onenter(enter) : enter.append(onenter + "");
1078  if (onupdate != null) update = onupdate(update);
1079  if (onexit == null) exit.remove(); else onexit(exit);
1080  return enter && update ? enter.merge(update).order() : update;
1081}
1082
1083function selection_merge(selection) {
1084
1085  for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {
1086    for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {
1087      if (node = group0[i] || group1[i]) {
1088        merge[i] = node;
1089      }
1090    }
1091  }
1092
1093  for (; j < m0; ++j) {
1094    merges[j] = groups0[j];
1095  }
1096
1097  return new Selection(merges, this._parents);
1098}
1099
1100function selection_order() {
1101
1102  for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) {
1103    for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) {
1104      if (node = group[i]) {
1105        if (next && node.compareDocumentPosition(next) ^ 4) next.parentNode.insertBefore(node, next);
1106        next = node;
1107      }
1108    }
1109  }
1110
1111  return this;
1112}
1113
1114function selection_sort(compare) {
1115  if (!compare) compare = ascending$1;
1116
1117  function compareNode(a, b) {
1118    return a && b ? compare(a.__data__, b.__data__) : !a - !b;
1119  }
1120
1121  for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) {
1122    for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) {
1123      if (node = group[i]) {
1124        sortgroup[i] = node;
1125      }
1126    }
1127    sortgroup.sort(compareNode);
1128  }
1129
1130  return new Selection(sortgroups, this._parents).order();
1131}
1132
1133function ascending$1(a, b) {
1134  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
1135}
1136
1137function selection_call() {
1138  var callback = arguments[0];
1139  arguments[0] = this;
1140  callback.apply(null, arguments);
1141  return this;
1142}
1143
1144function selection_nodes() {
1145  var nodes = new Array(this.size()), i = -1;
1146  this.each(function() { nodes[++i] = this; });
1147  return nodes;
1148}
1149
1150function selection_node() {
1151
1152  for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
1153    for (var group = groups[j], i = 0, n = group.length; i < n; ++i) {
1154      var node = group[i];
1155      if (node) return node;
1156    }
1157  }
1158
1159  return null;
1160}
1161
1162function selection_size() {
1163  var size = 0;
1164  this.each(function() { ++size; });

1164
1165  return size;
1166}
1167
1168function selection_empty() {
1169  return !this.node();
1170}
1171
1172function selection_each(callback) {
1173
1174  for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
1175    for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {
1176      if (node = group[i]) callback.call(node, node.__data__, i, group);
1177    }
1178  }
1179
1180  return this;
1181}
1182
1183function attrRemove(name) {
1184  return function() {
1185    this.removeAttribute(name);
1186  };
1187}
1188
1189function attrRemoveNS(fullname) {
1190  return function() {
1191    this.removeAttributeNS(fullname.space, fullname.local);
1192  };
1193}
1194
1195function attrConstant(name, value) {
1196  return function() {
1197    this.setAttribute(name, value);
1198  };
1199}
1200
1201function attrConstantNS(fullname, value) {
1202  return function() {
1203    this.setAttributeNS(fullname.space, fullname.local, value);
1204  };
1205}
1206
1207function attrFunction(name, value) {
1208  return function() {
1209    var v = value.apply(this, arguments);
1210    if (v == null) this.removeAttribute(name);
1211    else this.setAttribute(name, v);
1212  };
1213}
1214
1215function attrFunctionNS(fullname, value) {
1216  return function() {
1217    var v = value.apply(this, arguments);
1218    if (v == null) this.removeAttributeNS(fullname.space, fullname.local);
1219    else this.setAttributeNS(fullname.space, fullname.local, v);
1220  };
1221}
1222
1223function selection_attr(name, value) {
1224  var fullname = namespace(name);
1225
1226  if (arguments.length < 2) {
1227    var node = this.node();
1228    return fullname.local
1229        ? node.getAttributeNS(fullname.space, fullname.local)
1230        : node.getAttribute(fullname);
1231  }
1232
1233  return this.each((value == null
1234      ? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === "function"
1235      ? (fullname.local ? attrFunctionNS : attrFunction)
1236      : (fullname.local ? attrConstantNS : attrConstant)))(fullname, value));
1237}
1238
1239function defaultView(node) {
1240  return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node
1241      || (node.document && node) // node is a Window
1242      || node.defaultView; // node is a Document
1243}
1244
1245function styleRemove(name) {
1246  return function() {
1247    this.style.removeProperty(name);
1248  };
1249}
1250
1251function styleConstant(name, value, priority) {
1252  return function() {
1253    this.style.setProperty(name, value, priority);
1254  };
1255}
1256
1257function styleFunction(name, value, priority) {
1258  return function() {
1259    var v = value.apply(this, arguments);
1260    if (v == null) this.style.removeProperty(name);
1261    else this.style.setProperty(name, v, priority);
1262  };
1263}
1264
1265function selection_style(name, value, priority) {
1266  return arguments.length > 1
1267      ? this.each((value == null
1268            ? styleRemove : typeof value === "function"
1269            ? styleFunction
1270            : styleConstant)(name, value, priority == null ? "" : priority))
1271      : styleValue(this.node(), name);
1272}
1273
1274function styleValue(node, name) {
1275  return node.style.getPropertyValue(name)
1276      || defaultView(node).getComputedStyle(node, null).getPropertyValue(name);
1277}
1278
1279function propertyRemove(name) {
1280  return function() {
1281    delete this[name];
1282  };
1283}
1284
1285function propertyConstant(name, value) {
1286  return function() {
1287    this[name] = value;
1288  };
1289}
1290
1291function propertyFunction(name, value) {
1292  return function() {
1293    var v = value.apply(this, arguments);
1294    if (v == null) delete this[name];
1295    else this[name] = v;
1296  };
1297}
1298
1299function selection_property(name, value) {
1300  return arguments.length > 1
1301      ? this.each((value == null
1302          ? propertyRemove : typeof value === "function"
1303          ? propertyFunction
1304          : propertyConstant)(name, value))
1305      : this.node()[name];
1306}
1307
1308function classArray(string) {
1309  return string.trim().split(/^|\s+/);
1310}
1311
1312function classList(node) {
1313  return node.classList || new ClassList(node);
1314}
1315
1316function ClassList(node) {
1317  this._node = node;
1318  this._names = classArray(node.getAttribute("class") || "");
1319}
1320
1321ClassList.prototype = {
1322  add: function(name) {
1323    var i = this._names.indexOf(name);
1324    if (i < 0) {
1325      this._names.push(name);
1326      this._node.setAttribute("class", this._names.join(" "));
1327    }
1328  },
1329  remove: function(name) {
1330    var i = this._names.indexOf(name);
1331    if (i >= 0) {
1332      this._names.splice(i, 1);
1333      this._node.setAttribute("class", this._names.join(" "));
1334    }
1335  },
1336  contains: function(name) {
1337    return this._names.indexOf(name) >= 0;
1338  }
1339};
1340
1341function classedAdd(node, names) {
1342  var list = classList(node), i = -1, n = names.length;
1343  while (++i < n) list.add(names[i]);
1344}
1345
1346function classedRemove(node, names) {
1347  var list = classList(node), i = -1, n = names.length;
1348  while (++i < n) list.remove(names[i]);
1349}
1350
1351function classedTrue(names) {
1352  return function() {
1353    classedAdd(this, names);
1354  };
1355}
1356
1357function classedFalse(names) {
1358  return function() {
1359    classedRemove(this, names);
1360  };
1361}
1362
1363function classedFunction(names, value) {
1364  return function() {
1365    (value.apply(this, arguments) ? classedAdd : classedRemove)(this, names);
1366  };
1367}
1368
1369function selection_classed(name, value) {
1370  var names = classArray(name + "");
1371
1372  if (arguments.length < 2) {
1373    var list = classList(this.node()), i = -1, n = names.length;
1374    while (++i < n) if (!list.contains(names[i])) return false;
1375    return true;
1376  }
1377
1378  return this.each((typeof value === "function"
1379      ? classedFunction : value
1380      ? classedTrue
1381      : classedFalse)(names, value));
1382}
1383
1384function textRemove() {
1385  this.textContent = "";
1386}
1387
1388function textConstant(value) {
1389  return function() {
1390    this.textContent = value;
1391  };
1392}
1393
1394function textFunction(value) {
1395  return function() {
1396    var v = value.apply(this, arguments);
1397    this.textContent = v == null ? "" : v;
1398  };
1399}
1400
1401function selection_text(value) {
1402  return arguments.length
1403      ? this.each(value == null
1404          ? textRemove : (typeof value === "function"
1405          ? textFunction
1406          : textConstant)(value))
1407      : this.node().textContent;
1408}
1409
1410function htmlRemove() {
1411  this.innerHTML = "";
1412}
1413
1414function htmlConstant(value) {
1415  return function() {
1416    this.innerHTML = value;
1417  };
1418}
1419
1420function htmlFunction(value) {
1421  return function() {
1422    var v = value.apply(this, arguments);
1423    this.innerHTML = v == null ? "" : v;
1424  };
1425}
1426
1427function selection_html(value) {
1428  return arguments.length
1429      ? this.each(value == null
1430          ? htmlRemove : (typeof value === "function"
1431          ? htmlFunction
1432          : htmlConstant)(value))
1433      : this.node().innerHTML;
1434}
1435
1436function raise() {
1437  if (this.nextSibling) this.parentNode.appendChild(this);
1438}
1439
1440function selection_raise() {
1441  return this.each(raise);
1442}
1443
1444function lower() {
1445  if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild);
1446}
1447
1448function selection_lower() {
1449  return this.each(lower);
1450}
1451
1452function selection_append(name) {
1453  var create = typeof name === "function" ? name : creator(name);
1454  return this.select(function() {
1455    return this.appendChild(create.apply(this, arguments));
1456  });
1457}
1458
1459function constantNull() {
1460  return null;
1461}
1462
1463function selection_insert(name, before) {
1464  var create = typeof name === "function" ? name : creator(name),
1465      select = before == null ? constantNull : typeof before === "function" ? before : selector(before);
1466  return this.select(function() {
1467    return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null);
1468  });
1469}
1470
1471function remove() {
1472  var parent = this.parentNode;
1473  if (parent) parent.removeChild(this);
1474}
1475
1476function selection_remove() {
1477  return this.each(remove);
1478}
1479
1480function selection_cloneShallow() {
1481  var clone = this.cloneNode(false), parent = this.parentNode;
1482  return parent ? parent.insertBefore(clone, this.nextSibling) : clone;
1483}
1484
1485function selection_cloneDeep() {
1486  var clone = this.cloneNode(true), parent = this.parentNode;
1487  return parent ? parent.insertBefore(clone, this.nextSibling) : clone;
1488}
1489
1490function selection_clone(deep) {
1491  return this.select(deep ? selection_cloneDeep : selection_cloneShallow);
1492}
1493
1494function selection_datum(value) {
1495  return arguments.length
1496      ? this.property("__data__", value)
1497      : this.node().__data__;
1498}
1499

1500var filterEvents = {};
1501
1502exports.event = null;
1503
1504if (typeof document !== "undefined") {
1505  var element = document.documentElement;
1506  if (!("onmouseenter" in element)) {
1507    filterEvents = {mouseenter: "mouseover", mouseleave: "mouseout"};
1508  }
1509}
1510
1511function filterContextListener(listener, index, group) {
1512  listener = contextListener(listener, index, group);
1513  return function(event) {
1514    var related = event.relatedTarget;
1515    if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) {
1516      listener.call(this, event);
1517    }
1518  };
1519}
1520
1521function contextListener(listener, index, group) {
1522  return function(event1) {
1523    var event0 = exports.event; // Events can be reentrant (e.g., focus).
1524    exports.event = event1;
1525    try {
1526      listener.call(this, this.__data__, index, group);
1527    } finally {
1528      exports.event = event0;
1529    }
1530  };
1531}
1532
1533function parseTypenames$1(typenames) {
1534  return typenames.trim().split(/^|\s+/).map(function(t) {
1535    var name = "", i = t.indexOf(".");
1536    if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);
1537    return {type: t, name: name};
1538  });
1539}
1540
1541function onRemove(typename) {
1542  return function() {
1543    var on = this.__on;
1544    if (!on) return;
1545    for (var j = 0, i = -1, m = on.length, o; j < m; ++j) {
1546      if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {
1547        this.removeEventListener(o.type, o.listener, o.capture);
1548      } else {
1549        on[++i] = o;
1550      }
1551    }
1552    if (++i) on.length = i;
1553    else delete this.__on;
1554  };
1555}
1556
1557function onAdd(typename, value, capture) {
1558  var wrap = filterEvents.hasOwnProperty(typename.type) ? filterContextListener : contextListener;
1559  return function(d, i, group) {
1560    var on = this.__on, o, listener = wrap(value, i, group);
1561    if (on) for (var j = 0, m = on.length; j < m; ++j) {
1562      if ((o = on[j]).type === typename.type && o.name === typename.name) {
1563        this.removeEventListener(o.type, o.listener, o.capture);
1564        this.addEventListener(o.type, o.listener = listener, o.capture = capture);
1565        o.value = value;
1566        return;
1567      }
1568    }
1569    this.addEventListener(typename.type, listener, capture);
1570    o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture};
1571    if (!on) this.__on = [o];
1572    else on.push(o);
1573  };
1574}
1575
1576function selection_on(typename, value, capture) {
1577  var typenames = parseTypenames$1(typename + ""), i, n = typenames.length, t;
1578
1579  if (arguments.length < 2) {
1580    var on = this.node().__on;
1581    if (on) for (var j = 0, m = on.length, o; j < m; ++j) {
1582      for (i = 0, o = on[j]; i < n; ++i) {
1583        if ((t = typenames[i]).type === o.type && t.name === o.name) {
1584          return o.value;
1585        }
1586      }
1587    }
1588    return;
1589  }
1590
1591  on = value ? onAdd : onRemove;
1592  if (capture == null) capture = false;

1996;
1997}
1998
1999function define(constructor, factory, prototype) {
2000  constructor.prototype = factory.prototype = prototype;
2001  prototype.constructor = constructor;
2002}
2003
2004function extend(parent, definition) {
2005  var prototype = Object.create(parent.prototype);
2006  for (var key in definition) prototype[key] = definition[key];
2007  return prototype;
2008}
2009
2010function Color() {}
2011
2012var darker = 0.7;
2013var brighter = 1 / darker;
2014
2015var reI = "\\s*([+-]?\\d+)\\s*",
2016    reN = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",
2017    reP = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",
2018    reHex = /^#([0-9a-f]{3,8})$/,
2019    reRgbInteger = new RegExp("^rgb\\(" + [reI, reI, reI] + "\\)$"),
2020    reRgbPercent = new RegExp("^rgb\\(" + [reP, reP, reP] + "\\)$"),
2021    reRgbaInteger = new RegExp("^rgba\\(" + [reI, reI, reI, reN] + "\\)$"),
2022    reRgbaPercent = new RegExp("^rgba\\(" + [reP, reP, reP, reN] + "\\)$"),
2023    reHslPercent = new RegExp("^hsl\\(" + [reN, reP, reP] + "\\)$"),
2024    reHslaPercent = new RegExp("^hsla\\(" + [reN, reP, reP, reN] + "\\)$");
2025
2026var named = {
2027  aliceblue: 0xf0f8ff,
2028  antiquewhite: 0xfaebd7,
2029  aqua: 0x00ffff,
2030  aquamarine: 0x7fffd4,
2031  azure: 0xf0ffff,
2032  beige: 0xf5f5dc,
2033  bisque: 0xffe4c4,
2034  black: 0x000000,
2035  blanchedalmond: 0xffebcd,
2036  blue: 0x0000ff,
2037  blueviolet: 0x8a2be2,
2038  brown: 0xa52a2a,
2039  burlywood: 0xdeb887,
2040  cadetblue: 0x5f9ea0,
2041  chartreuse: 0x7fff00,
2042  chocolate: 0xd2691e,
2043  coral: 0xff7f50,
2044  cornflowerblue: 0x6495ed,
2045  cornsilk: 0xfff8dc,
2046  crimson: 0xdc143c,
2047  cyan: 0x00ffff,
2048  darkblue: 0x00008b,
2049  darkcyan: 0x008b8b,
2050  darkgoldenrod: 0xb8860b,
2051  darkgray: 0xa9a9a9,
2052  darkgreen: 0x006400,
2053  darkgrey: 0xa9a9a9,
2054  darkkhaki: 0xbdb76b,
2055  darkmagenta: 0x8b008b,
2056  darkolivegreen: 0x556b2f,
2057  darkorange: 0xff8c00,
2058  darkorchid: 0x9932cc,
2059  darkred: 0x8b0000,
2060  darksalmon: 0xe9967a,
2061  darkseagreen: 0x8fbc8f,
2062  darkslateblue: 0x483d8b,
2063  darkslategray: 0x2f4f4f,
2064  darkslategrey: 0x2f4f4f,
2065  darkturquoise: 0x00ced1,
2066  darkviolet: 0x9400d3,
2067  deeppink: 0xff1493,
2068  deepskyblue: 0x00bfff,
2069  dimgray: 0x696969,
2070  dimgrey: 0x696969,
2071  dodgerblue: 0x1e90ff,
2072  firebrick: 0xb22222,
2073  floralwhite: 0xfffaf0,
2074  forestgreen: 0x228b22,
2075  fuchsia: 0xff00ff,
2076  gainsboro: 0xdcdcdc,
2077  ghostwhite: 0xf8f8ff,
2078  gold: 0xffd700,
2079  goldenrod: 0xdaa520,
2080  gray: 0x808080,
2081  green: 0x008000,
2082  greenyellow: 0xadff2f,
2083  grey: 0x808080,
2084  honeydew: 0xf0fff0,
2085  hotpink: 0xff69b4,
2086  indianred: 0xcd5c5c,
2087  indigo: 0x4b0082,
2088  ivory: 0xfffff0,
2089  khaki: 0xf0e68c,
2090  lavender: 0xe6e6fa,
2091  lavenderblush: 0xfff0f5,
2092  lawngreen: 0x7cfc00,
2093  lemonchiffon: 0xfffacd,
2094  lightblue: 0xadd8e6,
2095  lightcoral: 0xf08080,
2096  lightcyan: 0xe0ffff,
2097  lightgoldenrodyellow: 0xfafad2,
2098  lightgray: 0xd3d3d3,
2099  lightgreen: 0x90ee90,
2100  lightgrey: 0xd3d3d3,
2101  lightpink: 0xffb6c1,
2102  lightsalmon: 0xffa07a,
2103  lightseagreen: 0x20b2aa,
2104  lightskyblue: 0x87cefa,
2105  lightslategray: 0x778899,
2106  lightslategrey: 0x778899,
2107  lightsteelblue: 0xb0c4de,
2108  lightyellow: 0xffffe0,
2109  lime: 0x00ff00,
2110  limegreen: 0x32cd32,
2111  linen: 0xfaf0e6,
2112  magenta: 0xff00ff,
2113  maroon: 0x800000,
2114  mediumaquamarine: 0x66cdaa,
2115  mediumblue: 0x0000cd,
2116  mediumorchid: 0xba55d3,
2117  mediumpurple: 0x9370db,
2118  mediumseagreen: 0x3cb371,
2119  mediumslateblue: 0x7b68ee,
2120  mediumspringgreen: 0x00fa9a,
2121  mediumturquoise: 0x48d1cc,
2122  mediumvioletred: 0xc71585,
2123  midnightblue: 0x191970,
2124  mintcream: 0xf5fffa,
2125  mistyrose: 0xffe4e1,
2126  moccasin: 0xffe4b5,
2127  navajowhite: 0xffdead,
2128  navy: 0x000080,
2129  oldlace: 0xfdf5e6,
2130  olive: 0x808000,
2131  olivedrab: 0x6b8e23,
2132  orange: 0xffa500,
2133  orangered: 0xff4500,
2134  orchid: 0xda70d6,
2135  palegoldenrod: 0xeee8aa,
2136  palegreen: 0x98fb98,
2137  paleturquoise: 0xafeeee,
2138  palevioletred: 0xdb7093,
2139  papayawhip: 0xffefd5,
2140  peachpuff: 0xffdab9,
2141  peru: 0xcd853f,
2142  pink: 0xffc0cb,
2143  plum: 0xdda0dd,
2144  powderblue: 0xb0e0e6,
2145  purple: 0x800080,
2146  rebeccapurple: 0x663399,
2147  red: 0xff0000,
2148  rosybrown: 0xbc8f8f,
2149  royalblue: 0x4169e1,
2150  saddlebrown: 0x8b4513,
2151  salmon: 0xfa8072,
2152  sandybrown: 0xf4a460,
2153  seagreen: 0x2e8b57,
2154  seashell: 0xfff5ee,
2155  sienna: 0xa0522d,
2156  silver: 0xc0c0c0,
2157  skyblue: 0x87ceeb,
2158  slateblue: 0x6a5acd,
2159  slategray: 0x708090,
2160  slategrey: 0x708090,
2161  snow: 0xfffafa,
2162  springgreen: 0x00ff7f,
2163  steelblue: 0x4682b4,
2164  tan: 0xd2b48c,
2165  teal: 0x008080,
2166  thistle: 0xd8bfd8,
2167  tomato: 0xff6347,
2168  turquoise: 0x40e0d0,
2169  violet: 0xee82ee,
2170  wheat: 0xf5deb3,
2171  white: 0xffffff,
2172  whitesmoke: 0xf5f5f5,
2173  yellow: 0xffff00,
2174  yellowgreen: 0x9acd32
2175};
2176
2177define(Color, color, {
2178  copy: function(channels) {
2179    return Object.assign(new this.constructor, this, channels);
2180  },
2181  displayable: function() {
2182    return this.rgb().displayable();
2183  },
2184  hex: color_formatHex, // Deprecated! Use color.formatHex.
2185  formatHex: color_formatHex,
2186  formatHsl: color_formatHsl,
2187  formatRgb: color_formatRgb,
2188  toString: color_formatRgb
2189});
2190
2191function color_formatHex() {
2192  return this.rgb().formatHex();
2193}
2194
2195function color_formatHsl() {
2196  return hslConvert(this).formatHsl();
2197}
2198
2199function color_formatRgb() {
2200  return this.rgb().formatRgb();
2201}
2202
2203function color(format) {
2204  var m, l;
2205  format = (format + "").trim().toLowerCase();
2206  return (m = reHex.exec(format)) ? (l = m[1].length, m = parseInt(m[1], 16), l === 6 ? rgbn(m) // #ff0000
2207      : l === 3 ? new Rgb((m >> 8 & 0xf) | (m >> 4 & 0xf0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1) // #f00
2208      : l === 8 ? rgba(m >> 24 & 0xff, m >> 16 & 0xff, m >> 8 & 0xff, (m & 0xff) / 0xff) // #ff000000
2209      : l === 4 ? rgba((m >> 12 & 0xf) | (m >> 8 & 0xf0), (m >> 8 & 0xf) | (m >> 4 & 0xf0), (m >> 4 & 0xf) | (m & 0xf0), (((m & 0xf) << 4) | (m & 0xf)) / 0xff) // #f000
2210      : null) // invalid hex
2211      : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0)
2212      : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%)
2213      : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1)
2214      : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1)
2215      : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%)
2216      : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1)
2217      : named.hasOwnProperty(format) ? rgbn(named[format]) // eslint-disable-line no-prototype-builtins
2218      : format === "transparent" ? new Rgb(NaN, NaN, NaN, 0)
2219      : null;
2220}
2221
2222function rgbn(n) {
2223  return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1);
2224}
2225
2226function rgba(r, g, b, a) {
2227  if (a <= 0) r = g = b = NaN;
2228  return new Rgb(r, g, b, a);
2229}
2230
2231function rgbConvert(o) {
2232  if (!(o instanceof Color)) o = color(o);
2233  if (!o) return new Rgb;
2234  o = o.rgb();
2235  return new Rgb(o.r, o.g, o.b, o.opacity);
2236}
2237
2238function rgb(r, g, b, opacity) {
2239  return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);
2240}
2241
2242function Rgb(r, g, b, opacity) {
2243  this.r = +r;
2244  this.g = +g;
2245  this.b = +b;
2246  this.opacity = +opacity;
2247}
2248
2249define(Rgb, rgb, extend(Color, {
2250  brighter: function(k) {
2251    k = k == null ? brighter : Math.pow(brighter, k);
2252    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
2253  },
2254  darker: function(k) {
2255    k = k == null ? darker : Math.pow(darker, k);
2256    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
2257  },
2258  rgb: function() {
2259    return this;
2260  },
2261  displayable: function() {
2262    return (-0.5 <= this.r && this.r < 255.5)
2263        && (-0.5 <= this.g && this.g < 255.5)
2264        && (-0.5 <= this.b && this.b < 255.5)
2265        && (0 <= this.opacity && this.opacity <= 1);
2266  },
2267  hex: rgb_formatHex, // Deprecated! Use color.formatHex.
2268  formatHex: rgb_formatHex,
2269  formatRgb: rgb_formatRgb,
2270  toString: rgb_formatRgb
2271}));
2272
2273function rgb_formatHex() {
2274  return "#" + hex(this.r) + hex(this.g) + hex(this.b);
2275}
2276
2277function rgb_formatRgb() {
2278  var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a));
2279  return (a === 1 ? "rgb(" : "rgba(")
2280      + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", "
2281      + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", "
2282      + Math.max(0, Math.min(255, Math.round(this.b) || 0))
2283      + (a === 1 ? ")" : ", " + a + ")");
2284}
2285
2286function hex(value) {
2287  value = Math.max(0, Math.min(255, Math.round(value) || 0));
2288  return (value < 16 ? "0" : "") + value.toString(16);
2289}
2290
2291function hsla(h, s, l, a) {
2292  if (a <= 0) h = s = l = NaN;
2293  else if (l <= 0 || l >= 1) h = s = NaN;
2294  else if (s <= 0) h = NaN;
2295  return new Hsl(h, s, l, a);
2296}
2297
2298function hslConvert(o) {
2299  if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);
2300  if (!(o instanceof Color)) o = color(o);
2301  if (!o) return new Hsl;
2302  if (o instanceof Hsl) return o;
2303  o = o.rgb();
2304  var r = o.r / 255,
2305      g = o.g / 255,
2306      b = o.b / 255,
2307      min = Math.min(r, g, b),
2308      max = Math.max(r, g, b),
2309      h = NaN,
2310      s = max - min,
2311      l = (max + min) / 2;
2312  if (s) {
2313    if (r === max) h = (g - b) / s + (g < b) * 6;
2314    else if (g === max) h = (b - r) / s + 2;
2315    else h = (r - g) / s + 4;
2316    s /= l < 0.5 ? max + min : 2 - max - min;
2317    h *= 60;
2318  } else {
2319    s = l > 0 && l < 1 ? 0 : h;
2320  }
2321  return new Hsl(h, s, l, o.opacity);
2322}
2323
2324function hsl(h, s, l, opacity) {
2325  return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);
2326}
2327
2328function Hsl(h, s, l, opacity) {
2329  this.h = +h;
2330  this.s = +s;
2331  this.l = +l;
2332  this.opacity = +opacity;
2333}
2334
2335define(Hsl, hsl, extend(Color, {
2336  brighter: function(k) {
2337    k = k == null ? brighter : Math.pow(brighter, k);
2338    return new Hsl(this.h, this.s, this.l * k, this.opacity);
2339  },
2340  darker: function(k) {
2341    k = k == null ? darker : Math.pow(darker, k);
2342    return new Hsl(this.h, this.s, this.l * k, this.opacity);
2343  },
2344  rgb: function() {
2345    var h = this.h % 360 + (this.h < 0) * 360,
2346        s = isNaN(h) || isNaN(this.s) ? 0 : this.s,
2347        l = this.l,
2348        m2 = l + (l < 0.5 ? l : 1 - l) * s,
2349        m1 = 2 * l - m2;
2350    return new Rgb(
2351      hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2),
2352      hsl2rgb(h, m1, m2),
2353      hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2),
2354      this.opacity
2355    );
2356  },
2357  displayable: function() {
2358    return (0 <= this.s && this.s <= 1 || isNaN(this.s))
2359        && (0 <= this.l && this.l <= 1)
2360        && (0 <= this.opacity && this.opacity <= 1);
2361  },
2362  formatHsl: function() {
2363    var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a));
2364    return (a === 1 ? "hsl(" : "hsla(")
2365        + (this.h || 0) + ", "
2366        + (this.s || 0) * 100 + "%, "
2367        + (this.l || 0) * 100 + "%"
2368        + (a === 1 ? ")" : ", " + a + ")");
2369  }
2370}));
2371
2372/* From FvD 13.37, CSS Color Module Level 3 */
2373function hsl2rgb(h, m1, m2) {
2374  return (h < 60 ? m1 + (m2 - m1) * h / 60
2375      : h < 180 ? m2
2376      : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60
2377      : m1) * 255;
2378}
2379

2380var deg2rad = Math.PI / 180;
2381var rad2deg = 180 / Math.PI;
2382
2383// https://observablehq.com/@mbostock/lab-and-rgb
2384var K = 18,
2385    Xn = 0.96422,
2386    Yn = 1,
2387    Zn = 0.82521,
2388    t0 = 4 / 29,
2389    t1 = 6 / 29,
2390    t2 = 3 * t1 * t1,
2391    t3 = t1 * t1 * t1;
2392
2393function labConvert(o) {
2394  if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity);
2395  if (o instanceof Hcl) return hcl2lab(o);
2396  if (!(o instanceof Rgb)) o = rgbConvert(o);
2397  var r = rgb2lrgb(o.r),
2398      g = rgb2lrgb(o.g),
2399      b = rgb2lrgb(o.b),
2400      y = xyz2lab((0.2225045 * r + 0.7168786 * g + 0.0606169 * b) / Yn), x, z;
2401  if (r === g && g === b) x = z = y; else {
2402    x = xyz2lab((0.4360747 * r + 0.3850649 * g + 0.1430804 * b) / Xn);
2403    z = xyz2lab((0.0139322 * r + 0.0971045 * g + 0.7141733 * b) / Zn);
2404  }
2405  return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity);
2406}
2407
2408function gray(l, opacity) {
2409  return new Lab(l, 0, 0, opacity == null ? 1 : opacity);
2410}
2411
2412function lab(l, a, b, opacity) {
2413  return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity);
2414}
2415
2416function Lab(l, a, b, opacity) {
2417  this.l = +l;
2418  this.a = +a;
2419  this.b = +b;
2420  this.opacity = +opacity;
2421}
2422
2423define(Lab, lab, extend(Color, {
2424  brighter: function(k) {
2425    return new Lab(this.l + K * (k == null ? 1 : k), this.a, this.b, this.opacity);
2426  },
2427  darker: function(k) {
2428    return new Lab(this.l - K * (k == null ? 1 : k), this.a, this.b, this.opacity);
2429  },
2430  rgb: function() {
2431    var y = (this.l + 16) / 116,
2432        x = isNaN(this.a) ? y : y + this.a / 500,
2433        z = isNaN(this.b) ? y : y - this.b / 200;
2434    x = Xn * lab2xyz(x);
2435    y = Yn * lab2xyz(y);
2436    z = Zn * lab2xyz(z);
2437    return new Rgb(
2438      lrgb2rgb( 3.1338561 * x - 1.6168667 * y - 0.4906146 * z),
2439      lrgb2rgb(-0.9787684 * x + 1.9161415 * y + 0.0334540 * z),
2440      lrgb2rgb( 0.0719453 * x - 0.2289914 * y + 1.4052427 * z),
2441      this.opacity
2442    );
2443  }
2444}));
2445
2446function xyz2lab(t) {
2447  return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;
2448}
2449
2450function lab2xyz(t) {
2451  return t > t1 ? t * t * t : t2 * (t - t0);
2452}
2453
2454function lrgb2rgb(x) {
2455  return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055);
2456}
2457
2458function rgb2lrgb(x) {
2459  return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);
2460}
2461
2462function hclConvert(o) {
2463  if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity);
2464  if (!(o instanceof Lab)) o = labConvert(o);
2465  if (o.a === 0 && o.b === 0) return new Hcl(NaN, 0 < o.l && o.l < 100 ? 0 : NaN, o.l, o.opacity);
2466  var h = Math.atan2(o.b, o.a) * rad2deg;
2467  return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity);
2468}
2469
2470function lch(l, c, h, opacity) {
2471  return arguments.length === 1 ? hclConvert(l) : new Hcl(h, c, l, opacity == null ? 1 : opacity);
2472}
2473
2474function hcl(h, c, l, opacity) {
2475  return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity);
2476}
2477
2478function Hcl(h, c, l, opacity) {
2479  this.h = +h;
2480  this.c = +c;
2481  this.l = +l;
2482  this.opacity = +opacity;
2483}
2484
2485function hcl2lab(o) {
2486  if (isNaN(o.h)) return new Lab(o.l, 0, 0, o.opacity);
2487  var h = o.h * deg2rad;
2488  return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity);
2489}
2490
2491define(Hcl, hcl, extend(Color, {
2492  brighter: function(k) {
2493    return new Hcl(this.h, this.c, this.l + K * (k == null ? 1 : k), this.opacity);
2494  },
2495  darker: function(k) {
2496    return new Hcl(this.h, this.c, this.l - K * (k == null ? 1 : k), this.opacity);
2497  },
2498  rgb: function() {
2499    return hcl2lab(this).rgb();
2500  }
2501}));
2502
2503var A = -0.14861,
2504    B = +1.78277,
2505    C = -0.29227,
2506    D = -0.90649,
2507    E = +1.97294,
2508    ED = E * D,
2509    EB = E * B,
2510    BC_DA = B * C - D * A;
2511
2512function cubehelixConvert(o) {
2513  if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity);
2514  if (!(o instanceof Rgb)) o = rgbConvert(o);
2515  var r = o.r / 255,
2516      g = o.g / 255,
2517      b = o.b / 255,
2518      l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB),
2519      bl = b - l,
2520      k = (E * (g - l) - C * bl) / D,
2521      s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1
2522      h = s ? Math.atan2(k, bl) * rad2deg - 120 : NaN;
2523  return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity);
2524}
2525
2526function cubehelix(h, s, l, opacity) {
2527  return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity);
2528}
2529
2530function Cubehelix(h, s, l, opacity) {
2531  this.h = +h;
2532  this.s = +s;
2533  this.l = +l;
2534  this.opacity = +opacity;
2535}
2536
2537define(Cubehelix, cubehelix, extend(Color, {
2538  brighter: function(k) {
2539    k = k == null ? brighter : Math.pow(brighter, k);
2540    return new Cubehelix(this.h, this.s, this.l * k, this.opacity);
2541  },
2542  darker: function(k) {
2543    k = k == null ? darker : Math.pow(darker, k);
2544    return new Cubehelix(this.h, this.s, this.l * k, this.opacity);
2545  },
2546  rgb: function() {
2547    var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad,
2548        l = +this.l,
2549        a = isNaN(this.s) ? 0 : this.s * l * (1 - l),
2550        cosh = Math.cos(h),
2551        sinh = Math.sin(h);
2552    return new Rgb(
2553      255 * (l + a * (A * cosh + B * sinh)),
2554      255 * (l + a * (C * cosh + D * sinh)),
2555      255 * (l + a * (E * cosh)),
2556      this.opacity
2557    );
2558  }
2559}));
2560
2561function basis(t1, v0, v1, v2, v3) {
2562  var t2 = t1 * t1, t3 = t2 * t1;
2563  return ((1 - 3 * t1 + 3 * t2 - t3) * v0
2564      + (4 - 6 * t2 + 3 * t3) * v1
2565      + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2
2566      + t3 * v3) / 6;
2567}
2568
2569function basis$1(values) {
2570  var n = values.length - 1;
2571  return function(t) {
2572    var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n),
2573        v1 = values[i],
2574        v2 = values[i + 1],
2575        v0 = i > 0 ? values[i - 1] : 2 * v1 - v2,
2576        v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;
2577    return basis((t - i / n) * n, v0, v1, v2, v3);
2578  };
2579}
2580
2581function basisClosed(values) {
2582  var n = values.length;
2583  return function(t) {
2584    var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n),
2585        v0 = values[(i + n - 1) % n],
2586        v1 = values[i % n],
2587        v2 = values[(i + 1) % n],
2588        v3 = values[(i + 2) % n];
2589    return basis((t - i / n) * n, v0, v1, v2, v3);
2590  };
2591}
2592
2593function constant$3(x) {
2594  return function() {
2595    return x;
2596  };
2597}
2598
2599function linear(a, d) {
2600  return function(t) {
2601    return a + t * d;
2602  };
2603}
2604
2605function exponential(a, b, y) {
2606  return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) {
2607    return Math.pow(a + t * b, y);
2608  };
2609}
2610
2611function hue(a, b) {
2612  var d = b - a;
2613  return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant$3(isNaN(a) ? b : a);
2614}
2615
2616function gamma(y) {
2617  return (y = +y) === 1 ? nogamma : function(a, b) {
2618    return b - a ? exponential(a, b, y) : constant$3(isNaN(a) ? b : a);
2619  };
2620}
2621
2622function nogamma(a, b) {
2623  var d = b - a;
2624  return d ? linear(a, d) : constant$3(isNaN(a) ? b : a);
2625}
2626
2627var interpolateRgb = (function rgbGamma(y) {
2628  var color = gamma(y);
2629
2630  function rgb$1(start, end) {
2631    var r = color((start = rgb(start)).r, (end = rgb(end)).r),
2632        g = color(start.g, end.g),
2633        b = color(start.b, end.b),
2634        opacity = nogamma(start.opacity, end.opacity);
2635    return function(t) {
2636      start.r = r(t);
2637      start.g = g(t);
2638      start.b = b(t);
2639      start.opacity = opacity(t);
2640      return start + "";
2641    };
2642  }
2643
2644  rgb$1.gamma = rgbGamma;
2645
2646  return rgb$1;
2647})(1);
2648
2649function rgbSpline(spline) {
2650  return function(colors) {
2651    var n = colors.length,
2652        r = new Array(n),
2653        g = new Array(n),
2654        b = new Array(n),
2655        i, color;
2656    for (i = 0; i < n; ++i) {
2657      color = rgb(colors[i]);
2658      r[i] = color.r || 0;
2659      g[i] = color.g || 0;
2660      b[i] = color.b || 0;
2661    }
2662    r = spline(r);
2663    g = spline(g);
2664    b = spline(b);
2665    color.opacity = 1;
2666    return function(t) {
2667      color.r = r(t);
2668      color.g = g(t);
2669      color.b = b(t);
2670      return color + "";
2671    };
2672  };
2673}
2674
2675var rgbBasis = rgbSpline(basis$1);
2676var rgbBasisClosed = rgbSpline(basisClosed);
2677
2678function numberArray(a, b) {
2679  if (!b) b = [];
2680  var n = a ? Math.min(b.length, a.length) : 0,
2681      c = b.slice(),
2682      i;
2683  return function(t) {
2684    for (i = 0; i < n; ++i) c[i] = a[i] * (1 - t) + b[i] * t;
2685    return c;
2686  };
2687}
2688
2689function isNumberArray(x) {
2690  return ArrayBuffer.isView(x) && !(x instanceof DataView);
2691}
2692
2693function array$1(a, b) {
2694  return (isNumberArray(b) ? numberArray : genericArray)(a, b);
2695}
2696
2697function genericArray(a, b) {
2698  var nb = b ? b.length : 0,
2699      na = a ? Math.min(nb, a.length) : 0,
2700      x = new Array(na),
2701      c = new Array(nb),
2702      i;
2703
2704  for (i = 0; i < na; ++i) x[i] = interpolateValue(a[i], b[i]);
2705  for (; i < nb; ++i) c[i] = b[i];
2706
2707  return function(t) {
2708    for (i = 0; i < na; ++i) c[i] = x[i](t);
2709    return c;
2710  };
2711}
2712
2713function date(a, b) {
2714  var d = new Date;
2715  return a = +a, b = +b, function(t) {
2716    return d.setTime(a * (1 - t) + b * t), d;
2717  };
2718}
2719
2720function interpolateNumber(a, b) {
2721  return a = +a, b = +b, function(t) {
2722    return a * (1 - t) + b * t;
2723  };
2724}
2725
2726function object(a, b) {
2727  var i = {},
2728      c = {},
2729      k;
2730
2731  if (a === null || typeof a !== "object") a = {};
2732  if (b === null || typeof b !== "object") b = {};
2733
2734  for (k in b) {
2735    if (k in a) {
2736      i[k] = interpolateValue(a[k], b[k]);
2737    } else {
2738      c[k] = b[k];
2739    }
2740  }
2741
2742  return function(t) {
2743    for (k in i) c[k] = i[k](t);
2744    return c;
2745  };
2746}
2747
2748var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,
2749    reB = new RegExp(reA.source, "g");
2750
2751function zero(b) {
2752  return function() {
2753    return b;
2754  };
2755}
2756
2757function one(b) {
2758  return function(t) {
2759    return b(t) + "";
2760  };
2761}
2762
2763function interpolateString(a, b) {
2764  var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b
2765      am, // current match in a
2766      bm, // current match in b
2767      bs, // string preceding current number in b, if any
2768      i = -1, // index in s
2769      s = [], // string constants and placeholders
2770      q = []; // number interpolators
2771
2772  // Coerce inputs to strings.
2773  a = a + "", b = b + "";
2774
2775  // Interpolate pairs of numbers in a & b.
2776  while ((am = reA.exec(a))
2777      && (bm = reB.exec(b))) {
2778    if ((bs = bm.index) > bi) { // a string precedes the next number in b
2779      bs = b.slice(bi, bs);
2780      if (s[i]) s[i] += bs; // coalesce with previous string
2781      else s[++i] = bs;
2782    }
2783    if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match
2784      if (s[i]) s[i] += bm; // coalesce with previous string
2785      else s[++i] = bm;
2786    } else { // interpolate non-matching numbers
2787      s[++i] = null;
2788      q.push({i: i, x: interpolateNumber(am, bm)});
2789    }
2790    bi = reB.lastIndex;
2791  }
2792
2793  // Add remains of b.
2794  if (bi < b.length) {
2795    bs = b.slice(bi);
2796    if (s[i]) s[i] += bs; // coalesce with previous string
2797    else s[++i] = bs;
2798  }
2799
2800  // Special optimization for only a single match.
2801  // Otherwise, interpolate each of the numbers and rejoin the string.
2802  return s.length < 2 ? (q[0]
2803      ? one(q[0].x)
2804      : zero(b))
2805      : (b = q.length, function(t) {
2806          for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);
2807          return s.join("");
2808        });
2809}
2810
2811function interpolateValue(a, b) {
2812  var t = typeof b, c;
2813  return b == null || t === "boolean" ? constant$3(b)
2814      : (t === "number" ? interpolateNumber
2815      : t === "string" ? ((c = color(b)) ? (b = c, interpolateRgb) : interpolateString)
2816      : b instanceof color ? interpolateRgb
2817      : b instanceof Date ? date
2818      : isNumberArray(b) ? numberArray
2819      : Array.isArray(b) ? genericArray
2820      : typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? object
2821      : interpolateNumber)(a, b);
2822}
2823
2824function discrete(range) {
2825  var n = range.length;
2826  return function(t) {
2827    return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))];
2828  };
2829}
2830
2831function hue$1(a, b) {
2832  var i = hue(+a, +b);
2833  return function(t) {
2834    var x = i(t);
2835    return x - 360 * Math.floor(x / 360);
2836  };
2837}
2838
2839function interpolateRound(a, b) {
2840  return a = +a, b = +b, function(t) {
2841    return Math.round(a * (1 - t) + b * t);
2842  };
2843}
2844
2845var degrees = 180 / Math.PI;
2846
2847var identity$2 = {
2848  translateX: 0,
2849  translateY: 0,
2850  rotate: 0,
2851  skewX: 0,
2852  scaleX: 1,
2853  scaleY: 1
2854};
2855
2856function decompose(a, b, c, d, e, f) {
2857  var scaleX, scaleY, skewX;
2858  if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX;
2859  if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX;
2860  if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY;
2861  if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX;
2862  return {
2863    translateX: e,
2864    translateY: f,
2865    rotate: Math.atan2(b, a) * degrees,
2866    skewX: Math.atan(skewX) * degrees,
2867    scaleX: scaleX,
2868    scaleY: scaleY
2869  };
2870}
2871
2872var cssNode,
2873    cssRoot,
2874    cssView,
2875    svgNode;
2876
2877function parseCss(value) {
2878  if (value === "none") return identity$2;
2879  if (!cssNode) cssNode = document.createElement("DIV"), cssRoot = document.documentElement, cssView = document.defaultView;
2880  cssNode.style.transform = value;
2881  value = cssView.getComputedStyle(cssRoot.appendChild(cssNode), null).getPropertyValue("transform");
2882  cssRoot.removeChild(cssNode);
2883  value = value.slice(7, -1).split(",");
2884  return decompose(+value[0], +value[1], +value[2], +value[3], +value[4], +value[5]);
2885}
2886
2887function parseSvg(value) {
2888  if (value == null) return identity$2;
2889  if (!svgNode) svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g");
2890  svgNode.setAttribute("transform", value);
2891  if (!(value = svgNode.transform.baseVal.consolidate())) return identity$2;
2892  value = value.matrix;
2893  return decompose(value.a, value.b, value.c, value.d, value.e, value.f);
2894}
2895
2896function interpolateTransform(parse, pxComma, pxParen, degParen) {
2897
2898  function pop(s) {
2899    return s.length ? s.pop() + " " : "";
2900  }
2901
2902  function translate(xa, ya, xb, yb, s, q) {
2903    if (xa !== xb || ya !== yb) {
2904      var i = s.push("translate(", null, pxComma, null, pxParen);
2905      q.push({i: i - 4, x: interpolateNumber(xa, xb)}, {i: i - 2, x: interpolateNumber(ya, yb)});
2906    } else if (xb || yb) {
2907      s.push("translate(" + xb + pxComma + yb + pxParen);
2908    }
2909  }
2910
2911  function rotate(a, b, s, q) {
2912    if (a !== b) {
2913      if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path
2914      q.push({i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: interpolateNumber(a, b)});
2915    } else if (b) {
2916      s.push(pop(s) + "rotate(" + b + degParen);
2917    }
2918  }
2919
2920  function skewX(a, b, s, q) {
2921    if (a !== b) {
2922      q.push({i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: interpolateNumber(a, b)});
2923    } else if (b) {
2924      s.push(pop(s) + "skewX(" + b + degParen);
2925    }
2926  }
2927
2928  function scale(xa, ya, xb, yb, s, q) {
2929    if (xa !== xb || ya !== yb) {
2930      var i = s.push(pop(s) + "scale(", null, ",", null, ")");
2931      q.push({i: i - 4, x: interpolateNumber(xa, xb)}, {i: i - 2, x: interpolateNumber(ya, yb)});
2932    } else if (xb !== 1 || yb !== 1) {
2933      s.push(pop(s) + "scale(" + xb + "," + yb + ")");
2934    }
2935  }
2936
2937  return function(a, b) {
2938    var s = [], // string constants and placeholders
2939        q = []; // number interpolators
2940    a = parse(a), b = parse(b);
2941    translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q);
2942    rotate(a.rotate, b.rotate, s, q);
2943    skewX(a.skewX, b.skewX, s, q);
2944    scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q);
2945    a = b = null; // gc
2946    return function(t) {
2947      var i = -1, n = q.length, o;
2948      while (++i < n) s[(o = q[i]).i] = o.x(t);
2949      return s.join("");
2950    };
2951  };
2952}
2953
2954var interpolateTransformCss = interpolateTransform(parseCss, "px, ", "px)", "deg)");
2955var interpolateTransformSvg = interpolateTransform(parseSvg, ", ", ")", ")");
2956
2957var rho = Math.SQRT2,
2958    rho2 = 2,
2959    rho4 = 4,
2960    epsilon2 = 1e-12;
2961
2962function cosh(x) {
2963  return ((x = Math.exp(x)) + 1 / x) / 2;
2964}
2965
2966function sinh(x) {
2967  return ((x = Math.exp(x)) - 1 / x) / 2;
2968}
2969
2970function tanh(x) {
2971  return ((x = Math.exp(2 * x)) - 1) / (x + 1);
2972}
2973
2974// p0 = [ux0, uy0, w0]
2975// p1 = [ux1, uy1, w1]
2976function interpolateZoom(p0, p1) {
2977  var ux0 = p0[0], uy0 = p0[1], w0 = p0[2],
2978      ux1 = p1[0], uy1 = p1[1], w1 = p1[2],
2979      dx = ux1 - ux0,
2980      dy = uy1 - uy0,
2981      d2 = dx * dx + dy * dy,
2982      i,
2983      S;
2984
2985  // Special case for u0 ≅ u1.
2986  if (d2 < epsilon2) {
2987    S = Math.log(w1 / w0) / rho;
2988    i = function(t) {
2989      return [
2990        ux0 + t * dx,
2991        uy0 + t * dy,
2992        w0 * Math.exp(rho * t * S)
2993      ];
2994    };
2995  }
2996
2997  // General case.
2998  else {
2999    var d1 = Math.sqrt(d2),
3000        b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1),
3001        b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1),
3002        r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0),
3003        r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);
3004    S = (r1 - r0) / rho;
3005    i = function(t) {
3006      var s = t * S,
3007          coshr0 = cosh(r0),
3008          u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0));
3009      return [
3010        ux0 + u * dx,
3011        uy0 + u * dy,
3012        w0 * coshr0 / cosh(rho * s + r0)
3013      ];
3014    };
3015  }
3016
3017  i.duration = S * 1000;
3018
3019  return i;
3020}
3021
3022function hsl$1(hue) {
3023  return function(start, end) {
3024    var h = hue((start = hsl(start)).h, (end = hsl(end)).h),
3025        s = nogamma(start.s, end.s),
3026        l = nogamma(start.l, end.l),
3027        opacity = nogamma(start.opacity, end.opacity);
3028    return function(t) {
3029      start.h = h(t);
3030      start.s = s(t);
3031      start.l = l(t);
3032      start.opacity = opacity(t);
3033      return start + "";
3034    };
3035  }
3036}
3037
3038var hsl$2 = hsl$1(hue);
3039var hslLong = hsl$1(nogamma);
3040
3041function lab$1(start, end) {
3042  var l = nogamma((start = lab(start)).l, (end = lab(end)).l),
3043      a = nogamma(start.a, end.a),
3044      b = nogamma(start.b, end.b),
3045      opacity = nogamma(start.opacity, end.opacity);
3046  return function(t) {
3047    start.l = l(t);
3048    start.a = a(t);
3049    start.b = b(t);
3050    start.opacity = opacity(t);
3051    return start + "";
3052  };
3053}
3054
3055function hcl$1(hue) {
3056  return function(start, end) {
3057    var h = hue((start = hcl(start)).h, (end = hcl(end)).h),
3058        c = nogamma(start.c, end.c),
3059        l = nogamma(start.l, end.l),
3060        opacity = nogamma(start.opacity, end.opacity);
3061    return function(t) {
3062      start.h = h(t);
3063      start.c = c(t);
3064      start.l = l(t);
3065      start.opacity = opacity(t);
3066      return start + "";
3067    };
3068  }
3069}
3070
3071var hcl$2 = hcl$1(hue);
3072var hclLong = hcl$1(nogamma);
3073
3074function cubehelix$1(hue) {
3075  return (function cubehelixGamma(y) {
3076    y = +y;
3077
3078    function cubehelix$1(start, end) {
3079      var h = hue((start = cubehelix(start)).h, (end = cubehelix(end)).h),
3080          s = nogamma(start.s, end.s),
3081          l = nogamma(start.l, end.l),
3082          opacity = nogamma(start.opacity, end.opacity);
3083      return function(t) {
3084        start.h = h(t);
3085        start.s = s(t);
3086        start.l = l(Math.pow(t, y));
3087        start.opacity = opacity(t);
3088        return start + "";
3089      };
3090    }
3091
3092    cubehelix$1.gamma = cubehelixGamma;
3093
3094    return cubehelix$1;
3095  })(1);
3096}
3097
3098var cubehelix$2 = cubehelix$1(hue);
3099var cubehelixLong = cubehelix$1(nogamma);
3100
3101function piecewise(interpolate, values) {
3102  var i = 0, n = values.length - 1, v = values[0], I = new Array(n < 0 ? 0 : n);
3103  while (i < n) I[i] = interpolate(v, v = values[++i]);
3104  return function(t) {
3105    var i = Math.max(0, Math.min(n - 1, Math.floor(t *= n)));
3106    return I[i](t - i);
3107  };
3108}
3109
3110function quantize(interpolator, n) {
3111  var samples = new Array(n);
3112  for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1));
3113  return samples;
3114}
3115
3116var frame = 0, // is an animation frame pending?
3117    timeout = 0, // is a timeout pending?
3118    interval = 0, // are any timers active?
3119    pokeDelay = 1000, // how frequently we check for clock skew
3120    taskHead,
3121    taskTail,
3122    clockLast = 0,
3123    clockNow = 0,
3124    clockSkew = 0,
3125    clock = typeof performance === "object" && performance.now ? performance : Date,
3126    setFrame = typeof window === "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f) { setTimeout(f, 17); };
3127
3128function now() {
3129  return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);
3130}
3131
3132function clearNow() {
3133  clockNow = 0;
3134}
3135
3136function Timer() {
3137  this._call =
3138  this._time =
3139  this._next = null;
3140}
3141
3142Timer.prototype = timer.prototype = {
3143  constructor: Timer,
3144  restart: function(callback, delay, time) {
3145    if (typeof callback !== "function") throw new TypeError("callback is not a function");
3146    time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);
3147    if (!this._next && taskTail !== this) {
3148      if (taskTail) taskTail._next = this;
3149      else taskHead = this;
3150      taskTail = this;
3151    }
3152    this._call = callback;
3153    this._time = time;
3154    sleep();
3155  },
3156  stop: function() {
3157    if (this._call) {
3158      this._call = null;
3159      this._time = Infinity;
3160      sleep();
3161    }
3162  }
3163};
3164
3165function timer(callback, delay, time) {
3166  var t = new Timer;
3167  t.restart(callback, delay, time);
3168  return t;
3169}
3170
3171function timerFlush() {
3172  now(); // Get the current time, if not already set.
3173  ++frame; // Pretend we’ve set an alarm, if we haven’t already.
3174  var t = taskHead, e;
3175  while (t) {
3176    if ((e = clockNow - t._time) >= 0) t._call.call(null, e);
3177    t = t._next;
3178  }
3179  --frame;
3180}
3181
3182function wake() {
3183  clockNow = (clockLast = clock.now()) + clockSkew;
3184  frame = timeout = 0;
3185  try {
3186    timerFlush();
3187  } finally {
3188    frame = 0;
3189    nap();
3190    clockNow = 0;
3191  }
3192}
3193
3194function poke() {
3195  var now = clock.now(), delay = now - clockLast;
3196  if (delay > pokeDelay) clockSkew -= delay, clockLast = now;
3197}
3198
3199function nap() {
3200  var t0, t1 = taskHead, t2, time = Infinity;
3201  while (t1) {
3202    if (t1._call) {
3203      if (time > t1._time) time = t1._time;
3204      t0 = t1, t1 = t1._next;
3205    } else {
3206      t2 = t1._next, t1._next = null;
3207      t1 = t0 ? t0._next = t2 : taskHead = t2;
3208    }
3209  }
3210  taskTail = t0;
3211  sleep(time);
3212}
3213
3214function sleep(time) {
3215  if (frame) return; // Soonest alarm already set, or will be.
3216  if (timeout) timeout = clearTimeout(timeout);
3217  var delay = time - clockNow; // Strictly less than if we recomputed clockNow.
3218  if (delay > 24) {
3219    if (time < Infinity) timeout = setTimeout(wake, time - clock.now() - clockSkew);
3220    if (interval) interval = clearInterval(interval);
3221  } else {
3222    if (!interval) clockLast = clock.now(), interval = setInterval(poke, pokeDelay);
3223    frame = 1, setFrame(wake);
3224  }
3225}
3226
3227function timeout$1(callback, delay, time) {
3228  var t = new Timer;
3229  delay = delay == null ? 0 : +delay;
3230  t.restart(function(elapsed) {
3231    t.stop();
3232    callback(elapsed + delay);
3233  }, delay, time);
3234  return t;
3235}
3236
3237function interval$1(callback, delay, time) {
3238  var t = new Timer, total = delay;
3239  if (delay == null) return t.restart(callback, delay, time), t;
3240  delay = +delay, time = time == null ? now() : +time;
3241  t.restart(function tick(elapsed) {
3242    elapsed += total;
3243    t.restart(tick, total += delay, time);
3244    callback(elapsed);
3245  }, delay, time);
3246  return t;
3247}
3248
3249var emptyOn = dispatch("start", "end", "cancel", "interrupt");
3250var emptyTween = [];
3251
3252var CREATED = 0;
3253var SCHEDULED = 1;
3254var STARTING = 2;
3255var STARTED = 3;
3256var RUNNING = 4;
3257var ENDING = 5;
3258var ENDED = 6;
3259
3260function schedule(node, name, id, index, group, timing) {
3261  var schedules = node.__transition;
3262  if (!schedules) node.__transition = {};
3263  else if (id in schedules) return;
3264  create$1(node, id, {
3265    name: name,
3266    index: index, // For context during callback.
3267    group: group, // For context during callback.
3268    on: emptyOn,
3269    tween: emptyTween,
3270    time: timing.time,
3271    delay: timing.delay,
3272    duration: timing.duration,
3273    ease: timing.ease,
3274    timer: null,
3275    state: CREATED
3276  });
3277}
3278
3279function init(node, id) {
3280  var schedule = get$1(node, id);
3281  if (schedule.state > CREATED) throw new Error("too late; already scheduled");
3282  return schedule;
3283}
3284
3285function set$1(node, id) {
3286  var schedule = get$1(node, id);
3287  if (schedule.state > STARTED) throw new Error("too late; already running");
3288  return schedule;
3289}
3290
3291function get$1(node, id) {
3292  var schedule = node.__transition;
3293  if (!schedule || !(schedule = schedule[id])) throw new Error("transition not found");
3294  return schedule;
3295}
3296
3297function create$1(node, id, self) {
3298  var schedules = node.__transition,
3299      tween;
3300
3301  // Initialize the self timer when the transition is created.
3302  // Note the actual delay is not known until the first callback!
3303  schedules[id] = self;
3304  self.timer = timer(schedule, 0, self.time);
3305
3306  function schedule(elapsed) {
3307    self.state = SCHEDULED;
3308    self.timer.restart(start, self.delay, self.time);
3309
3310    // If the elapsed delay is less than our first sleep, start immediately.
3311    if (self.delay <= elapsed) start(elapsed - self.delay);
3312  }
3313
3314  function start(elapsed) {
3315    var i, j, n, o;
3316
3317    // If the state is not SCHEDULED, then we previously errored on start.
3318    if (self.state !== SCHEDULED) return stop();
3319
3320    for (i in schedules) {
3321      o = schedules[i];
3322      if (o.name !== self.name) continue;
3323
3324      // While this element already has a starting transition during this frame,
3325      // defer starting an interrupting transition until that transition has a
3326      // chance to tick (and possibly end); see d3/d3-transition#54!
3327      if (o.state === STARTED) return timeout$1(start);
3328
3329      // Interrupt the active transition, if any.
3330      if (o.state === RUNNING) {
3331        o.state = ENDED;
3332        o.timer.stop();
3333        o.on.call("interrupt", node, node.__data__, o.index, o.group);
3334        delete schedules[i];
3335      }
3336
3337      // Cancel any pre-empted transitions.
3338      else if (+i < id) {
3339        o.state = ENDED;
3340        o.timer.stop();
3341        o.on.call("cancel", node, node.__data__, o.index, o.group);
3342        delete schedules[i];
3343      }
3344    }
3345
3346    // Defer the first tick to end of the current frame; see d3/d3#1576.
3347    // Note the transition may be canceled after start and before the first tick!
3348    // Note this must be scheduled before the start event; see d3/d3-transition#16!
3349    // Assuming this is successful, subsequent callbacks go straight to tick.
3350    timeout$1(function() {
3351      if (self.state === STARTED) {
3352        self.state = RUNNING;
3353        self.timer.restart(tick, self.delay, self.time);
3354        tick(elapsed);
3355      }
3356    });
3357
3358    // Dispatch the start event.
3359    // Note this must be done before the tween are initialized.
3360    self.state = STARTING;
3361    self.on.call("start", node, node.__data__, self.index, self.group);
3362    if (self.state !== STARTING) return; // interrupted
3363    self.state = STARTED;
3364
3365    // Initialize the tween, deleting null tween.
3366    tween = new Array(n = self.tween.length);
3367    for (i = 0, j = -1; i < n; ++i) {
3368      if (o = self.tween[i].value.call(node, node.__data__, self.index, self.group)) {
3369        tween[++j] = o;
3370      }
3371    }
3372    tween.length = j + 1;
3373  }
3374
3375  function tick(elapsed) {
3376    var t = elapsed < self.duration ? self.ease.call(null, elapsed / self.duration) : (self.timer.restart(stop), self.state = ENDING, 1),
3377        i = -1,
3378        n = tween.length;
3379
3380    while (++i < n) {
3381      tween[i].call(node, t);
3382    }
3383
3384    // Dispatch the end event.
3385    if (self.state === ENDING) {
3386      self.on.call("end", node, node.__data__, self.index, self.group);
3387      stop();
3388    }
3389  }
3390
3391  function stop() {
3392    self.state = ENDED;
3393    self.timer.stop();
3394    delete schedules[id];
3395    for (var i in schedules) return; // eslint-disable-line no-unused-vars
3396    delete node.__transition;
3397  }
3398}
3399
3400function interrupt(node, name) {
3401  var schedules = node.__transition,
3402      schedule,
3403      active,
3404      empty = true,
3405      i;
3406
3407  if (!schedules) return;
3408
3409  name = name == null ? null : name + "";
3410
3411  for (i in schedules) {
3412    if ((schedule = schedules[i]).name !== name) { empty = false; continue; }
3413    active = schedule.state > STARTING && schedule.state < ENDING;
3414    schedule.state = ENDED;
3415    schedule.timer.stop();
3416    schedule.on.call(active ? "interrupt" : "cancel", node, node.__data__, schedule.index, schedule.group);
3417    delete schedules[i];
3418  }
3419
3420  if (empty) delete node.__transition;
3421}
3422
3423function selection_interrupt(name) {
3424  return this.each(function() {
3425    interrupt(this, name);
3426  });
3427}
3428
3429function tweenRemove(id, name) {
3430  var tween0, tween1;
3431  return function() {
3432    var schedule = set$1(this, id),
3433        tween = schedule.tween;
3434
3435    // If this node shared tween with the previous node,
3436    // just assign the updated shared tween and we’re done!
3437    // Otherwise, copy-on-write.
3438    if (tween !== tween0) {
3439      tween1 = tween0 = tween;
3440      for (var i = 0, n = tween1.length; i < n; ++i) {
3441        if (tween1[i].name === name) {
3442          tween1 = tween1.slice();
3443          tween1.splice(i, 1);
3444          break;
3445        }
3446      }
3447    }
3448
3449    schedule.tween = tween1;
3450  };
3451}
3452
3453function tweenFunction(id, name, value) {
3454  var tween0, tween1;
3455  if (typeof value !== "function") throw new Error;
3456  return function() {
3457    var schedule = set$1(this, id),
3458        tween = schedule.tween;
3459
3460    // If this node shared tween with the previous node,
3461    // just assign the updated shared tween and we’re done!
3462    // Otherwise, copy-on-write.
3463    if (tween !== tween0) {
3464      tween1 = (tween0 = tween).slice();
3465      for (var t = {name: name, value: value}, i = 0, n = tween1.length; i < n; ++i) {
3466        if (tween1[i].name === name) {
3467          tween1[i] = t;
3468          break;
3469        }
3470      }
3471      if (i === n) tween1.push(t);
3472    }
3473
3474    schedule.tween = tween1;
3475  };
3476}
3477
3478function transition_tween(name, value) {
3479  var id = this._id;
3480
3481  name += "";
3482
3483  if (arguments.length < 2) {
3484    var tween = get$1(this.node(), id).tween;
3485    for (var i = 0, n = tween.length, t; i < n; ++i) {
3486      if ((t = tween[i]).name === name) {
3487        return t.value;
3488      }
3489    }
3490    return null;
3491  }
3492
3493  return this.each((value == null ? tweenRemove : tweenFunction)(id, name, value));
3494}
3495
3496function tweenValue(transition, name, value) {
3497  var id = transition._id;
3498
3499  transition.each(function() {
3500    var schedule = set$1(this, id);
3501    (schedule.value || (schedule.value = {}))[name] = value.apply(this, arguments);
3502  });
3503
3504  return function(node) {
3505    return get$1(node, id).value[name];
3506  };
3507}
3508
3509function interpolate(a, b) {
3510  var c;
3511  return (typeof b === "number" ? interpolateNumber
3512      : b instanceof color ? interpolateRgb
3513      : (c = color(b)) ? (b = c, interpolateRgb)
3514      : interpolateString)(a, b);
3515}
3516
3517function attrRemove$1(name) {
3518  return function() {
3519    this.removeAttribute(name);
3520  };
3521}
3522
3523function attrRemoveNS$1(fullname) {
3524  return function() {
3525    this.removeAttributeNS(fullname.space, fullname.local);
3526  };
3527}
3528
3529function attrConstant$1(name, interpolate, value1) {
3530  var string00,
3531      string1 = value1 + "",
3532      interpolate0;
3533  return function() {
3534    var string0 = this.getAttribute(name);
3535    return string0 === string1 ? null
3536        : string0 === string00 ? interpolate0
3537        : interpolate0 = interpolate(string00 = string0, value1);
3538  };
3539}
3540
3541function attrConstantNS$1(fullname, interpolate, value1) {
3542  var string00,
3543      string1 = value1 + "",
3544      interpolate0;
3545  return function() {
3546    var string0 = this.getAttributeNS(fullname.space, fullname.local);
3547    return string0 === string1 ? null
3548        : string0 === string00 ? interpolate0
3549        : interpolate0 = interpolate(string00 = string0, value1);
3550  };
3551}
3552
3553function attrFunction$1(name, interpolate, value) {
3554  var string00,
3555      string10,
3556      interpolate0;
3557  return function() {
3558    var string0, value1 = value(this), string1;
3559    if (value1 == null) return void this.removeAttribute(name);
3560    string0 = this.getAttribute(name);
3561    string1 = value1 + "";
3562    return string0 === string1 ? null
3563        : string0 === string00 && string1 === string10 ? interpolate0
3564        : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1));
3565  };
3566}
3567
3568function attrFunctionNS$1(fullname, interpolate, value) {
3569  var string00,
3570      string10,
3571      interpolate0;
3572  return function() {
3573    var string0, value1 = value(this), string1;
3574    if (value1 == null) return void this.removeAttributeNS(fullname.space, fullname.local);
3575    string0 = this.getAttributeNS(fullname.space, fullname.local);
3576    string1 = value1 + "";
3577    return string0 === string1 ? null
3578        : string0 === string00 && string1 === string10 ? interpolate0
3579        : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1));
3580  };
3581}
3582
3583function transition_attr(name, value) {
3584  var fullname = namespace(name), i = fullname === "transform" ? interpolateTransformSvg : interpolate;
3585  return this.attrTween(name, typeof value === "function"
3586      ? (fullname.local ? attrFunctionNS$1 : attrFunction$1)(fullname, i, tweenValue(this, "attr." + name, value))
3587      : value == null ? (fullname.local ? attrRemoveNS$1 : attrRemove$1)(fullname)
3588      : (fullname.local ? attrConstantNS$1 : attrConstant$1)(fullname, i, value));
3589}
3590
3591function attrInterpolate(name, i) {
3592  return function(t) {
3593    this.setAttribute(name, i.call(this, t));
3594  };
3595}
3596
3597function attrInterpolateNS(fullname, i) {
3598  return function(t) {
3599    this.setAttributeNS(fullname.space, fullname.local, i.call(this, t));
3600  };
3601}
3602
3603function attrTweenNS(fullname, value) {
3604  var t0, i0;
3605  function tween() {
3606    var i = value.apply(this, arguments);
3607    if (i !== i0) t0 = (i0 = i) && attrInterpolateNS(fullname, i);
3608    return t0;
3609  }
3610  tween._value = value;
3611  return tween;
3612}
3613
3614function attrTween(name, value) {
3615  var t0, i0;
3616  function tween() {
3617    var i = value.apply(this, arguments);
3618    if (i !== i0) t0 = (i0 = i) && attrInterpolate(name, i);
3619    return t0;
3620  }
3621  tween._value = value;
3622  return tween;
3623}
3624
3625function transition_attrTween(name, value) {
3626  var key = "attr." + name;
3627  if (arguments.length < 2) return (key = this.tween(key)) && key._value;
3628  if (value == null) return this.tween(key, null);
3629  if (typeof value !== "function") throw new Error;
3630  var fullname = namespace(name);
3631  return this.tween(key, (fullname.local ? attrTweenNS : attrTween)(fullname, value));
3632}
3633
3634function delayFunction(id, value) {
3635  return function() {
3636    init(this, id).delay = +value.apply(this, arguments);
3637  };
3638}
3639
3640function delayConstant(id, value) {
3641  return value = +value, function() {
3642    init(this, id).delay = value;
3643  };
3644}
3645
3646function transition_delay(value) {
3647  var id = this._id;
3648
3649  return arguments.length
3650      ? this.each((typeof value === "function"
3651          ? delayFunction
3652          : delayConstant)(id, value))
3653      : get$1(this.node(), id).delay;
3654}
3655
3656function durationFunction(id, value) {
3657  return function() {
3658    set$1(this, id).duration = +value.apply(this, arguments);
3659  };
3660}
3661
3662function durationConstant(id, value) {
3663  return value = +value, function() {
3664    set$1(this, id).duration = value;
3665  };
3666}
3667
3668function transition_duration(value) {
3669  var id = this._id;
3670
3671  return arguments.length
3672      ? this.each((typeof value === "function"
3673          ? durationFunction
3674          : durationConstant)(id, value))
3675      : get$1(this.node(), id).duration;
3676}
3677
3678function easeConstant(id, value) {
3679  if (typeof value !== "function") throw new Error;
3680  return function() {
3681    set$1(this, id).ease = value;
3682  };
3683}
3684
3685function transition_ease(value) {
3686  var id = this._id;
3687
3688  return arguments.length
3689      ? this.each(easeConstant(id, value))
3690      : get$1(this.node(), id).ease;
3691}
3692
3693function transition_filter(match) {
3694  if (typeof match !== "function") match = matcher(match);
3695
3696  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
3697    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {
3698      if ((node = group[i]) && match.call(node, node.__data__, i, group)) {
3699        subgroup.push(node);
3700      }
3701    }
3702  }
3703
3704  return new Transition(subgroups, this._parents, this._name, this._id);
3705}
3706
3707function transition_merge(transition) {
3708  if (transition._id !== this._id) throw new Error;
3709
3710  for (var groups0 = this._groups, groups1 = transition._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {
3711    for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {
3712      if (node = group0[i] || group1[i]) {
3713        merge[i] = node;
3714      }
3715    }
3716  }
3717
3718  for (; j < m0; ++j) {
3719    merges[j] = groups0[j];
3720  }
3721
3722  return new Transition(merges, this._parents, this._name, this._id);
3723}
3724
3725function start(name) {
3726  return (name + "").trim().split(/^|\s+/).every(function(t) {
3727    var i = t.indexOf(".");
3728    if (i >= 0) t = t.slice(0, i);
3729    return !t || t === "start";
3730  });
3731}
3732
3733function onFunction(id, name, listener) {
3734  var on0, on1, sit = start(name) ? init : set$1;
3735  return function() {
3736    var schedule = sit(this, id),
3737        on = schedule.on;
3738
3739    // If this node shared a dispatch with the previous node,
3740    // just assign the updated shared dispatch and we’re done!
3741    // Otherwise, copy-on-write.
3742    if (on !== on0) (on1 = (on0 = on).copy()).on(name, listener);
3743
3744    schedule.on = on1;
3745  };
3746}
3747
3748function transition_on(name, listener) {
3749  var id = this._id;
3750
3751  return arguments.length < 2
3752      ? get$1(this.node(), id).on.on(name)
3753      : this.each(onFunction(id, name, listener));
3754}
3755
3756function removeFunction(id) {
3757  return function() {
3758    var parent = this.parentNode;
3759    for (var i in this.__transition) if (+i !== id) return;
3760    if (parent) parent.removeChild(this);
3761  };
3762}
3763
3764function transition_remove() {
3765  return this.on("end.remove", removeFunction(this._id));
3766}
3767
3768function transition_select(select) {
3769  var name = this._name,
3770      id = this._id;
3771
3772  if (typeof select !== "function") select = selector(select);
3773
3774  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
3775    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {
3776      if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {
3777        if ("__data__" in node) subnode.__data__ = node.__data__;
3778        subgroup[i] = subnode;
3779        schedule(subgroup[i], name, id, i, subgroup, get$1(node, id));
3780      }
3781    }
3782  }
3783
3784  return new Transition(subgroups, this._parents, name, id);
3785}
3786
3787function transition_selectAll(select) {
3788  var name = this._name,
3789      id = this._id;
3790
3791  if (typeof select !== "function") select = selectorAll(select);
3792
3793  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {
3794    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
3795      if (node = group[i]) {
3796        for (var children = select.call(node, node.__data__, i, group), child, inherit = get$1(node, id), k = 0, l = children.length; k < l; ++k) {
3797          if (child = children[k]) {
3798            schedule(child, name, id, k, children, inherit);
3799          }
3800        }
3801        subgroups.push(children);
3802        parents.push(node);
3803      }
3804    }
3805  }
3806
3807  return new Transition(subgroups, parents, name, id);
3808}
3809
3810var Selection$1 = selection.prototype.constructor;
3811
3812function transition_selection() {
3813  return new Selection$1(this._groups, this._parents);
3814}
3815
3816function styleNull(name, interpolate) {
3817  var string00,
3818      string10,
3819      interpolate0;
3820  return function() {
3821    var string0 = styleValue(this, name),
3822        string1 = (this.style.removeProperty(name), styleValue(this, name));
3823    return string0 === string1 ? null
3824        : string0 === string00 && string1 === string10 ? interpolate0
3825        : interpolate0 = interpolate(string00 = string0, string10 = string1);
3826  };
3827}
3828
3829function styleRemove$1(name) {
3830  return function() {
3831    this.style.removeProperty(name);
3832  };
3833}
3834
3835function styleConstant$1(name, interpolate, value1) {
3836  var string00,
3837      string1 = value1 + "",
3838      interpolate0;
3839  return function() {
3840    var string0 = styleValue(this, name);
3841    return string0 === string1 ? null
3842        : string0 === string00 ? interpolate0
3843        : interpolate0 = interpolate(string00 = string0, value1);
3844  };
3845}
3846
3847function styleFunction$1(name, interpolate, value) {
3848  var string00,
3849      string10,
3850      interpolate0;
3851  return function() {
3852    var string0 = styleValue(this, name),
3853        value1 = value(this),
3854        string1 = value1 + "";
3855    if (value1 == null) string1 = value1 = (this.style.removeProperty(name), styleValue(this, name));
3856    return string0 === string1 ? null
3857        : string0 === string00 && string1 === string10 ? interpolate0
3858        : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1));
3859  };
3860}
3861
3862function styleMaybeRemove(id, name) {
3863  var on0, on1, listener0, key = "style." + name, event = "end." + key, remove;
3864  return function() {
3865    var schedule = set$1(this, id),
3866        on = schedule.on,
3867        listener = schedule.value[key] == null ? remove || (remove = styleRemove$1(name)) : undefined;
3868
3869    // If this node shared a dispatch with the previous node,
3870    // just assign the updated shared dispatch and we’re done!
3871    // Otherwise, copy-on-write.
3872    if (on !== on0 || listener0 !== listener) (on1 = (on0 = on).copy()).on(event, listener0 = listener);
3873
3874    schedule.on = on1;
3875  };
3876}
3877
3878function transition_style(name, value, priority) {
3879  var i = (name += "") === "transform" ? interpolateTransformCss : interpolate;
3880  return value == null ? this
3881      .styleTween(name, styleNull(name, i))
3882      .on("end.style." + name, styleRemove$1(name))
3883    : typeof value === "function" ? this
3884      .styleTween(name, styleFunction$1(name, i, tweenValue(this, "style." + name, value)))
3885      .each(styleMaybeRemove(this._id, name))
3886    : this
3887      .styleTween(name, styleConstant$1(name, i, value), priority)
3888      .on("end.style." + name, null);
3889}
3890
3891function styleInterpolate(name, i, priority) {
3892  return function(t) {
3893    this.style.setProperty(name, i.call(this, t), priority);
3894  };
3895}
3896
3897function styleTween(name, value, priority) {
3898  var t, i0;
3899  function tween() {
3900    var i = value.apply(this, arguments);
3901    if (i !== i0) t = (i0 = i) && styleInterpolate(name, i, priority);
3902    return t;
3903  }
3904  tween._value = value;
3905  return tween;
3906}
3907
3908function transition_styleTween(name, value, priority) {
3909  var key = "style." + (name += "");
3910  if (arguments.length < 2) return (key = this.tween(key)) && key._value;
3911  if (value == null) return this.tween(key, null);
3912  if (typeof value !== "function") throw new Error;
3913  return this.tween(key, styleTween(name, value, priority == null ? "" : priority));
3914}
3915
3916function textConstant$1(value) {
3917  return function() {
3918    this.textContent = value;
3919  };
3920}
3921
3922function textFunction$1(value) {
3923  return function() {
3924    var value1 = value(this);
3925    this.textContent = value1 == null ? "" : value1;
3926  };
3927}
3928
3929function transition_text(value) {
3930  return this.tween("text", typeof value === "function"
3931      ? textFunction$1(tweenValue(this, "text", value))
3932      : textConstant$1(value == null ? "" : value + ""));
3933}
3934
3935function textInterpolate(i) {
3936  return function(t) {
3937    this.textContent = i.call(this, t);
3938  };
3939}
3940
3941function textTween(value) {
3942  var t0, i0;
3943  function tween() {
3944    var i = value.apply(this, arguments);
3945    if (i !== i0) t0 = (i0 = i) && textInterpolate(i);
3946    return t0;
3947  }
3948  tween._value = value;
3949  return tween;
3950}
3951
3952function transition_textTween(value) {
3953  var key = "text";
3954  if (arguments.length < 1) return (key = this.tween(key)) && key._value;
3955  if (value == null) return this.tween(key, null);
3956  if (typeof value !== "function") throw new Error;
3957  return this.tween(key, textTween(value));
3958}
3959
3960function transition_transition() {
3961  var name = this._name,
3962      id0 = this._id,
3963      id1 = newId();
3964
3965  for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {
3966    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
3967      if (node = group[i]) {
3968        var inherit = get$1(node, id0);
3969        schedule(node, name, id1, i, group, {
3970          time: inherit.time + inherit.delay + inherit.duration,
3971          delay: 0,
3972          duration: inherit.duration,
3973          ease: inherit.ease
3974        });
3975      }
3976    }
3977  }
3978
3979  return new Transition(groups, this._parents, name, id1);
3980}
3981
3982function transition_end() {
3983  var on0, on1, that = this, id = that._id, size = that.size();
3984  return new Promise(function(resolve, reject) {
3985    var cancel = {value: reject},
3986        end = {value: function() { if (--size === 0) resolve(); }};
3987
3988    that.each(function() {
3989      var schedule = set$1(this, id),
3990          on = schedule.on;
3991
3992      // If this node shared a dispatch with the previous node,
3993      // just assign the updated shared dispatch and we’re done!
3994      // Otherwise, copy-on-write.
3995      if (on !== on0) {
3996        on1 = (on0 = on).copy();
3997        on1._.cancel.push(cancel);
3998        on1._.interrupt.push(cancel);
3999        on1._.end.push(end);
4000      }
4001
4002      schedule.on = on1;
4003    });
4004  });
4005}
4006
4007var id = 0;
4008
4009function Transition(groups, parents, name, id) {
4010  this._groups = groups;
4011  this._parents = parents;
4012  this._name = name;
4013  this._id = id;
4014}
4015
4016function transition(name) {
4017  return selection().transition(name);
4018}
4019
4020function newId() {
4021  return ++id;
4022}
4023
4024var selection_prototype = selection.prototype;
4025
4026Transition.prototype = transition.prototype = {
4027  constructor: Transition,
4028  select: transition_select,
4029  selectAll: transition_selectAll,
4030  filter: transition_filter,
4031  merge: transition_merge,
4032  selection: transition_selection,
4033  transition: transition_transition,
4034  call: selection_prototype.call,
4035  nodes: selection_prototype.nodes,
4036  node: selection_prototype.node,
4037  size: selection_prototype.size,
4038  empty: selection_prototype.empty,
4039  each: selection_prototype.each,
4040  on: transition_on,
4041  attr: transition_attr,
4042  attrTween: transition_attrTween,
4043  style: transition_style,
4044  styleTween: transition_styleTween,
4045  text: transition_text,
4046  textTween: transition_textTween,
4047  remove: transition_remove,
4048  tween: transition_tween,
4049  delay: transition_delay,
4050  duration: transition_duration,
4051  ease: transition_ease,
4052  end: transition_end
4053};
4054
4055function linear$1(t) {
4056  return +t;
4057}
4058
4059function quadIn(t) {
4060  return t * t;
4061}
4062
4063function quadOut(t) {
4064  return t * (2 - t);
4065}
4066
4067function quadInOut(t) {
4068  return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2;
4069}
4070
4071function cubicIn(t) {
4072  return t * t * t;
4073}
4074
4075function cubicOut(t) {
4076  return --t * t * t + 1;
4077}
4078
4079function cubicInOut(t) {
4080  return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2;
4081}
4082
4083var exponent = 3;
4084
4085var polyIn = (function custom(e) {
4086  e = +e;
4087
4088  function polyIn(t) {
4089    return Math.pow(t, e);
4090  }
4091
4092  polyIn.exponent = custom;
4093
4094  return polyIn;
4095})(exponent);
4096
4097var polyOut = (function custom(e) {
4098  e = +e;
4099
4100  function polyOut(t) {
4101    return 1 - Math.pow(1 - t, e);
4102  }
4103
4104  polyOut.exponent = custom;
4105
4106  return polyOut;
4107})(exponent);
4108
4109var polyInOut = (function custom(e) {
4110  e = +e;
4111
4112  function polyInOut(t) {
4113    return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2;
4114  }
4115
4116  polyInOut.exponent = custom;
4117
4118  return polyInOut;
4119})(exponent);
4120
4121var pi = Math.PI,
4122    halfPi = pi / 2;
4123
4124function sinIn(t) {
4125  return 1 - Math.cos(t * halfPi);
4126}
4127
4128function sinOut(t) {
4129  return Math.sin(t * halfPi);
4130}
4131
4132function sinInOut(t) {
4133  return (1 - Math.cos(pi * t)) / 2;
4134}
4135
4136function expIn(t) {
4137  return Math.pow(2, 10 * t - 10);
4138}
4139
4140function expOut(t) {
4141  return 1 - Math.pow(2, -10 * t);
4142}
4143
4144function expInOut(t) {
4145  return ((t *= 2) <= 1 ? Math.pow(2, 10 * t - 10) : 2 - Math.pow(2, 10 - 10 * t)) / 2;
4146}
4147
4148function circleIn(t) {
4149  return 1 - Math.sqrt(1 - t * t);
4150}
4151
4152function circleOut(t) {
4153  return Math.sqrt(1 - --t * t);
4154}
4155
4156function circleInOut(t) {
4157  return ((t *= 2) <= 1 ? 1 - Math.sqrt(1 - t * t) : Math.sqrt(1 - (t -= 2) * t) + 1) / 2;
4158}
4159
4160var b1 = 4 / 11,
4161    b2 = 6 / 11,
4162    b3 = 8 / 11,
4163    b4 = 3 / 4,
4164    b5 = 9 / 11,
4165    b6 = 10 / 11,
4166    b7 = 15 / 16,
4167    b8 = 21 / 22,
4168    b9 = 63 / 64,
4169    b0 = 1 / b1 / b1;
4170
4171function bounceIn(t) {
4172  return 1 - bounceOut(1 - t);
4173}
4174
4175function bounceOut(t) {
4176  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;
4177}
4178
4179function bounceInOut(t) {
4180  return ((t *= 2) <= 1 ? 1 - bounceOut(1 - t) : bounceOut(t - 1) + 1) / 2;
4181}
4182
4183var overshoot = 1.70158;
4184
4185var backIn = (function custom(s) {
4186  s = +s;
4187
4188  function backIn(t) {
4189    return t * t * ((s + 1) * t - s);
4190  }
4191
4192  backIn.overshoot = custom;
4193
4194  return backIn;
4195})(overshoot);
4196
4197var backOut = (function custom(s) {
4198  s = +s;
4199
4200  function backOut(t) {
4201    return --t * t * ((s + 1) * t + s) + 1;
4202  }
4203
4204  backOut.overshoot = custom;
4205
4206  return backOut;
4207})(overshoot);
4208
4209var backInOut = (function custom(s) {
4210  s = +s;
4211
4212  function backInOut(t) {
4213    return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2;
4214  }
4215
4216  backInOut.overshoot = custom;
4217
4218  return backInOut;
4219})(overshoot);
4220
4221var tau = 2 * Math.PI,
4222    amplitude = 1,
4223    period = 0.3;
4224
4225var elasticIn = (function custom(a, p) {
4226  var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);
4227
4228  function elasticIn(t) {
4229    return a * Math.pow(2, 10 * --t) * Math.sin((s - t) / p);
4230  }
4231
4232  elasticIn.amplitude = function(a) { return custom(a, p * tau); };
4233  elasticIn.period = function(p) { return custom(a, p); };
4234
4235  return elasticIn;
4236})(amplitude, period);
4237
4238var elasticOut = (function custom(a, p) {
4239  var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);
4240
4241  function elasticOut(t) {
4242    return 1 - a * Math.pow(2, -10 * (t = +t)) * Math.sin((t + s) / p);
4243  }
4244
4245  elasticOut.amplitude = function(a) { return custom(a, p * tau); };
4246  elasticOut.period = function(p) { return custom(a, p); };
4247
4248  return elasticOut;
4249})(amplitude, period);
4250
4251var elasticInOut = (function custom(a, p) {
4252  var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);
4253
4254  function elasticInOut(t) {
4255    return ((t = t * 2 - 1) < 0
4256        ? a * Math.pow(2, 10 * t) * Math.sin((s - t) / p)
4257        : 2 - a * Math.pow(2, -10 * t) * Math.sin((s + t) / p)) / 2;
4258  }
4259
4260  elasticInOut.amplitude = function(a) { return custom(a, p * tau); };
4261  elasticInOut.period = function(p) { return custom(a, p); };
4262
4263  return elasticInOut;
4264})(amplitude, period);
4265
4266var defaultTiming = {
4267  time: null, // Set on use.
4268  delay: 0,
4269  duration: 250,
4270  ease: cubicInOut
4271};
4272
4273function inherit(node, id) {
4274  var timing;
4275  while (!(timing = node.__transition) || !(timing = timing[id])) {
4276    if (!(node = node.parentNode)) {
4277      return defaultTiming.time = now(), defaultTiming;
4278    }
4279  }
4280  return timing;
4281}
4282
4283function selection_transition(name) {
4284  var id,
4285      timing;
4286
4287  if (name instanceof Transition) {
4288    id = name._id, name = name._name;
4289  } else {
4290    id = newId(), (timing = defaultTiming).time = now(), name = name == null ? null : name + "";
4291  }
4292
4293  for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {
4294    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
4295      if (node = group[i]) {
4296        schedule(node, name, id, i, group, timing || inherit(node, id));
4297      }
4298    }
4299  }
4300
4301  return new Transition(groups, this._parents, name, id);
4302}
4303
4304selection.prototype.interrupt = selection_interrupt;
4305selection.prototype.transition = selection_transition;
4306
4307var root$1 = [null];
4308
4309function active(node, name) {
4310  var schedules = node.__transition,
4311      schedule,
4312      i;
4313
4314  if (schedules) {
4315    name = name == null ? null : name + "";
4316    for (i in schedules) {
4317      if ((schedule = schedules[i]).state > SCHEDULED && schedule.name === name) {
4318        return new Transition([[node]], root$1, name, +i);
4319      }
4320    }
4321  }
4322
4323  return null;
4324}
4325
4326function constant$4(x) {
4327  return function() {
4328    return x;
4329  };
4330}
4331
4332function BrushEvent(target, type, selection) {
4333  this.target = target;
4334  this.type = type;
4335  this.selection = selection;
4336}
4337
4338function nopropagation$1() {
4339  exports.event.stopImmediatePropagation();
4340}
4341
4342function noevent$1() {
4343  exports.event.preventDefault();
4344  exports.event.stopImmediatePropagation();
4345}
4346
4347var MODE_DRAG = {name: "drag"},
4348    MODE_SPACE = {name: "space"},
4349    MODE_HANDLE = {name: "handle"},
4350    MODE_CENTER = {name: "center"};
4351
4352function number1(e) {
4353  return [+e[0], +e[1]];
4354}
4355
4356function number2(e) {
4357  return [number1(e[0]), number1(e[1])];
4358}
4359
4360function toucher(identifier) {
4361  return function(target) {
4362    return touch(target, exports.event.touches, identifier);
4363  };
4364}
4365
4366var X = {
4367  name: "x",
4368  handles: ["w", "e"].map(type),
4369  input: function(x, e) { return x == null ? null : [[+x[0], e[0][1]], [+x[1], e[1][1]]]; },
4370  output: function(xy) { return xy && [xy[0][0], xy[1][0]]; }
4371};
4372
4373var Y = {
4374  name: "y",
4375  handles: ["n", "s"].map(type),
4376  input: function(y, e) { return y == null ? null : [[e[0][0], +y[0]], [e[1][0], +y[1]]]; },
4377  output: function(xy) { return xy && [xy[0][1], xy[1][1]]; }
4378};
4379
4380var XY = {
4381  name: "xy",
4382  handles: ["n", "w", "e", "s", "nw", "ne", "sw", "se"].map(type),
4383  input: function(xy) { return xy == null ? null : number2(xy); },
4384  output: function(xy) { return xy; }
4385};
4386
4387var cursors = {
4388  overlay: "crosshair",
4389  selection: "move",
4390  n: "ns-resize",
4391  e: "ew-resize",
4392  s: "ns-resize",
4393  w: "ew-resize",
4394  nw: "nwse-resize",
4395  ne: "nesw-resize",
4396  se: "nwse-resize",
4397  sw: "nesw-resize"
4398};
4399
4400var flipX = {
4401  e: "w",
4402  w: "e",
4403  nw: "ne",
4404  ne: "nw",
4405  se: "sw",
4406  sw: "se"
4407};
4408
4409var flipY = {
4410  n: "s",
4411  s: "n",
4412  nw: "sw",
4413  ne: "se",
4414  se: "ne",
4415  sw: "nw"
4416};
4417
4418var signsX = {
4419  overlay: +1,
4420  selection: +1,
4421  n: null,
4422  e: +1,
4423  s: null,
4424  w: -1,
4425  nw: -1,
4426  ne: +1,
4427  se: +1,
4428  sw: -1
4429};
4430
4431var signsY = {
4432  overlay: +1,
4433  selection: +1,
4434  n: -1,
4435  e: null,
4436  s: +1,
4437  w: null,
4438  nw: -1,
4439  ne: -1,
4440  se: +1,
4441  sw: +1
4442};
4443
4444function type(t) {
4445  return {type: t};
4446}
4447
4448// Ignore right-click, since that should open the context menu.
4449function defaultFilter$1() {
4450  return !exports.event.ctrlKey && !exports.event.button;
4451}
4452
4453function defaultExtent() {
4454  var svg = this.ownerSVGElement || this;
4455  if (svg.hasAttribute("viewBox")) {
4456    svg = svg.viewBox.baseVal;
4457    return [[svg.x, svg.y], [svg.x + svg.width, svg.y + svg.height]];
4458  }
4459  return [[0, 0], [svg.width.baseVal.value, svg.height.baseVal.value]];
4460}
4461
4462function defaultTouchable$1() {
4463  return navigator.maxTouchPoints || ("ontouchstart" in this);
4464}
4465
4466// Like d3.local, but with the name “__brush” rather than auto-generated.
4467function local$1(node) {
4468  while (!node.__brush) if (!(node = node.parentNode)) return;
4469  return node.__brush;
4470}
4471
4472function empty$1(extent) {
4473  return extent[0][0] === extent[1][0]
4474      || extent[0][1] === extent[1][1];
4475}
4476
4477function brushSelection(node) {
4478  var state = node.__brush;
4479  return state ? state.dim.output(state.selection) : null;
4480}
4481
4482function brushX() {
4483  return brush$1(X);
4484}
4485
4486function brushY() {
4487  return brush$1(Y);
4488}
4489
4490function brush() {
4491  return brush$1(XY);
4492}
4493
4494function brush$1(dim) {
4495  var extent = defaultExtent,
4496      filter = defaultFilter$1,
4497      touchable = defaultTouchable$1,
4498      keys = true,
4499      listeners = dispatch("start", "brush", "end"),
4500      handleSize = 6,
4501      touchending;
4502
4503  function brush(group) {
4504    var overlay = group
4505        .property("__brush", initialize)
4506      .selectAll(".overlay")
4507      .data([type("overlay")]);
4508
4509    overlay.enter().append("rect")
4510        .attr("class", "overlay")
4511        .attr("pointer-events", "all")
4512        .attr("cursor", cursors.overlay)
4513      .merge(overlay)
4514        .each(function() {
4515          var extent = local$1(this).extent;
4516          select(this)
4517              .attr("x", extent[0][0])
4518              .attr("y", extent[0][1])
4519              .attr("width", extent[1][0] - extent[0][0])
4520              .attr("height", extent[1][1] - extent[0][1]);
4521        });
4522
4523    group.selectAll(".selection")
4524      .data([type("selection")])
4525      .enter().append("rect")
4526        .attr("class", "selection")
4527        .attr("cursor", cursors.selection)
4528        .attr("fill", "#777")
4529        .attr("fill-opacity", 0.3)
4530        .attr("stroke", "#fff")
4531        .attr("shape-rendering", "crispEdges");
4532
4533    var handle = group.selectAll(".handle")
4534      .data(dim.handles, function(d) { return d.type; });
4535
4536    handle.exit().remove();
4537
4538    handle.enter().append("rect")
4539        .attr("class", function(d) { return "handle handle--" + d.type; })
4540        .attr("cursor", function(d) { return cursors[d.type]; });
4541
4542    group
4543        .each(redraw)
4544        .attr("fill", "none")
4545        .attr("pointer-events", "all")
4546        .on("mousedown.brush", started)
4547      .filter(touchable)
4548        .on("touchstart.brush", started)
4549        .on("touchmove.brush", touchmoved)
4550        .on("touchend.brush touchcancel.brush", touchended)
4551        .style("touch-action", "none")
4552        .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)");
4553  }
4554
4555  brush.move = function(group, selection) {
4556    if (group.selection) {
4557      group
4558          .on("start.brush", function() { emitter(this, arguments).beforestart().start(); })
4559          .on("interrupt.brush end.brush", function() { emitter(this, arguments).end(); })
4560          .tween("brush", function() {
4561            var that = this,
4562                state = that.__brush,
4563                emit = emitter(that, arguments),
4564                selection0 = state.selection,
4565                selection1 = dim.input(typeof selection === "function" ? selection.apply(this, arguments) : selection, state.extent),
4566                i = interpolateValue(selection0, selection1);
4567
4568            function tween(t) {
4569              state.selection = t === 1 && selection1 === null ? null : i(t);
4570              redraw.call(that);
4571              emit.brush();
4572            }
4573
4574            return selection0 !== null && selection1 !== null ? tween : tween(1);
4575          });
4576    } else {
4577      group
4578          .each(function() {
4579            var that = this,
4580                args = arguments,
4581                state = that.__brush,
4582                selection1 = dim.input(typeof selection === "function" ? selection.apply(that, args) : selection, state.extent),
4583                emit = emitter(that, args).beforestart();
4584
4585            interrupt(that);
4586            state.selection = selection1 === null ? null : selection1;
4587            redraw.call(that);
4588            emit.start().brush().end();
4589          });
4590    }
4591  };
4592
4593  brush.clear = function(group) {
4594    brush.move(group, null);
4595  };
4596
4597  function redraw() {
4598    var group = select(this),
4599        selection = local$1(this).selection;
4600
4601    if (selection) {
4602      group.selectAll(".selection")
4603          .style("display", null)
4604          .attr("x", selection[0][0])
4605          .attr("y", selection[0][1])
4606          .attr("width", selection[1][0] - selection[0][0])
4607          .attr("height", selection[1][1] - selection[0][1]);
4608
4609      group.selectAll(".handle")
4610          .style("display", null)