https://www.jobsexperts.at/typo3temp/assets/compressed/d3-395eb3b1330c485f9f27be5d116bad57.js?1781861596

1// https://d3js.org Version 4.13.0. Copyright 2018 Mike Bostock.
2(function (global, factory) {
3	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
4	typeof define === 'function' && define.amd ? define(['exports'], factory) :
5	(factory((global.d3 = global.d3 || {})));
6}(this, (function (exports) { 'use strict';
7
8var version = "4.13.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);
194var e5 = Math.sqrt(10);
195var 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 sturges(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 = sturges;
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, Math.floor(x1 / tz) * tz, 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;
565var right = 2;
566var bottom = 3;
567var left = 4;
568var 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", "#000"));
626
627    tick = tick.merge(tickEnter);
628
629    line = line.merge(tickEnter.append("line")
630        .attr("stroke", "#000")
631        .attr(x + "2", k * tickSizeInner));
632
633    text = text.merge(tickEnter.append("text")
634        .attr("fill", "#000")
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            ? "M" + k * tickSizeOuter + "," + range0 + "H0.5V" + range1 + "H" + k * tickSizeOuter
658            : "M" + range0 + "," + k * tickSizeOuter + "V0.5H" + range1 + "V" + k * tickSizeOuter);
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 _)) 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$1() {
882  return [];
883}
884
885function selectorAll(selector) {
886  return selector == null ? empty$1 : 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
906var matcher = function(selector) {
907  return function() {
908    return this.matches(selector);
909  };
910};
911
912if (typeof document !== "undefined") {
913  var element = document.documentElement;
914  if (!element.matches) {
915    var vendorMatches = element.webkitMatchesSelector

916        || element.msMatchesSelector
917        || element.mozMatchesSelector
918        || element.oMatchesSelector;
919    matcher = function(selector) {
920      return function() {
921        return vendorMatches.call(this, selector);
922      };
923    };
924  }
925}
926
927var matcher$1 = matcher;
928
929function selection_filter(match) {
930  if (typeof match !== "function") match = matcher$1(match);
931
932  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
933    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {
934      if ((node = group[i]) && match.call(node, node.__data__, i, group)) {
935        subgroup.push(node);
936      }
937    }
938  }
939
940  return new Selection(subgroups, this._parents);
941}
942
943function sparse(update) {
944  return new Array(update.length);
945}
946
947function selection_enter() {
948  return new Selection(this._enter || this._groups.map(sparse), this._parents);
949}
950
951function EnterNode(parent, datum) {
952  this.ownerDocument = parent.ownerDocument;
953  this.namespaceURI = parent.namespaceURI;
954  this._next = null;
955  this._parent = parent;
956  this.__data__ = datum;
957}
958
959EnterNode.prototype = {
960  constructor: EnterNode,
961  appendChild: function(child) { return this._parent.insertBefore(child, this._next); },
962  insertBefore: function(child, next) { return this._parent.insertBefore(child, next); },
963  querySelector: function(selector) { return this._parent.querySelector(selector); },
964  querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); }
965};
966
967function constant$1(x) {
968  return function() {
969    return x;
970  };
971}
972
973var keyPrefix = "$"; // Protect against keys like “__proto__”.
974
975function bindIndex(parent, group, enter, update, exit, data) {
976  var i = 0,
977      node,
978      groupLength = group.length,
979      dataLength = data.length;
980
981  // Put any non-null nodes that fit into update.
982  // Put any null nodes into enter.
983  // Put any remaining data into enter.
984  for (; i < dataLength; ++i) {
985    if (node = group[i]) {
986      node.__data__ = data[i];
987      update[i] = node;
988    } else {
989      enter[i] = new EnterNode(parent, data[i]);
990    }
991  }
992
993  // Put any non-null nodes that don’t fit into exit.
994  for (; i < groupLength; ++i) {
995    if (node = group[i]) {
996      exit[i] = node;
997    }
998  }
999}
1000
1001function bindKey(parent, group, enter, update, exit, data, key) {
1002  var i,
1003      node,
1004      nodeByKeyValue = {},
1005      groupLength = group.length,
1006      dataLength = data.length,
1007      keyValues = new Array(groupLength),
1008      keyValue;
1009
1010  // Compute the key for each node.
1011  // If multiple nodes have the same key, the duplicates are added to exit.
1012  for (i = 0; i < groupLength; ++i) {
1013    if (node = group[i]) {
1014      keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group);
1015      if (keyValue in nodeByKeyValue) {
1016        exit[i] = node;
1017      } else {
1018        nodeByKeyValue[keyValue] = node;
1019      }
1020    }
1021  }
1022
1023  // Compute the key for each datum.
1024  // If there a node associated with this key, join and add it to update.
1025  // If there is not (or the key is a duplicate), add it to enter.
1026  for (i = 0; i < dataLength; ++i) {
1027    keyValue = keyPrefix + key.call(parent, data[i], i, data);
1028    if (node = nodeByKeyValue[keyValue]) {
1029      update[i] = node;
1030      node.__data__ = data[i];
1031      nodeByKeyValue[keyValue] = null;
1032    } else {
1033      enter[i] = new EnterNode(parent, data[i]);
1034    }
1035  }
1036
1037  // Add any remaining nodes that were not bound to data to exit.
1038  for (i = 0; i < groupLength; ++i) {
1039    if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) {
1040      exit[i] = node;
1041    }
1042  }
1043}
1044
1045function selection_data(value, key) {
1046  if (!value) {
1047    data = new Array(this.size()), j = -1;
1048    this.each(function(d) { data[++j] = d; });
1049    return data;
1050  }
1051
1052  var bind = key ? bindKey : bindIndex,
1053      parents = this._parents,
1054      groups = this._groups;
1055
1056  if (typeof value !== "function") value = constant$1(value);
1057
1058  for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) {
1059    var parent = parents[j],
1060        group = groups[j],
1061        groupLength = group.length,
1062        data = value.call(parent, parent && parent.__data__, j, parents),
1063        dataLength = data.length,
1064        enterGroup = enter[j] = new Array(dataLength),
1065        updateGroup = update[j] = new Array(dataLength),
1066        exitGroup = exit[j] = new Array(groupLength);
1067
1068    bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);
1069
1070    // Now connect the enter nodes to their following update node, such that
1071    // appendChild can insert the materialized enter node before this node,
1072    // rather than at the end of the parent node.
1073    for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) {
1074      if (previous = enterGroup[i0]) {
1075        if (i0 >= i1) i1 = i0 + 1;
1076        while (!(next = updateGroup[i1]) && ++i1 < dataLength);
1077        previous._next = next || null;
1078      }
1079    }
1080  }
1081
1082  update = new Selection(update, parents);
1083  update._enter = enter;
1084  update._exit = exit;
1085  return update;
1086}
1087
1088function selection_exit() {
1089  return new Selection(this._exit || this._groups.map(sparse), this._parents);
1090}
1091
1092function selection_merge(selection$$1) {
1093
1094  for (var groups0 = this._groups, groups1 = selection$$1._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {
1095    for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {
1096      if (node = group0[i] || group1[i]) {
1097        merge[i] = node;
1098      }
1099    }
1100  }
1101
1102  for (; j < m0; ++j) {
1103    merges[j] = groups0[j];
1104  }
1105
1106  return new Selection(merges, this._parents);
1107}
1108
1109function selection_order() {
1110
1111  for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) {
1112    for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) {
1113      if (node = group[i]) {
1114        if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);
1115        next = node;
1116      }
1117    }
1118  }
1119
1120  return this;
1121}
1122
1123function selection_sort(compare) {
1124  if (!compare) compare = ascending$1;
1125
1126  function compareNode(a, b) {
1127    return a && b ? compare(a.__data__, b.__data__) : !a - !b;
1128  }
1129
1130  for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) {
1131    for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) {
1132      if (node = group[i]) {
1133        sortgroup[i] = node;
1134      }
1135    }
1136    sortgroup.sort(compareNode);
1137  }
1138
1139  return new Selection(sortgroups, this._parents).order();
1140}
1141
1142function ascending$1(a, b) {
1143  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
1144}
1145
1146function selection_call() {
1147  var callback = arguments[0];
1148  arguments[0] = this;
1149  callback.apply(null, arguments);
1150  return this;
1151}
1152
1153function selection_nodes() {
1154  var nodes = new Array(this.size()), i = -1;
1155  this.each(function() { nodes[++i] = this; });
1156  return nodes;
1157}
1158
1159function selection_node() {
1160
1161  for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
1162    for (var group = groups[j], i = 0, n = group.length; i < n; ++i) {
1163      var node = group[i];
1164      if (node) return node;
1165    }
1166  }
1167
1168  return null;
1169}
1170
1171function selection_size() {
1172  var size = 0;
1173  this.each(function() { ++size; });

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

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

21995 / 100, 1) // rgb(100%, 0%, 0%)
2200      : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1)
2201      : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1)
2202      : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%)
2203      : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1)
2204      : named.hasOwnProperty(format) ? rgbn(named[format])
2205      : format === "transparent" ? new Rgb(NaN, NaN, NaN, 0)
2206      : null;
2207}
2208
2209function rgbn(n) {
2210  return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1);
2211}
2212
2213function rgba(r, g, b, a) {
2214  if (a <= 0) r = g = b = NaN;
2215  return new Rgb(r, g, b, a);
2216}
2217
2218function rgbConvert(o) {
2219  if (!(o instanceof Color)) o = color(o);
2220  if (!o) return new Rgb;
2221  o = o.rgb();
2222  return new Rgb(o.r, o.g, o.b, o.opacity);
2223}
2224
2225function rgb(r, g, b, opacity) {
2226  return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);
2227}
2228
2229function Rgb(r, g, b, opacity) {
2230  this.r = +r;
2231  this.g = +g;
2232  this.b = +b;
2233  this.opacity = +opacity;
2234}
2235
2236define(Rgb, rgb, extend(Color, {
2237  brighter: function(k) {
2238    k = k == null ? brighter : Math.pow(brighter, k);
2239    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
2240  },
2241  darker: function(k) {
2242    k = k == null ? darker : Math.pow(darker, k);
2243    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
2244  },
2245  rgb: function() {
2246    return this;
2247  },
2248  displayable: function() {
2249    return (0 <= this.r && this.r <= 255)
2250        && (0 <= this.g && this.g <= 255)
2251        && (0 <= this.b && this.b <= 255)
2252        && (0 <= this.opacity && this.opacity <= 1);
2253  },
2254  toString: function() {
2255    var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a));
2256    return (a === 1 ? "rgb(" : "rgba(")
2257        + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", "
2258        + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", "
2259        + Math.max(0, Math.min(255, Math.round(this.b) || 0))
2260        + (a === 1 ? ")" : ", " + a + ")");
2261  }
2262}));
2263
2264function hsla(h, s, l, a) {
2265  if (a <= 0) h = s = l = NaN;
2266  else if (l <= 0 || l >= 1) h = s = NaN;
2267  else if (s <= 0) h = NaN;
2268  return new Hsl(h, s, l, a);
2269}
2270
2271function hslConvert(o) {
2272  if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);
2273  if (!(o instanceof Color)) o = color(o);
2274  if (!o) return new Hsl;
2275  if (o instanceof Hsl) return o;
2276  o = o.rgb();
2277  var r = o.r / 255,
2278      g = o.g / 255,
2279      b = o.b / 255,
2280      min = Math.min(r, g, b),
2281      max = Math.max(r, g, b),
2282      h = NaN,
2283      s = max - min,
2284      l = (max + min) / 2;
2285  if (s) {
2286    if (r === max) h = (g - b) / s + (g < b) * 6;
2287    else if (g === max) h = (b - r) / s + 2;
2288    else h = (r - g) / s + 4;
2289    s /= l < 0.5 ? max + min : 2 - max - min;
2290    h *= 60;
2291  } else {
2292    s = l > 0 && l < 1 ? 0 : h;
2293  }
2294  return new Hsl(h, s, l, o.opacity);
2295}
2296
2297function hsl(h, s, l, opacity) {
2298  return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);
2299}
2300
2301function Hsl(h, s, l, opacity) {
2302  this.h = +h;
2303  this.s = +s;
2304  this.l = +l;
2305  this.opacity = +opacity;
2306}
2307
2308define(Hsl, hsl, extend(Color, {
2309  brighter: function(k) {
2310    k = k == null ? brighter : Math.pow(brighter, k);
2311    return new Hsl(this.h, this.s, this.l * k, this.opacity);
2312  },
2313  darker: function(k) {
2314    k = k == null ? darker : Math.pow(darker, k);
2315    return new Hsl(this.h, this.s, this.l * k, this.opacity);
2316  },
2317  rgb: function() {
2318    var h = this.h % 360 + (this.h < 0) * 360,
2319        s = isNaN(h) || isNaN(this.s) ? 0 : this.s,
2320        l = this.l,
2321        m2 = l + (l < 0.5 ? l : 1 - l) * s,
2322        m1 = 2 * l - m2;
2323    return new Rgb(
2324      hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2),
2325      hsl2rgb(h, m1, m2),
2326      hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2),
2327      this.opacity
2328    );
2329  },
2330  displayable: function() {
2331    return (0 <= this.s && this.s <= 1 || isNaN(this.s))
2332        && (0 <= this.l && this.l <= 1)
2333        && (0 <= this.opacity && this.opacity <= 1);
2334  }
2335}));
2336
2337/* From FvD 13.37, CSS Color Module Level 3 */
2338function hsl2rgb(h, m1, m2) {
2339  return (h < 60 ? m1 + (m2 - m1) * h / 60
2340      : h < 180 ? m2
2341      : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60
2342      : m1) * 255;
2343}
2344
2345var deg2rad = Math.PI / 180;
2346var rad2deg = 180 / Math.PI;
2347
2348var Kn = 18;
2349var Xn = 0.950470;
2350var Yn = 1;
2351var Zn = 1.088830;
2352var t0 = 4 / 29;
2353var t1 = 6 / 29;
2354var t2 = 3 * t1 * t1;
2355var t3 = t1 * t1 * t1;
2356
2357function labConvert(o) {

2358  if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity);
2359  if (o instanceof Hcl) {
2360    var h = o.h * deg2rad;
2361    return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity);
2362  }
2363  if (!(o instanceof Rgb)) o = rgbConvert(o);
2364  var b = rgb2xyz(o.r),
2365      a = rgb2xyz(o.g),
2366      l = rgb2xyz(o.b),
2367      x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn),
2368      y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.0721750 * l) / Yn),
2369      z = xyz2lab((0.0193339 * b + 0.1191920 * a + 0.9503041 * l) / Zn);
2370  return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity);
2371}
2372
2373function lab(l, a, b, opacity) {
2374  return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity);
2375}
2376
2377function Lab(l, a, b, opacity) {
2378  this.l = +l;
2379  this.a = +a;
2380  this.b = +b;
2381  this.opacity = +opacity;
2382}
2383
2384define(Lab, lab, extend(Color, {
2385  brighter: function(k) {
2386    return new Lab(this.l + Kn * (k == null ? 1 : k), this.a, this.b, this.opacity);
2387  },
2388  darker: function(k) {
2389    return new Lab(this.l - Kn * (k == null ? 1 : k), this.a, this.b, this.opacity);
2390  },
2391  rgb: function() {
2392    var y = (this.l + 16) / 116,
2393        x = isNaN(this.a) ? y : y + this.a / 500,
2394        z = isNaN(this.b) ? y : y - this.b / 200;
2395    y = Yn * lab2xyz(y);
2396    x = Xn * lab2xyz(x);
2397    z = Zn * lab2xyz(z);
2398    return new Rgb(
2399      xyz2rgb( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB
2400      xyz2rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z),
2401      xyz2rgb( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z),
2402      this.opacity
2403    );
2404  }
2405}));
2406
2407function xyz2lab(t) {
2408  return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;
2409}
2410
2411function lab2xyz(t) {
2412  return t > t1 ? t * t * t : t2 * (t - t0);
2413}
2414
2415function xyz2rgb(x) {
2416  return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055);
2417}
2418
2419function rgb2xyz(x) {
2420  return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);
2421}
2422
2423function hclConvert(o) {
2424  if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity);
2425  if (!(o instanceof Lab)) o = labConvert(o);
2426  var h = Math.atan2(o.b, o.a) * rad2deg;
2427  return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity);
2428}
2429
2430function hcl(h, c, l, opacity) {
2431  return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity);
2432}
2433
2434function Hcl(h, c, l, opacity) {
2435  this.h = +h;
2436  this.c = +c;
2437  this.l = +l;
2438  this.opacity = +opacity;
2439}
2440
2441define(Hcl, hcl, extend(Color, {
2442  brighter: function(k) {
2443    return new Hcl(this.h, this.c, this.l + Kn * (k == null ? 1 : k), this.opacity);
2444  },
2445  darker: function(k) {
2446    return new Hcl(this.h, this.c, this.l - Kn * (k == null ? 1 : k), this.opacity);
2447  },
2448  rgb: function() {
2449    return labConvert(this).rgb();
2450  }
2451}));
2452
2453var A = -0.14861;
2454var B = +1.78277;
2455var C = -0.29227;
2456var D = -0.90649;
2457var E = +1.97294;
2458var ED = E * D;
2459var EB = E * B;
2460var BC_DA = B * C - D * A;
2461
2462function cubehelixConvert(o) {
2463  if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity);
2464  if (!(o instanceof Rgb)) o = rgbConvert(o);
2465  var r = o.r / 255,
2466      g = o.g / 255,
2467      b = o.b / 255,
2468      l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB),
2469      bl = b - l,
2470      k = (E * (g - l) - C * bl) / D,
2471      s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1
2472      h = s ? Math.atan2(k, bl) * rad2deg - 120 : NaN;
2473  return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity);
2474}
2475
2476function cubehelix(h, s, l, opacity) {
2477  return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity);
2478}
2479
2480function Cubehelix(h, s, l, opacity) {
2481  this.h = +h;
2482  this.s = +s;
2483  this.l = +l;
2484  this.opacity = +opacity;
2485}
2486
2487define(Cubehelix, cubehelix, extend(Color, {
2488  brighter: function(k) {
2489    k = k == null ? brighter : Math.pow(brighter, k);
2490    return new Cubehelix(this.h, this.s, this.l * k, this.opacity);
2491  },
2492  darker: function(k) {
2493    k = k == null ? darker : Math.pow(darker, k);
2494    return new Cubehelix(this.h, this.s, this.l * k, this.opacity);
2495  },
2496  rgb: function() {
2497    var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad,
2498        l = +this.l,
2499        a = isNaN(this.s) ? 0 : this.s * l * (1 - l),
2500        cosh = Math.cos(h),
2501        sinh = Math.sin(h);
2502    return new Rgb(
2503      255 * (l + a * (A * cosh + B * sinh)),
2504      255 * (l + a * (C * cosh + D * sinh)),
2505      255 * (l + a * (E * cosh)),
2506      this.opacity
2507    );
2508  }
2509}));
2510
2511function basis(t1, v0, v1, v2, v3) {
2512  var t2 = t1 * t1, t3 = t2 * t1;
2513  return ((1 - 3 * t1 + 3 * t2 - t3) * v0
2514      + (4 - 6 * t2 + 3 * t3) * v1
2515      + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2
2516      + t3 * v3) / 6;
2517}
2518
2519function basis$1(values) {
2520  var n = values.length - 1;
2521  return function(t) {
2522    var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n),
2523        v1 = values[i],
2524        v2 = values[i + 1],
2525        v0 = i > 0 ? values[i - 1] : 2 * v1 - v2,
2526        v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;
2527    return basis((t - i / n) * n, v0, v1, v2, v3);
2528  };
2529}
2530
2531function basisClosed(values) {
2532  var n = values.length;
2533  return function(t) {
2534    var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n),
2535        v0 = values[(i + n - 1) % n],
2536        v1 = values[i % n],
2537        v2 = values[(i + 1) % n],
2538        v3 = values[(i + 2) % n];
2539    return basis((t - i / n) * n, v0, v1, v2, v3);
2540  };
2541}
2542
2543function constant$3(x) {
2544  return function() {
2545    return x;
2546  };
2547}
2548
2549function linear(a, d) {
2550  return function(t) {
2551    return a + t * d;
2552  };
2553}
2554
2555function exponential(a, b, y) {
2556  return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) {
2557    return Math.pow(a + t * b, y);
2558  };
2559}
2560
2561function hue(a, b) {
2562  var d = b - a;
2563  return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant$3(isNaN(a) ? b : a);
2564}
2565
2566function gamma(y) {
2567  return (y = +y) === 1 ? nogamma : function(a, b) {
2568    return b - a ? exponential(a, b, y) : constant$3(isNaN(a) ? b : a);
2569  };
2570}
2571
2572function nogamma(a, b) {
2573  var d = b - a;
2574  return d ? linear(a, d) : constant$3(isNaN(a) ? b : a);
2575}
2576
2577var interpolateRgb = (function rgbGamma(y) {
2578  var color$$1 = gamma(y);
2579
2580  function rgb$$1(start, end) {
2581    var r = color$$1((start = rgb(start)).r, (end = rgb(end)).r),
2582        g = color$$1(start.g, end.g),
2583        b = color$$1(start.b, end.b),
2584        opacity = nogamma(start.opacity, end.opacity);
2585    return function(t) {
2586      start.r = r(t);
2587      start.g = g(t);
2588      start.b = b(t);
2589      start.opacity = opacity(t);
2590      return start + "";
2591    };
2592  }
2593
2594  rgb$$1.gamma = rgbGamma;
2595
2596  return rgb$$1;
2597})(1);
2598
2599function rgbSpline(spline) {
2600  return function(colors) {
2601    var n = colors.length,
2602        r = new Array(n),
2603        g = new Array(n),
2604        b = new Array(n),
2605        i, color$$1;
2606    for (i = 0; i < n; ++i) {
2607      color$$1 = rgb(colors[i]);
2608      r[i] = color$$1.r || 0;
2609      g[i] = color$$1.g || 0;
2610      b[i] = color$$1.b || 0;
2611    }
2612    r = spline(r);
2613    g = spline(g);
2614    b = spline(b);
2615    color$$1.opacity = 1;
2616    return function(t) {
2617      color$$1.r = r(t);
2618      color$$1.g = g(t);
2619      color$$1.b = b(t);
2620      return color$$1 + "";
2621    };
2622  };
2623}
2624
2625var rgbBasis = rgbSpline(basis$1);
2626var rgbBasisClosed = rgbSpline(basisClosed);
2627
2628function array$1(a, b) {
2629  var nb = b ? b.length : 0,
2630      na = a ? Math.min(nb, a.length) : 0,
2631      x = new Array(na),
2632      c = new Array(nb),
2633      i;
2634
2635  for (i = 0; i < na; ++i) x[i] = interpolateValue(a[i], b[i]);
2636  for (; i < nb; ++i) c[i] = b[i];
2637
2638  return function(t) {
2639    for (i = 0; i < na; ++i) c[i] = x[i](t);
2640    return c;
2641  };
2642}
2643
2644function date(a, b) {
2645  var d = new Date;
2646  return a = +a, b -= a, function(t) {
2647    return d.setTime(a + b * t), d;
2648  };
2649}
2650
2651function reinterpolate(a, b) {
2652  return a = +a, b -= a, function(t) {
2653    return a + b * t;
2654  };
2655}
2656
2657function object(a, b) {
2658  var i = {},
2659      c = {},
2660      k;
2661
2662  if (a === null || typeof a !== "object") a = {};
2663  if (b === null || typeof b !== "object") b = {};
2664
2665  for (k in b) {
2666    if (k in a) {
2667      i[k] = interpolateValue(a[k], b[k]);
2668    } else {
2669      c[k] = b[k];
2670    }
2671  }
2672
2673  return function(t) {
2674    for (k in i) c[k] = i[k](t);
2675    return c;
2676  };
2677}
2678
2679var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g;
2680var reB = new RegExp(reA.source, "g");
2681
2682function zero(b) {
2683  return function() {
2684    return b;
2685  };
2686}
2687
2688function one(b) {
2689  return function(t) {
2690    return b(t) + "";
2691  };
2692}
2693
2694function interpolateString(a, b) {
2695  var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b
2696      am, // current match in a
2697      bm, // current match in b
2698      bs, // string preceding current number in b, if any
2699      i = -1, // index in s
2700      s = [], // string constants and placeholders
2701      q = []; // number interpolators
2702
2703  // Coerce inputs to strings.
2704  a = a + "", b = b + "";
2705
2706  // Interpolate pairs of numbers in a & b.
2707  while ((am = reA.exec(a))
2708      && (bm = reB.exec(b))) {
2709    if ((bs = bm.index) > bi) { // a string precedes the next number in b
2710      bs = b.slice(bi, bs);
2711      if (s[i]) s[i] += bs; // coalesce with previous string
2712      else s[++i] = bs;
2713    }
2714    if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match
2715      if (s[i]) s[i] += bm; // coalesce with previous string
2716      else s[++i] = bm;
2717    } else { // interpolate non-matching numbers
2718      s[++i] = null;
2719      q.push({i: i, x: reinterpolate(am, bm)});
2720    }
2721    bi = reB.lastIndex;
2722  }
2723
2724  // Add remains of b.
2725  if (bi < b.length) {
2726    bs = b.slice(bi);
2727    if (s[i]) s[i] += bs; // coalesce with previous string
2728    else s[++i] = bs;
2729  }
2730
2731  // Special optimization for only a single match.
2732  // Otherwise, interpolate each of the numbers and rejoin the string.
2733  return s.length < 2 ? (q[0]
2734      ? one(q[0].x)
2735      : zero(b))
2736      : (b = q.length, function(t) {
2737          for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);
2738          return s.join("");
2739        });
2740}
2741
2742function interpolateValue(a, b) {
2743  var t = typeof b, c;
2744  return b == null || t === "boolean" ? constant$3(b)
2745      : (t === "number" ? reinterpolate
2746      : t === "string" ? ((c = color(b)) ? (b = c, interpolateRgb) : interpolateString)
2747      : b instanceof color ? interpolateRgb
2748      : b instanceof Date ? date
2749      : Array.isArray(b) ? array$1
2750      : typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? object
2751      : reinterpolate)(a, b);
2752}
2753
2754function interpolateRound(a, b) {
2755  return a = +a, b -= a, function(t) {
2756    return Math.round(a + b * t);
2757  };
2758}
2759
2760var degrees = 180 / Math.PI;
2761
2762var identity$2 = {
2763  translateX: 0,
2764  translateY: 0,
2765  rotate: 0,
2766  skewX: 0,
2767  scaleX: 1,
2768  scaleY: 1
2769};
2770
2771function decompose(a, b, c, d, e, f) {
2772  var scaleX, scaleY, skewX;
2773  if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX;