|
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ |
|
/* |
|
|
|
This file needs to be compiled with Browserify to `bundle.js` in order that the visualisation can be displayed in the browser. |
|
|
|
*/ |
|
const d3 = require("d3") |
|
|
|
const width = window.innerWidth |
|
const height = window.innerHeight |
|
|
|
var svg = d3.select("div#chartId") |
|
.append("div") |
|
.classed("svg-container", true) //container class to make it responsive |
|
.append("svg") |
|
//responsive SVG needs these 2 attributes and no width and height attr |
|
.attr("preserveAspectRatio", "xMinYMin meet") |
|
//.attr("width", width) |
|
//.attr("height", height) |
|
.attr("viewBox", `0 0 ${width} ${height}`) |
|
//class to make it responsive |
|
.classed("svg-content-responsive", true) |
|
|
|
d3.tsv("uor-joint-courses-data-2014.tsv", function(error, data) { |
|
if (error) throw error |
|
|
|
var flatJoints = data |
|
.map(o => { |
|
var a = [] |
|
var k |
|
for (k in o) { |
|
if (k !== "Course" && o.hasOwnProperty(k)) { |
|
a.push({ |
|
"course": o["Course"], |
|
"joint": k, |
|
"boolean": o[k] === "*" |
|
}) |
|
} |
|
} |
|
return a |
|
}) |
|
.reduce((p, c) => p.concat(c), []) |
|
|
|
var deduplicate = array => array |
|
.filter((f => { |
|
var o = {} |
|
return x => { |
|
var r = !o.hasOwnProperty(x) |
|
o[x] = true |
|
return r |
|
} |
|
})()) |
|
|
|
var courselabels = deduplicate(flatJoints.map(x => x.course)) |
|
var jointlabels = deduplicate(flatJoints.map(x => x.joint)) |
|
|
|
const x = d3.scaleBand() |
|
.range([width / 5, width]) |
|
.domain(courselabels) |
|
|
|
const y = d3.scaleBand() |
|
.range([height / 5, height]) |
|
.domain(jointlabels) |
|
|
|
var dataArea = svg.append("g") |
|
.attr("id", "dataArea") |
|
|
|
var rects = dataArea.selectAll(".course") |
|
.data(flatJoints) |
|
.enter().append("rect") |
|
.attr("class", (d, i) => `course course-${d.course.replace(/[^\w\d\-\_]+/g, "-").toLowerCase()} joint-${d.joint.replace(/[^\w\d\-\_]+/g, "-").toLowerCase()} ${Math.floor(i / y.domain().length) % 2 ? "odd-row" : "even-row" } ${d.boolean ? "joint-option-exists" : "joint-option-unavailable"}`) |
|
.attr("x", d => x(d.course)) |
|
.attr("y", d => y(d.joint)) |
|
.attr("width", x.bandwidth()) |
|
.attr("height", y.bandwidth()) |
|
|
|
var xlabels = dataArea.selectAll(".xlabel") |
|
.data(x.domain()) |
|
.enter().append("g") |
|
.attr("class", "label xlabel") |
|
//.attr("transform", d => `translate(${x(d) + (x.bandwidth() / 2)}, ${(height / 5) - y.bandwidth()})`) |
|
|
|
var xtext = xlabels.append("text") |
|
.attr("class", "labeltext") |
|
.attr("x", 0) |
|
.attr("y", 0) |
|
.attr("transform", `rotate(-90)`) |
|
.text(d => d) |
|
|
|
var ylabels = dataArea.selectAll(".ylabel") |
|
.data(y.domain()) |
|
.enter().append("g") |
|
.attr("class", "label ylabel") |
|
//.attr("transform", d => `translate(0, ${y(d) + (y.bandwidth() / 2)})`) |
|
|
|
var ytext = ylabels.append("text") |
|
.attr("class", "labeltext") |
|
.attr("x", 0) |
|
.attr("y", 0) |
|
.text(d => d) |
|
|
|
var maxxlabelwidth = d3.max(xtext.nodes(), n => n.getComputedTextLength()) |
|
var maxylabelwidth = d3.max(ytext.nodes(), n => n.getComputedTextLength()) |
|
|
|
var maxxlabelheight = d3.max(xtext.nodes(), n => n.getBBox().height) |
|
var maxylabelheight = d3.max(ytext.nodes(), n => n.getBBox().height) |
|
|
|
x.range([maxylabelwidth + maxylabelheight, width]) |
|
y.range([maxxlabelwidth + maxxlabelheight, height]) |
|
|
|
rects |
|
.attr("x", d => x(d.course)) |
|
.attr("y", d => y(d.joint)) |
|
.attr("width", x.bandwidth()) |
|
.attr("height", y.bandwidth()) |
|
|
|
xlabels.attr("transform", d => `translate(${x(d) + (x.bandwidth() / 2)}, ${maxxlabelwidth + (maxxlabelheight / 2)})`) |
|
ylabels.attr("transform", d => `translate(0, ${y(d) + (y.bandwidth() / 2)})`) |
|
ytext |
|
.attr("transform", (d, i, nodes) => `translate(${maxylabelwidth - nodes[i].getComputedTextLength()}, 0)`) |
|
|
|
}) |
|
|
|
},{"d3":2}],2:[function(require,module,exports){ |
|
// https://d3js.org Version 4.10.0. Copyright 2017 Mike Bostock. |
|
(function (global, factory) { |
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : |
|
typeof define === 'function' && define.amd ? define(['exports'], factory) : |
|
(factory((global.d3 = global.d3 || {}))); |
|
}(this, (function (exports) { 'use strict'; |
|
|
|
var version = "4.10.0"; |
|
|
|
var ascending = function(a, b) { |
|
return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; |
|
}; |
|
|
|
var bisector = function(compare) { |
|
if (compare.length === 1) compare = ascendingComparator(compare); |
|
return { |
|
left: function(a, x, lo, hi) { |
|
if (lo == null) lo = 0; |
|
if (hi == null) hi = a.length; |
|
while (lo < hi) { |
|
var mid = lo + hi >>> 1; |
|
if (compare(a[mid], x) < 0) lo = mid + 1; |
|
else hi = mid; |
|
} |
|
return lo; |
|
}, |
|
right: function(a, x, lo, hi) { |
|
if (lo == null) lo = 0; |
|
if (hi == null) hi = a.length; |
|
while (lo < hi) { |
|
var mid = lo + hi >>> 1; |
|
if (compare(a[mid], x) > 0) hi = mid; |
|
else lo = mid + 1; |
|
} |
|
return lo; |
|
} |
|
}; |
|
}; |
|
|
|
function ascendingComparator(f) { |
|
return function(d, x) { |
|
return ascending(f(d), x); |
|
}; |
|
} |
|
|
|
var ascendingBisect = bisector(ascending); |
|
var bisectRight = ascendingBisect.right; |
|
var bisectLeft = ascendingBisect.left; |
|
|
|
var pairs = function(array, f) { |
|
if (f == null) f = pair; |
|
var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n); |
|
while (i < n) pairs[i] = f(p, p = array[++i]); |
|
return pairs; |
|
}; |
|
|
|
function pair(a, b) { |
|
return [a, b]; |
|
} |
|
|
|
var cross = function(values0, values1, reduce) { |
|
var n0 = values0.length, |
|
n1 = values1.length, |
|
values = new Array(n0 * n1), |
|
i0, |
|
i1, |
|
i, |
|
value0; |
|
|
|
if (reduce == null) reduce = pair; |
|
|
|
for (i0 = i = 0; i0 < n0; ++i0) { |
|
for (value0 = values0[i0], i1 = 0; i1 < n1; ++i1, ++i) { |
|
values[i] = reduce(value0, values1[i1]); |
|
} |
|
} |
|
|
|
return values; |
|
}; |
|
|
|
var descending = function(a, b) { |
|
return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; |
|
}; |
|
|
|
var number = function(x) { |
|
return x === null ? NaN : +x; |
|
}; |
|
|
|
var variance = function(values, valueof) { |
|
var n = values.length, |
|
m = 0, |
|
i = -1, |
|
mean = 0, |
|
value, |
|
delta, |
|
sum = 0; |
|
|
|
if (valueof == null) { |
|
while (++i < n) { |
|
if (!isNaN(value = number(values[i]))) { |
|
delta = value - mean; |
|
mean += delta / ++m; |
|
sum += delta * (value - mean); |
|
} |
|
} |
|
} |
|
|
|
else { |
|
while (++i < n) { |
|
if (!isNaN(value = number(valueof(values[i], i, values)))) { |
|
delta = value - mean; |
|
mean += delta / ++m; |
|
sum += delta * (value - mean); |
|
} |
|
} |
|
} |
|
|
|
if (m > 1) return sum / (m - 1); |
|
}; |
|
|
|
var deviation = function(array, f) { |
|
var v = variance(array, f); |
|
return v ? Math.sqrt(v) : v; |
|
}; |
|
|
|
var extent = function(values, valueof) { |
|
var n = values.length, |
|
i = -1, |
|
value, |
|
min, |
|
max; |
|
|
|
if (valueof == null) { |
|
while (++i < n) { // Find the first comparable value. |
|
if ((value = values[i]) != null && value >= value) { |
|
min = max = value; |
|
while (++i < n) { // Compare the remaining values. |
|
if ((value = values[i]) != null) { |
|
if (min > value) min = value; |
|
if (max < value) max = value; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
else { |
|
while (++i < n) { // Find the first comparable value. |
|
if ((value = valueof(values[i], i, values)) != null && value >= value) { |
|
min = max = value; |
|
while (++i < n) { // Compare the remaining values. |
|
if ((value = valueof(values[i], i, values)) != null) { |
|
if (min > value) min = value; |
|
if (max < value) max = value; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
return [min, max]; |
|
}; |
|
|
|
var array = Array.prototype; |
|
|
|
var slice = array.slice; |
|
var map = array.map; |
|
|
|
var constant = function(x) { |
|
return function() { |
|
return x; |
|
}; |
|
}; |
|
|
|
var identity = function(x) { |
|
return x; |
|
}; |
|
|
|
var sequence = function(start, stop, step) { |
|
start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step; |
|
|
|
var i = -1, |
|
n = Math.max(0, Math.ceil((stop - start) / step)) | 0, |
|
range = new Array(n); |
|
|
|
while (++i < n) { |
|
range[i] = start + i * step; |
|
} |
|
|
|
return range; |
|
}; |
|
|
|
var e10 = Math.sqrt(50); |
|
var e5 = Math.sqrt(10); |
|
var e2 = Math.sqrt(2); |
|
|
|
var ticks = function(start, stop, count) { |
|
var reverse = stop < start, |
|
i = -1, |
|
n, |
|
ticks, |
|
step; |
|
|
|
if (reverse) n = start, start = stop, stop = n; |
|
|
|
if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return []; |
|
|
|
if (step > 0) { |
|
start = Math.ceil(start / step); |
|
stop = Math.floor(stop / step); |
|
ticks = new Array(n = Math.ceil(stop - start + 1)); |
|
while (++i < n) ticks[i] = (start + i) * step; |
|
} else { |
|
start = Math.floor(start * step); |
|
stop = Math.ceil(stop * step); |
|
ticks = new Array(n = Math.ceil(start - stop + 1)); |
|
while (++i < n) ticks[i] = (start - i) / step; |
|
} |
|
|
|
if (reverse) ticks.reverse(); |
|
|
|
return ticks; |
|
}; |
|
|
|
function tickIncrement(start, stop, count) { |
|
var step = (stop - start) / Math.max(0, count), |
|
power = Math.floor(Math.log(step) / Math.LN10), |
|
error = step / Math.pow(10, power); |
|
return power >= 0 |
|
? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power) |
|
: -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1); |
|
} |
|
|
|
function tickStep(start, stop, count) { |
|
var step0 = Math.abs(stop - start) / Math.max(0, count), |
|
step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)), |
|
error = step0 / step1; |
|
if (error >= e10) step1 *= 10; |
|
else if (error >= e5) step1 *= 5; |
|
else if (error >= e2) step1 *= 2; |
|
return stop < start ? -step1 : step1; |
|
} |
|
|
|
var sturges = function(values) { |
|
return Math.ceil(Math.log(values.length) / Math.LN2) + 1; |
|
}; |
|
|
|
var histogram = function() { |
|
var value = identity, |
|
domain = extent, |
|
threshold = sturges; |
|
|
|
function histogram(data) { |
|
var i, |
|
n = data.length, |
|
x, |
|
values = new Array(n); |
|
|
|
for (i = 0; i < n; ++i) { |
|
values[i] = value(data[i], i, data); |
|
} |
|
|
|
var xz = domain(values), |
|
x0 = xz[0], |
|
x1 = xz[1], |
|
tz = threshold(values, x0, x1); |
|
|
|
// Convert number of thresholds into uniform thresholds. |
|
if (!Array.isArray(tz)) { |
|
tz = tickStep(x0, x1, tz); |
|
tz = sequence(Math.ceil(x0 / tz) * tz, Math.floor(x1 / tz) * tz, tz); // exclusive |
|
} |
|
|
|
// Remove any thresholds outside the domain. |
|
var m = tz.length; |
|
while (tz[0] <= x0) tz.shift(), --m; |
|
while (tz[m - 1] > x1) tz.pop(), --m; |
|
|
|
var bins = new Array(m + 1), |
|
bin; |
|
|
|
// Initialize bins. |
|
for (i = 0; i <= m; ++i) { |
|
bin = bins[i] = []; |
|
bin.x0 = i > 0 ? tz[i - 1] : x0; |
|
bin.x1 = i < m ? tz[i] : x1; |
|
} |
|
|
|
// Assign data to bins by value, ignoring any outside the domain. |
|
for (i = 0; i < n; ++i) { |
|
x = values[i]; |
|
if (x0 <= x && x <= x1) { |
|
bins[bisectRight(tz, x, 0, m)].push(data[i]); |
|
} |
|
} |
|
|
|
return bins; |
|
} |
|
|
|
histogram.value = function(_) { |
|
return arguments.length ? (value = typeof _ === "function" ? _ : constant(_), histogram) : value; |
|
}; |
|
|
|
histogram.domain = function(_) { |
|
return arguments.length ? (domain = typeof _ === "function" ? _ : constant([_[0], _[1]]), histogram) : domain; |
|
}; |
|
|
|
histogram.thresholds = function(_) { |
|
return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold; |
|
}; |
|
|
|
return histogram; |
|
}; |
|
|
|
var threshold = function(values, p, valueof) { |
|
if (valueof == null) valueof = number; |
|
if (!(n = values.length)) return; |
|
if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values); |
|
if (p >= 1) return +valueof(values[n - 1], n - 1, values); |
|
var n, |
|
i = (n - 1) * p, |
|
i0 = Math.floor(i), |
|
value0 = +valueof(values[i0], i0, values), |
|
value1 = +valueof(values[i0 + 1], i0 + 1, values); |
|
return value0 + (value1 - value0) * (i - i0); |
|
}; |
|
|
|
var freedmanDiaconis = function(values, min, max) { |
|
values = map.call(values, number).sort(ascending); |
|
return Math.ceil((max - min) / (2 * (threshold(values, 0.75) - threshold(values, 0.25)) * Math.pow(values.length, -1 / 3))); |
|
}; |
|
|
|
var scott = function(values, min, max) { |
|
return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3))); |
|
}; |
|
|
|
var max = function(values, valueof) { |
|
var n = values.length, |
|
i = -1, |
|
value, |
|
max; |
|
|
|
if (valueof == null) { |
|
while (++i < n) { // Find the first comparable value. |
|
if ((value = values[i]) != null && value >= value) { |
|
max = value; |
|
while (++i < n) { // Compare the remaining values. |
|
if ((value = values[i]) != null && value > max) { |
|
max = value; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
else { |
|
while (++i < n) { // Find the first comparable value. |
|
if ((value = valueof(values[i], i, values)) != null && value >= value) { |
|
max = value; |
|
while (++i < n) { // Compare the remaining values. |
|
if ((value = valueof(values[i], i, values)) != null && value > max) { |
|
max = value; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
return max; |
|
}; |
|
|
|
var mean = function(values, valueof) { |
|
var n = values.length, |
|
m = n, |
|
i = -1, |
|
value, |
|
sum = 0; |
|
|
|
if (valueof == null) { |
|
while (++i < n) { |
|
if (!isNaN(value = number(values[i]))) sum += value; |
|
else --m; |
|
} |
|
} |
|
|
|
else { |
|
while (++i < n) { |
|
if (!isNaN(value = number(valueof(values[i], i, values)))) sum += value; |
|
else --m; |
|
} |
|
} |
|
|
|
if (m) return sum / m; |
|
}; |
|
|
|
var median = function(values, valueof) { |
|
var n = values.length, |
|
i = -1, |
|
value, |
|
numbers = []; |
|
|
|
if (valueof == null) { |
|
while (++i < n) { |
|
if (!isNaN(value = number(values[i]))) { |
|
numbers.push(value); |
|
} |
|
} |
|
} |
|
|
|
else { |
|
while (++i < n) { |
|
if (!isNaN(value = number(valueof(values[i], i, values)))) { |
|
numbers.push(value); |
|
} |
|
} |
|
} |
|
|
|
return threshold(numbers.sort(ascending), 0.5); |
|
}; |
|
|
|
var merge = function(arrays) { |
|
var n = arrays.length, |
|
m, |
|
i = -1, |
|
j = 0, |
|
merged, |
|
array; |
|
|
|
while (++i < n) j += arrays[i].length; |
|
merged = new Array(j); |
|
|
|
while (--n >= 0) { |
|
array = arrays[n]; |
|
m = array.length; |
|
while (--m >= 0) { |
|
merged[--j] = array[m]; |
|
} |
|
} |
|
|
|
return merged; |
|
}; |
|
|
|
var min = function(values, valueof) { |
|
var n = values.length, |
|
i = -1, |
|
value, |
|
min; |
|
|
|
if (valueof == null) { |
|
while (++i < n) { // Find the first comparable value. |
|
if ((value = values[i]) != null && value >= value) { |
|
min = value; |
|
while (++i < n) { // Compare the remaining values. |
|
if ((value = values[i]) != null && min > value) { |
|
min = value; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
else { |
|
while (++i < n) { // Find the first comparable value. |
|
if ((value = valueof(values[i], i, values)) != null && value >= value) { |
|
min = value; |
|
while (++i < n) { // Compare the remaining values. |
|
if ((value = valueof(values[i], i, values)) != null && min > value) { |
|
min = value; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
return min; |
|
}; |
|
|
|
var permute = function(array, indexes) { |
|
var i = indexes.length, permutes = new Array(i); |
|
while (i--) permutes[i] = array[indexes[i]]; |
|
return permutes; |
|
}; |
|
|
|
var scan = function(values, compare) { |
|
if (!(n = values.length)) return; |
|
var n, |
|
i = 0, |
|
j = 0, |
|
xi, |
|
xj = values[j]; |
|
|
|
if (compare == null) compare = ascending; |
|
|
|
while (++i < n) { |
|
if (compare(xi = values[i], xj) < 0 || compare(xj, xj) !== 0) { |
|
xj = xi, j = i; |
|
} |
|
} |
|
|
|
if (compare(xj, xj) === 0) return j; |
|
}; |
|
|
|
var shuffle = function(array, i0, i1) { |
|
var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0), |
|
t, |
|
i; |
|
|
|
while (m) { |
|
i = Math.random() * m-- | 0; |
|
t = array[m + i0]; |
|
array[m + i0] = array[i + i0]; |
|
array[i + i0] = t; |
|
} |
|
|
|
return array; |
|
}; |
|
|
|
var sum = function(values, valueof) { |
|
var n = values.length, |
|
i = -1, |
|
value, |
|
sum = 0; |
|
|
|
if (valueof == null) { |
|
while (++i < n) { |
|
if (value = +values[i]) sum += value; // Note: zero and null are equivalent. |
|
} |
|
} |
|
|
|
else { |
|
while (++i < n) { |
|
if (value = +valueof(values[i], i, values)) sum += value; |
|
} |
|
} |
|
|
|
return sum; |
|
}; |
|
|
|
var transpose = function(matrix) { |
|
if (!(n = matrix.length)) return []; |
|
for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) { |
|
for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) { |
|
row[j] = matrix[j][i]; |
|
} |
|
} |
|
return transpose; |
|
}; |
|
|
|
function length(d) { |
|
return d.length; |
|
} |
|
|
|
var zip = function() { |
|
return transpose(arguments); |
|
}; |
|
|
|
var slice$1 = Array.prototype.slice; |
|
|
|
var identity$1 = function(x) { |
|
return x; |
|
}; |
|
|
|
var top = 1; |
|
var right = 2; |
|
var bottom = 3; |
|
var left = 4; |
|
var epsilon = 1e-6; |
|
|
|
function translateX(x) { |
|
return "translate(" + (x + 0.5) + ",0)"; |
|
} |
|
|
|
function translateY(y) { |
|
return "translate(0," + (y + 0.5) + ")"; |
|
} |
|
|
|
function number$1(scale) { |
|
return function(d) { |
|
return +scale(d); |
|
}; |
|
} |
|
|
|
function center(scale) { |
|
var offset = Math.max(0, scale.bandwidth() - 1) / 2; // Adjust for 0.5px offset. |
|
if (scale.round()) offset = Math.round(offset); |
|
return function(d) { |
|
return +scale(d) + offset; |
|
}; |
|
} |
|
|
|
function entering() { |
|
return !this.__axis; |
|
} |
|
|
|
function axis(orient, scale) { |
|
var tickArguments = [], |
|
tickValues = null, |
|
tickFormat = null, |
|
tickSizeInner = 6, |
|
tickSizeOuter = 6, |
|
tickPadding = 3, |
|
k = orient === top || orient === left ? -1 : 1, |
|
x = orient === left || orient === right ? "x" : "y", |
|
transform = orient === top || orient === bottom ? translateX : translateY; |
|
|
|
function axis(context) { |
|
var values = tickValues == null ? (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) : tickValues, |
|
format = tickFormat == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : identity$1) : tickFormat, |
|
spacing = Math.max(tickSizeInner, 0) + tickPadding, |
|
range = scale.range(), |
|
range0 = +range[0] + 0.5, |
|
range1 = +range[range.length - 1] + 0.5, |
|
position = (scale.bandwidth ? center : number$1)(scale.copy()), |
|
selection = context.selection ? context.selection() : context, |
|
path = selection.selectAll(".domain").data([null]), |
|
tick = selection.selectAll(".tick").data(values, scale).order(), |
|
tickExit = tick.exit(), |
|
tickEnter = tick.enter().append("g").attr("class", "tick"), |
|
line = tick.select("line"), |
|
text = tick.select("text"); |
|
|
|
path = path.merge(path.enter().insert("path", ".tick") |
|
.attr("class", "domain") |
|
.attr("stroke", "#000")); |
|
|
|
tick = tick.merge(tickEnter); |
|
|
|
line = line.merge(tickEnter.append("line") |
|
.attr("stroke", "#000") |
|
.attr(x + "2", k * tickSizeInner)); |
|
|
|
text = text.merge(tickEnter.append("text") |
|
.attr("fill", "#000") |
|
.attr(x, k * spacing) |
|
.attr("dy", orient === top ? "0em" : orient === bottom ? "0.71em" : "0.32em")); |
|
|
|
if (context !== selection) { |
|
path = path.transition(context); |
|
tick = tick.transition(context); |
|
line = line.transition(context); |
|
text = text.transition(context); |
|
|
|
tickExit = tickExit.transition(context) |
|
.attr("opacity", epsilon) |
|
.attr("transform", function(d) { return isFinite(d = position(d)) ? transform(d) : this.getAttribute("transform"); }); |
|
|
|
tickEnter |
|
.attr("opacity", epsilon) |
|
.attr("transform", function(d) { var p = this.parentNode.__axis; return transform(p && isFinite(p = p(d)) ? p : position(d)); }); |
|
} |
|
|
|
tickExit.remove(); |
|
|
|
path |
|
.attr("d", orient === left || orient == right |
|
? "M" + k * tickSizeOuter + "," + range0 + "H0.5V" + range1 + "H" + k * tickSizeOuter |
|
: "M" + range0 + "," + k * tickSizeOuter + "V0.5H" + range1 + "V" + k * tickSizeOuter); |
|
|
|
tick |
|
.attr("opacity", 1) |
|
.attr("transform", function(d) { return transform(position(d)); }); |
|
|
|
line |
|
.attr(x + "2", k * tickSizeInner); |
|
|
|
text |
|
.attr(x, k * spacing) |
|
.text(format); |
|
|
|
selection.filter(entering) |
|
.attr("fill", "none") |
|
.attr("font-size", 10) |
|
.attr("font-family", "sans-serif") |
|
.attr("text-anchor", orient === right ? "start" : orient === left ? "end" : "middle"); |
|
|
|
selection |
|
.each(function() { this.__axis = position; }); |
|
} |
|
|
|
axis.scale = function(_) { |
|
return arguments.length ? (scale = _, axis) : scale; |
|
}; |
|
|
|
axis.ticks = function() { |
|
return tickArguments = slice$1.call(arguments), axis; |
|
}; |
|
|
|
axis.tickArguments = function(_) { |
|
return arguments.length ? (tickArguments = _ == null ? [] : slice$1.call(_), axis) : tickArguments.slice(); |
|
}; |
|
|
|
axis.tickValues = function(_) { |
|
return arguments.length ? (tickValues = _ == null ? null : slice$1.call(_), axis) : tickValues && tickValues.slice(); |
|
}; |
|
|
|
axis.tickFormat = function(_) { |
|
return arguments.length ? (tickFormat = _, axis) : tickFormat; |
|
}; |
|
|
|
axis.tickSize = function(_) { |
|
return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis) : tickSizeInner; |
|
}; |
|
|
|
axis.tickSizeInner = function(_) { |
|
return arguments.length ? (tickSizeInner = +_, axis) : tickSizeInner; |
|
}; |
|
|
|
axis.tickSizeOuter = function(_) { |
|
return arguments.length ? (tickSizeOuter = +_, axis) : tickSizeOuter; |
|
}; |
|
|
|
axis.tickPadding = function(_) { |
|
return arguments.length ? (tickPadding = +_, axis) : tickPadding; |
|
}; |
|
|
|
return axis; |
|
} |
|
|
|
function axisTop(scale) { |
|
return axis(top, scale); |
|
} |
|
|
|
function axisRight(scale) { |
|
return axis(right, scale); |
|
} |
|
|
|
function axisBottom(scale) { |
|
return axis(bottom, scale); |
|
} |
|
|
|
function axisLeft(scale) { |
|
return axis(left, scale); |
|
} |
|
|
|
var noop = {value: function() {}}; |
|
|
|
function dispatch() { |
|
for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) { |
|
if (!(t = arguments[i] + "") || (t in _)) throw new Error("illegal type: " + t); |
|
_[t] = []; |
|
} |
|
return new Dispatch(_); |
|
} |
|
|
|
function Dispatch(_) { |
|
this._ = _; |
|
} |
|
|
|
function parseTypenames(typenames, types) { |
|
return typenames.trim().split(/^|\s+/).map(function(t) { |
|
var name = "", i = t.indexOf("."); |
|
if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i); |
|
if (t && !types.hasOwnProperty(t)) throw new Error("unknown type: " + t); |
|
return {type: t, name: name}; |
|
}); |
|
} |
|
|
|
Dispatch.prototype = dispatch.prototype = { |
|
constructor: Dispatch, |
|
on: function(typename, callback) { |
|
var _ = this._, |
|
T = parseTypenames(typename + "", _), |
|
t, |
|
i = -1, |
|
n = T.length; |
|
|
|
// If no callback was specified, return the callback of the given type and name. |
|
if (arguments.length < 2) { |
|
while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t; |
|
return; |
|
} |
|
|
|
// If a type was specified, set the callback for the given type and name. |
|
// Otherwise, if a null callback was specified, remove callbacks of the given name. |
|
if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback); |
|
while (++i < n) { |
|
if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback); |
|
else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null); |
|
} |
|
|
|
return this; |
|
}, |
|
copy: function() { |
|
var copy = {}, _ = this._; |
|
for (var t in _) copy[t] = _[t].slice(); |
|
return new Dispatch(copy); |
|
}, |
|
call: function(type, that) { |
|
if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2]; |
|
if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type); |
|
for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args); |
|
}, |
|
apply: function(type, that, args) { |
|
if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type); |
|
for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args); |
|
} |
|
}; |
|
|
|
function get(type, name) { |
|
for (var i = 0, n = type.length, c; i < n; ++i) { |
|
if ((c = type[i]).name === name) { |
|
return c.value; |
|
} |
|
} |
|
} |
|
|
|
function set(type, name, callback) { |
|
for (var i = 0, n = type.length; i < n; ++i) { |
|
if (type[i].name === name) { |
|
type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1)); |
|
break; |
|
} |
|
} |
|
if (callback != null) type.push({name: name, value: callback}); |
|
return type; |
|
} |
|
|
|
var xhtml = "http://www.w3.org/1999/xhtml"; |
|
|
|
var namespaces = { |
|
svg: "http://www.w3.org/2000/svg", |
|
xhtml: xhtml, |
|
xlink: "http://www.w3.org/1999/xlink", |
|
xml: "http://www.w3.org/XML/1998/namespace", |
|
xmlns: "http://www.w3.org/2000/xmlns/" |
|
}; |
|
|
|
var namespace = function(name) { |
|
var prefix = name += "", i = prefix.indexOf(":"); |
|
if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1); |
|
return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name; |
|
}; |
|
|
|
function creatorInherit(name) { |
|
return function() { |
|
var document = this.ownerDocument, |
|
uri = this.namespaceURI; |
|
return uri === xhtml && document.documentElement.namespaceURI === xhtml |
|
? document.createElement(name) |
|
: document.createElementNS(uri, name); |
|
}; |
|
} |
|
|
|
function creatorFixed(fullname) { |
|
return function() { |
|
return this.ownerDocument.createElementNS(fullname.space, fullname.local); |
|
}; |
|
} |
|
|
|
var creator = function(name) { |
|
var fullname = namespace(name); |
|
return (fullname.local |
|
? creatorFixed |
|
: creatorInherit)(fullname); |
|
}; |
|
|
|
var nextId = 0; |
|
|
|
function local$1() { |
|
return new Local; |
|
} |
|
|
|
function Local() { |
|
this._ = "@" + (++nextId).toString(36); |
|
} |
|
|
|
Local.prototype = local$1.prototype = { |
|
constructor: Local, |
|
get: function(node) { |
|
var id = this._; |
|
while (!(id in node)) if (!(node = node.parentNode)) return; |
|
return node[id]; |
|
}, |
|
set: function(node, value) { |
|
return node[this._] = value; |
|
}, |
|
remove: function(node) { |
|
return this._ in node && delete node[this._]; |
|
}, |
|
toString: function() { |
|
return this._; |
|
} |
|
}; |
|
|
|
var matcher = function(selector) { |
|
return function() { |
|
return this.matches(selector); |
|
}; |
|
}; |
|
|
|
if (typeof document !== "undefined") { |
|
var element = document.documentElement; |
|
if (!element.matches) { |
|
var vendorMatches = element.webkitMatchesSelector |
|
|| element.msMatchesSelector |
|
|| element.mozMatchesSelector |
|
|| element.oMatchesSelector; |
|
matcher = function(selector) { |
|
return function() { |
|
return vendorMatches.call(this, selector); |
|
}; |
|
}; |
|
} |
|
} |
|
|
|
var matcher$1 = matcher; |
|
|
|
var filterEvents = {}; |
|
|
|
exports.event = null; |
|
|
|
if (typeof document !== "undefined") { |
|
var element$1 = document.documentElement; |
|
if (!("onmouseenter" in element$1)) { |
|
filterEvents = {mouseenter: "mouseover", mouseleave: "mouseout"}; |
|
} |
|
} |
|
|
|
function filterContextListener(listener, index, group) { |
|
listener = contextListener(listener, index, group); |
|
return function(event) { |
|
var related = event.relatedTarget; |
|
if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) { |
|
listener.call(this, event); |
|
} |
|
}; |
|
} |
|
|
|
function contextListener(listener, index, group) { |
|
return function(event1) { |
|
var event0 = exports.event; // Events can be reentrant (e.g., focus). |
|
exports.event = event1; |
|
try { |
|
listener.call(this, this.__data__, index, group); |
|
} finally { |
|
exports.event = event0; |
|
} |
|
}; |
|
} |
|
|
|
function parseTypenames$1(typenames) { |
|
return typenames.trim().split(/^|\s+/).map(function(t) { |
|
var name = "", i = t.indexOf("."); |
|
if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i); |
|
return {type: t, name: name}; |
|
}); |
|
} |
|
|
|
function onRemove(typename) { |
|
return function() { |
|
var on = this.__on; |
|
if (!on) return; |
|
for (var j = 0, i = -1, m = on.length, o; j < m; ++j) { |
|
if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) { |
|
this.removeEventListener(o.type, o.listener, o.capture); |
|
} else { |
|
on[++i] = o; |
|
} |
|
} |
|
if (++i) on.length = i; |
|
else delete this.__on; |
|
}; |
|
} |
|
|
|
function onAdd(typename, value, capture) { |
|
var wrap = filterEvents.hasOwnProperty(typename.type) ? filterContextListener : contextListener; |
|
return function(d, i, group) { |
|
var on = this.__on, o, listener = wrap(value, i, group); |
|
if (on) for (var j = 0, m = on.length; j < m; ++j) { |
|
if ((o = on[j]).type === typename.type && o.name === typename.name) { |
|
this.removeEventListener(o.type, o.listener, o.capture); |
|
this.addEventListener(o.type, o.listener = listener, o.capture = capture); |
|
o.value = value; |
|
return; |
|
} |
|
} |
|
this.addEventListener(typename.type, listener, capture); |
|
o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture}; |
|
if (!on) this.__on = [o]; |
|
else on.push(o); |
|
}; |
|
} |
|
|
|
var selection_on = function(typename, value, capture) { |
|
var typenames = parseTypenames$1(typename + ""), i, n = typenames.length, t; |
|
|
|
if (arguments.length < 2) { |
|
var on = this.node().__on; |
|
if (on) for (var j = 0, m = on.length, o; j < m; ++j) { |
|
for (i = 0, o = on[j]; i < n; ++i) { |
|
if ((t = typenames[i]).type === o.type && t.name === o.name) { |
|
return o.value; |
|
} |
|
} |
|
} |
|
return; |
|
} |
|
|
|
on = value ? onAdd : onRemove; |
|
if (capture == null) capture = false; |
|
for (i = 0; i < n; ++i) this.each(on(typenames[i], value, capture)); |
|
return this; |
|
}; |
|
|
|
function customEvent(event1, listener, that, args) { |
|
var event0 = exports.event; |
|
event1.sourceEvent = exports.event; |
|
exports.event = event1; |
|
try { |
|
return listener.apply(that, args); |
|
} finally { |
|
exports.event = event0; |
|
} |
|
} |
|
|
|
var sourceEvent = function() { |
|
var current = exports.event, source; |
|
while (source = current.sourceEvent) current = source; |
|
return current; |
|
}; |
|
|
|
var point = function(node, event) { |
|
var svg = node.ownerSVGElement || node; |
|
|
|
if (svg.createSVGPoint) { |
|
var point = svg.createSVGPoint(); |
|
point.x = event.clientX, point.y = event.clientY; |
|
point = point.matrixTransform(node.getScreenCTM().inverse()); |
|
return [point.x, point.y]; |
|
} |
|
|
|
var rect = node.getBoundingClientRect(); |
|
return [event.clientX - rect.left - node.clientLeft, event.clientY - rect.top - node.clientTop]; |
|
}; |
|
|
|
var mouse = function(node) { |
|
var event = sourceEvent(); |
|
if (event.changedTouches) event = event.changedTouches[0]; |
|
return point(node, event); |
|
}; |
|
|
|
function none() {} |
|
|
|
var selector = function(selector) { |
|
return selector == null ? none : function() { |
|
return this.querySelector(selector); |
|
}; |
|
}; |
|
|
|
var selection_select = function(select) { |
|
if (typeof select !== "function") select = selector(select); |
|
|
|
for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { |
|
for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) { |
|
if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) { |
|
if ("__data__" in node) subnode.__data__ = node.__data__; |
|
subgroup[i] = subnode; |
|
} |
|
} |
|
} |
|
|
|
return new Selection(subgroups, this._parents); |
|
}; |
|
|
|
function empty$1() { |
|
return []; |
|
} |
|
|
|
var selectorAll = function(selector) { |
|
return selector == null ? empty$1 : function() { |
|
return this.querySelectorAll(selector); |
|
}; |
|
}; |
|
|
|
var selection_selectAll = function(select) { |
|
if (typeof select !== "function") select = selectorAll(select); |
|
|
|
for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) { |
|
for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { |
|
if (node = group[i]) { |
|
subgroups.push(select.call(node, node.__data__, i, group)); |
|
parents.push(node); |
|
} |
|
} |
|
} |
|
|
|
return new Selection(subgroups, parents); |
|
}; |
|
|
|
var selection_filter = function(match) { |
|
if (typeof match !== "function") match = matcher$1(match); |
|
|
|
for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { |
|
for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) { |
|
if ((node = group[i]) && match.call(node, node.__data__, i, group)) { |
|
subgroup.push(node); |
|
} |
|
} |
|
} |
|
|
|
return new Selection(subgroups, this._parents); |
|
}; |
|
|
|
var sparse = function(update) { |
|
return new Array(update.length); |
|
}; |
|
|
|
var selection_enter = function() { |
|
return new Selection(this._enter || this._groups.map(sparse), this._parents); |
|
}; |
|
|
|
function EnterNode(parent, datum) { |
|
this.ownerDocument = parent.ownerDocument; |
|
this.namespaceURI = parent.namespaceURI; |
|
this._next = null; |
|
this._parent = parent; |
|
this.__data__ = datum; |
|
} |
|
|
|
EnterNode.prototype = { |
|
constructor: EnterNode, |
|
appendChild: function(child) { return this._parent.insertBefore(child, this._next); }, |
|
insertBefore: function(child, next) { return this._parent.insertBefore(child, next); }, |
|
querySelector: function(selector) { return this._parent.querySelector(selector); }, |
|
querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); } |
|
}; |
|
|
|
var constant$1 = function(x) { |
|
return function() { |
|
return x; |
|
}; |
|
}; |
|
|
|
var keyPrefix = "$"; // Protect against keys like “__proto__”. |
|
|
|
function bindIndex(parent, group, enter, update, exit, data) { |
|
var i = 0, |
|
node, |
|
groupLength = group.length, |
|
dataLength = data.length; |
|
|
|
// Put any non-null nodes that fit into update. |
|
// Put any null nodes into enter. |
|
// Put any remaining data into enter. |
|
for (; i < dataLength; ++i) { |
|
if (node = group[i]) { |
|
node.__data__ = data[i]; |
|
update[i] = node; |
|
} else { |
|
enter[i] = new EnterNode(parent, data[i]); |
|
} |
|
} |
|
|
|
// Put any non-null nodes that don’t fit into exit. |
|
for (; i < groupLength; ++i) { |
|
if (node = group[i]) { |
|
exit[i] = node; |
|
} |
|
} |
|
} |
|
|
|
function bindKey(parent, group, enter, update, exit, data, key) { |
|
var i, |
|
node, |
|
nodeByKeyValue = {}, |
|
groupLength = group.length, |
|
dataLength = data.length, |
|
keyValues = new Array(groupLength), |
|
keyValue; |
|
|
|
// Compute the key for each node. |
|
// If multiple nodes have the same key, the duplicates are added to exit. |
|
for (i = 0; i < groupLength; ++i) { |
|
if (node = group[i]) { |
|
keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group); |
|
if (keyValue in nodeByKeyValue) { |
|
exit[i] = node; |
|
} else { |
|
nodeByKeyValue[keyValue] = node; |
|
} |
|
} |
|
} |
|
|
|
// Compute the key for each datum. |
|
// If there a node associated with this key, join and add it to update. |
|
// If there is not (or the key is a duplicate), add it to enter. |
|
for (i = 0; i < dataLength; ++i) { |
|
keyValue = keyPrefix + key.call(parent, data[i], i, data); |
|
if (node = nodeByKeyValue[keyValue]) { |
|
update[i] = node; |
|
node.__data__ = data[i]; |
|
nodeByKeyValue[keyValue] = null; |
|
} else { |
|
enter[i] = new EnterNode(parent, data[i]); |
|
} |
|
} |
|
|
|
// Add any remaining nodes that were not bound to data to exit. |
|
for (i = 0; i < groupLength; ++i) { |
|
if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) { |
|
exit[i] = node; |
|
} |
|
} |
|
} |
|
|
|
var selection_data = function(value, key) { |
|
if (!value) { |
|
data = new Array(this.size()), j = -1; |
|
this.each(function(d) { data[++j] = d; }); |
|
return data; |
|
} |
|
|
|
var bind = key ? bindKey : bindIndex, |
|
parents = this._parents, |
|
groups = this._groups; |
|
|
|
if (typeof value !== "function") value = constant$1(value); |
|
|
|
for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) { |
|
var parent = parents[j], |
|
group = groups[j], |
|
groupLength = group.length, |
|
data = value.call(parent, parent && parent.__data__, j, parents), |
|
dataLength = data.length, |
|
enterGroup = enter[j] = new Array(dataLength), |
|
updateGroup = update[j] = new Array(dataLength), |
|
exitGroup = exit[j] = new Array(groupLength); |
|
|
|
bind(parent, group, enterGroup, updateGroup, exitGroup, data, key); |
|
|
|
// Now connect the enter nodes to their following update node, such that |
|
// appendChild can insert the materialized enter node before this node, |
|
// rather than at the end of the parent node. |
|
for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) { |
|
if (previous = enterGroup[i0]) { |
|
if (i0 >= i1) i1 = i0 + 1; |
|
while (!(next = updateGroup[i1]) && ++i1 < dataLength); |
|
previous._next = next || null; |
|
} |
|
} |
|
} |
|
|
|
update = new Selection(update, parents); |
|
update._enter = enter; |
|
update._exit = exit; |
|
return update; |
|
}; |
|
|
|
var selection_exit = function() { |
|
return new Selection(this._exit || this._groups.map(sparse), this._parents); |
|
}; |
|
|
|
var selection_merge = function(selection$$1) { |
|
|
|
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) { |
|
for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) { |
|
if (node = group0[i] || group1[i]) { |
|
merge[i] = node; |
|
} |
|
} |
|
} |
|
|
|
for (; j < m0; ++j) { |
|
merges[j] = groups0[j]; |
|
} |
|
|
|
return new Selection(merges, this._parents); |
|
}; |
|
|
|
var selection_order = function() { |
|
|
|
for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) { |
|
for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) { |
|
if (node = group[i]) { |
|
if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next); |
|
next = node; |
|
} |
|
} |
|
} |
|
|
|
return this; |
|
}; |
|
|
|
var selection_sort = function(compare) { |
|
if (!compare) compare = ascending$1; |
|
|
|
function compareNode(a, b) { |
|
return a && b ? compare(a.__data__, b.__data__) : !a - !b; |
|
} |
|
|
|
for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) { |
|
for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) { |
|
if (node = group[i]) { |
|
sortgroup[i] = node; |
|
} |
|
} |
|
sortgroup.sort(compareNode); |
|
} |
|
|
|
return new Selection(sortgroups, this._parents).order(); |
|
}; |
|
|
|
function ascending$1(a, b) { |
|
return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; |
|
} |
|
|
|
var selection_call = function() { |
|
var callback = arguments[0]; |
|
arguments[0] = this; |
|
callback.apply(null, arguments); |
|
return this; |
|
}; |
|
|
|
var selection_nodes = function() { |
|
var nodes = new Array(this.size()), i = -1; |
|
this.each(function() { nodes[++i] = this; }); |
|
return nodes; |
|
}; |
|
|
|
var selection_node = function() { |
|
|
|
for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { |
|
for (var group = groups[j], i = 0, n = group.length; i < n; ++i) { |
|
var node = group[i]; |
|
if (node) return node; |
|
} |
|
} |
|
|
|
return null; |
|
}; |
|
|
|
var selection_size = function() { |
|
var size = 0; |
|
this.each(function() { ++size; }); |
|
return size; |
|
}; |
|
|
|
var selection_empty = function() { |
|
return !this.node(); |
|
}; |
|
|
|
var selection_each = function(callback) { |
|
|
|
for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { |
|
for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) { |
|
if (node = group[i]) callback.call(node, node.__data__, i, group); |
|
} |
|
} |
|
|
|
return this; |
|
}; |
|
|
|
function attrRemove(name) { |
|
return function() { |
|
this.removeAttribute(name); |
|
}; |
|
} |
|
|
|
function attrRemoveNS(fullname) { |
|
return function() { |
|
this.removeAttributeNS(fullname.space, fullname.local); |
|
}; |
|
} |
|
|
|
function attrConstant(name, value) { |
|
return function() { |
|
this.setAttribute(name, value); |
|
}; |
|
} |
|
|
|
function attrConstantNS(fullname, value) { |
|
return function() { |
|
this.setAttributeNS(fullname.space, fullname.local, value); |
|
}; |
|
} |
|
|
|
function attrFunction(name, value) { |
|
return function() { |
|
var v = value.apply(this, arguments); |
|
if (v == null) this.removeAttribute(name); |
|
else this.setAttribute(name, v); |
|
}; |
|
} |
|
|
|
function attrFunctionNS(fullname, value) { |
|
return function() { |
|
var v = value.apply(this, arguments); |
|
if (v == null) this.removeAttributeNS(fullname.space, fullname.local); |
|
else this.setAttributeNS(fullname.space, fullname.local, v); |
|
}; |
|
} |
|
|
|
var selection_attr = function(name, value) { |
|
var fullname = namespace(name); |
|
|
|
if (arguments.length < 2) { |
|
var node = this.node(); |
|
return fullname.local |
|
? node.getAttributeNS(fullname.space, fullname.local) |
|
: node.getAttribute(fullname); |
|
} |
|
|
|
return this.each((value == null |
|
? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === "function" |
|
? (fullname.local ? attrFunctionNS : attrFunction) |
|
: (fullname.local ? attrConstantNS : attrConstant)))(fullname, value)); |
|
}; |
|
|
|
var defaultView = function(node) { |
|
return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node |
|
|| (node.document && node) // node is a Window |
|
|| node.defaultView; // node is a Document |
|
}; |
|
|
|
function styleRemove(name) { |
|
return function() { |
|
this.style.removeProperty(name); |
|
}; |
|
} |
|
|
|
function styleConstant(name, value, priority) { |
|
return function() { |
|
this.style.setProperty(name, value, priority); |
|
}; |
|
} |
|
|
|
function styleFunction(name, value, priority) { |
|
return function() { |
|
var v = value.apply(this, arguments); |
|
if (v == null) this.style.removeProperty(name); |
|
else this.style.setProperty(name, v, priority); |
|
}; |
|
} |
|
|
|
var selection_style = function(name, value, priority) { |
|
return arguments.length > 1 |
|
? this.each((value == null |
|
? styleRemove : typeof value === "function" |
|
? styleFunction |
|
: styleConstant)(name, value, priority == null ? "" : priority)) |
|
: styleValue(this.node(), name); |
|
}; |
|
|
|
function styleValue(node, name) { |
|
return node.style.getPropertyValue(name) |
|
|| defaultView(node).getComputedStyle(node, null).getPropertyValue(name); |
|
} |
|
|
|
function propertyRemove(name) { |
|
return function() { |
|
delete this[name]; |
|
}; |
|
} |
|
|
|
function propertyConstant(name, value) { |
|
return function() { |
|
this[name] = value; |
|
}; |
|
} |
|
|
|
function propertyFunction(name, value) { |
|
return function() { |
|
var v = value.apply(this, arguments); |
|
if (v == null) delete this[name]; |
|
else this[name] = v; |
|
}; |
|
} |
|
|
|
var selection_property = function(name, value) { |
|
return arguments.length > 1 |
|
? this.each((value == null |
|
? propertyRemove : typeof value === "function" |
|
? propertyFunction |
|
: propertyConstant)(name, value)) |
|
: this.node()[name]; |
|
}; |
|
|
|
function classArray(string) { |
|
return string.trim().split(/^|\s+/); |
|
} |
|
|
|
function classList(node) { |
|
return node.classList || new ClassList(node); |
|
} |
|
|
|
function ClassList(node) { |
|
this._node = node; |
|
this._names = classArray(node.getAttribute("class") || ""); |
|
} |
|
|
|
ClassList.prototype = { |
|
add: function(name) { |
|
var i = this._names.indexOf(name); |
|
if (i < 0) { |
|
this._names.push(name); |
|
this._node.setAttribute("class", this._names.join(" ")); |
|
} |
|
}, |
|
remove: function(name) { |
|
var i = this._names.indexOf(name); |
|
if (i >= 0) { |
|
this._names.splice(i, 1); |
|
this._node.setAttribute("class", this._names.join(" ")); |
|
} |
|
}, |
|
contains: function(name) { |
|
return this._names.indexOf(name) >= 0; |
|
} |
|
}; |
|
|
|
function classedAdd(node, names) { |
|
var list = classList(node), i = -1, n = names.length; |
|
while (++i < n) list.add(names[i]); |
|
} |
|
|
|
function classedRemove(node, names) { |
|
var list = classList(node), i = -1, n = names.length; |
|
while (++i < n) list.remove(names[i]); |
|
} |
|
|
|
function classedTrue(names) { |
|
return function() { |
|
classedAdd(this, names); |
|
}; |
|
} |
|
|
|
function classedFalse(names) { |
|
return function() { |
|
classedRemove(this, names); |
|
}; |
|
} |
|
|
|
function classedFunction(names, value) { |
|
return function() { |
|
(value.apply(this, arguments) ? classedAdd : classedRemove)(this, names); |
|
}; |
|
} |
|
|
|
var selection_classed = function(name, value) { |
|
var names = classArray(name + ""); |
|
|
|
if (arguments.length < 2) { |
|
var list = classList(this.node()), i = -1, n = names.length; |
|
while (++i < n) if (!list.contains(names[i])) return false; |
|
return true; |
|
} |
|
|
|
return this.each((typeof value === "function" |
|
? classedFunction : value |
|
? classedTrue |
|
: classedFalse)(names, value)); |
|
}; |
|
|
|
function textRemove() { |
|
this.textContent = ""; |
|
} |
|
|
|
function textConstant(value) { |
|
return function() { |
|
this.textContent = value; |
|
}; |
|
} |
|
|
|
function textFunction(value) { |
|
return function() { |
|
var v = value.apply(this, arguments); |
|
this.textContent = v == null ? "" : v; |
|
}; |
|
} |
|
|
|
var selection_text = function(value) { |
|
return arguments.length |
|
? this.each(value == null |
|
? textRemove : (typeof value === "function" |
|
? textFunction |
|
: textConstant)(value)) |
|
: this.node().textContent; |
|
}; |
|
|
|
function htmlRemove() { |
|
this.innerHTML = ""; |
|
} |
|
|
|
function htmlConstant(value) { |
|
return function() { |
|
this.innerHTML = value; |
|
}; |
|
} |
|
|
|
function htmlFunction(value) { |
|
return function() { |
|
var v = value.apply(this, arguments); |
|
this.innerHTML = v == null ? "" : v; |
|
}; |
|
} |
|
|
|
var selection_html = function(value) { |
|
return arguments.length |
|
? this.each(value == null |
|
? htmlRemove : (typeof value === "function" |
|
? htmlFunction |
|
: htmlConstant)(value)) |
|
: this.node().innerHTML; |
|
}; |
|
|
|
function raise() { |
|
if (this.nextSibling) this.parentNode.appendChild(this); |
|
} |
|
|
|
var selection_raise = function() { |
|
return this.each(raise); |
|
}; |
|
|
|
function lower() { |
|
if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild); |
|
} |
|
|
|
var selection_lower = function() { |
|
return this.each(lower); |
|
}; |
|
|
|
var selection_append = function(name) { |
|
var create = typeof name === "function" ? name : creator(name); |
|
return this.select(function() { |
|
return this.appendChild(create.apply(this, arguments)); |
|
}); |
|
}; |
|
|
|
function constantNull() { |
|
return null; |
|
} |
|
|
|
var selection_insert = function(name, before) { |
|
var create = typeof name === "function" ? name : creator(name), |
|
select = before == null ? constantNull : typeof before === "function" ? before : selector(before); |
|
return this.select(function() { |
|
return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null); |
|
}); |
|
}; |
|
|
|
function remove() { |
|
var parent = this.parentNode; |
|
if (parent) parent.removeChild(this); |
|
} |
|
|
|
var selection_remove = function() { |
|
return this.each(remove); |
|
}; |
|
|
|
var selection_datum = function(value) { |
|
return arguments.length |
|
? this.property("__data__", value) |
|
: this.node().__data__; |
|
}; |
|
|
|
function dispatchEvent(node, type, params) { |
|
var window = defaultView(node), |
|
event = window.CustomEvent; |
|
|
|
if (typeof event === "function") { |
|
event = new event(type, params); |
|
} else { |
|
event = window.document.createEvent("Event"); |
|
if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail; |
|
else event.initEvent(type, false, false); |
|
} |
|
|
|
node.dispatchEvent(event); |
|
} |
|
|
|
function dispatchConstant(type, params) { |
|
return function() { |
|
return dispatchEvent(this, type, params); |
|
}; |
|
} |
|
|
|
function dispatchFunction(type, params) { |
|
return function() { |
|
return dispatchEvent(this, type, params.apply(this, arguments)); |
|
}; |
|
} |
|
|
|
var selection_dispatch = function(type, params) { |
|
return this.each((typeof params === "function" |
|
? dispatchFunction |
|
: dispatchConstant)(type, params)); |
|
}; |
|
|
|
var root = [null]; |
|
|
|
function Selection(groups, parents) { |
|
this._groups = groups; |
|
this._parents = parents; |
|
} |
|
|
|
function selection() { |
|
return new Selection([[document.documentElement]], root); |
|
} |
|
|
|
Selection.prototype = selection.prototype = { |
|
constructor: Selection, |
|
select: selection_select, |
|
selectAll: selection_selectAll, |
|
filter: selection_filter, |
|
data: selection_data, |
|
enter: selection_enter, |
|
exit: selection_exit, |
|
merge: selection_merge, |
|
order: selection_order, |
|
sort: selection_sort, |
|
call: selection_call, |
|
nodes: selection_nodes, |
|
node: selection_node, |
|
size: selection_size, |
|
empty: selection_empty, |
|
each: selection_each, |
|
attr: selection_attr, |
|
style: selection_style, |
|
property: selection_property, |
|
classed: selection_classed, |
|
text: selection_text, |
|
html: selection_html, |
|
raise: selection_raise, |
|
lower: selection_lower, |
|
append: selection_append, |
|
insert: selection_insert, |
|
remove: selection_remove, |
|
datum: selection_datum, |
|
on: selection_on, |
|
dispatch: selection_dispatch |
|
}; |
|
|
|
var select = function(selector) { |
|
return typeof selector === "string" |
|
? new Selection([[document.querySelector(selector)]], [document.documentElement]) |
|
: new Selection([[selector]], root); |
|
}; |
|
|
|
var selectAll = function(selector) { |
|
return typeof selector === "string" |
|
? new Selection([document.querySelectorAll(selector)], [document.documentElement]) |
|
: new Selection([selector == null ? [] : selector], root); |
|
}; |
|
|
|
var touch = function(node, touches, identifier) { |
|
if (arguments.length < 3) identifier = touches, touches = sourceEvent().changedTouches; |
|
|
|
for (var i = 0, n = touches ? touches.length : 0, touch; i < n; ++i) { |
|
if ((touch = touches[i]).identifier === identifier) { |
|
return point(node, touch); |
|
} |
|
} |
|
|
|
return null; |
|
}; |
|
|
|
var touches = function(node, touches) { |
|
if (touches == null) touches = sourceEvent().touches; |
|
|
|
for (var i = 0, n = touches ? touches.length : 0, points = new Array(n); i < n; ++i) { |
|
points[i] = point(node, touches[i]); |
|
} |
|
|
|
return points; |
|
}; |
|
|
|
function nopropagation() { |
|
exports.event.stopImmediatePropagation(); |
|
} |
|
|
|
var noevent = function() { |
|
exports.event.preventDefault(); |
|
exports.event.stopImmediatePropagation(); |
|
}; |
|
|
|
var dragDisable = function(view) { |
|
var root = view.document.documentElement, |
|
selection$$1 = select(view).on("dragstart.drag", noevent, true); |
|
if ("onselectstart" in root) { |
|
selection$$1.on("selectstart.drag", noevent, true); |
|
} else { |
|
root.__noselect = root.style.MozUserSelect; |
|
root.style.MozUserSelect = "none"; |
|
} |
|
}; |
|
|
|
function yesdrag(view, noclick) { |
|
var root = view.document.documentElement, |
|
selection$$1 = select(view).on("dragstart.drag", null); |
|
if (noclick) { |
|
selection$$1.on("click.drag", noevent, true); |
|
setTimeout(function() { selection$$1.on("click.drag", null); }, 0); |
|
} |
|
if ("onselectstart" in root) { |
|
selection$$1.on("selectstart.drag", null); |
|
} else { |
|
root.style.MozUserSelect = root.__noselect; |
|
delete root.__noselect; |
|
} |
|
} |
|
|
|
var constant$2 = function(x) { |
|
return function() { |
|
return x; |
|
}; |
|
}; |
|
|
|
function DragEvent(target, type, subject, id, active, x, y, dx, dy, dispatch) { |
|
this.target = target; |
|
this.type = type; |
|
this.subject = subject; |
|
this.identifier = id; |
|
this.active = active; |
|
this.x = x; |
|
this.y = y; |
|
this.dx = dx; |
|
this.dy = dy; |
|
this._ = dispatch; |
|
} |
|
|
|
DragEvent.prototype.on = function() { |
|
var value = this._.on.apply(this._, arguments); |
|
return value === this._ ? this : value; |
|
}; |
|
|
|
// Ignore right-click, since that should open the context menu. |
|
function defaultFilter$1() { |
|
return !exports.event.button; |
|
} |
|
|
|
function defaultContainer() { |
|
return this.parentNode; |
|
} |
|
|
|
function defaultSubject(d) { |
|
return d == null ? {x: exports.event.x, y: exports.event.y} : d; |
|
} |
|
|
|
function touchable() { |
|
return "ontouchstart" in this; |
|
} |
|
|
|
var drag = function() { |
|
var filter = defaultFilter$1, |
|
container = defaultContainer, |
|
subject = defaultSubject, |
|
gestures = {}, |
|
listeners = dispatch("start", "drag", "end"), |
|
active = 0, |
|
mousedownx, |
|
mousedowny, |
|
mousemoving, |
|
touchending, |
|
clickDistance2 = 0; |
|
|
|
function drag(selection) { |
|
selection |
|
.on("mousedown.drag", mousedowned) |
|
.filter(touchable) |
|
.on("touchstart.drag", touchstarted) |
|
.on("touchmove.drag", touchmoved) |
|
.on("touchend.drag touchcancel.drag", touchended) |
|
.style("touch-action", "none") |
|
.style("-webkit-tap-highlight-color", "rgba(0,0,0,0)"); |
|
} |
|
|
|
function mousedowned() { |
|
if (touchending || !filter.apply(this, arguments)) return; |
|
var gesture = beforestart("mouse", container.apply(this, arguments), mouse, this, arguments); |
|
if (!gesture) return; |
|
select(exports.event.view).on("mousemove.drag", mousemoved, true).on("mouseup.drag", mouseupped, true); |
|
dragDisable(exports.event.view); |
|
nopropagation(); |
|
mousemoving = false; |
|
mousedownx = exports.event.clientX; |
|
mousedowny = exports.event.clientY; |
|
gesture("start"); |
|
} |
|
|
|
function mousemoved() { |
|
noevent(); |
|
if (!mousemoving) { |
|
var dx = exports.event.clientX - mousedownx, dy = exports.event.clientY - mousedowny; |
|
mousemoving = dx * dx + dy * dy > clickDistance2; |
|
} |
|
gestures.mouse("drag"); |
|
} |
|
|
|
function mouseupped() { |
|
select(exports.event.view).on("mousemove.drag mouseup.drag", null); |
|
yesdrag(exports.event.view, mousemoving); |
|
noevent(); |
|
gestures.mouse("end"); |
|
} |
|
|
|
function touchstarted() { |
|
if (!filter.apply(this, arguments)) return; |
|
var touches$$1 = exports.event.changedTouches, |
|
c = container.apply(this, arguments), |
|
n = touches$$1.length, i, gesture; |
|
|
|
for (i = 0; i < n; ++i) { |
|
if (gesture = beforestart(touches$$1[i].identifier, c, touch, this, arguments)) { |
|
nopropagation(); |
|
gesture("start"); |
|
} |
|
} |
|
} |
|
|
|
function touchmoved() { |
|
var touches$$1 = exports.event.changedTouches, |
|
n = touches$$1.length, i, gesture; |
|
|
|
for (i = 0; i < n; ++i) { |
|
if (gesture = gestures[touches$$1[i].identifier]) { |
|
noevent(); |
|
gesture("drag"); |
|
} |
|
} |
|
} |
|
|
|
function touchended() { |
|
var touches$$1 = exports.event.changedTouches, |
|
n = touches$$1.length, i, gesture; |
|
|
|
if (touchending) clearTimeout(touchending); |
|
touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed! |
|
for (i = 0; i < n; ++i) { |
|
if (gesture = gestures[touches$$1[i].identifier]) { |
|
nopropagation(); |
|
gesture("end"); |
|
} |
|
} |
|
} |
|
|
|
function beforestart(id, container, point, that, args) { |
|
var p = point(container, id), s, dx, dy, |
|
sublisteners = listeners.copy(); |
|
|
|
if (!customEvent(new DragEvent(drag, "beforestart", s, id, active, p[0], p[1], 0, 0, sublisteners), function() { |
|
if ((exports.event.subject = s = subject.apply(that, args)) == null) return false; |
|
dx = s.x - p[0] || 0; |
|
dy = s.y - p[1] || 0; |
|
return true; |
|
})) return; |
|
|
|
return function gesture(type) { |
|
var p0 = p, n; |
|
switch (type) { |
|
case "start": gestures[id] = gesture, n = active++; break; |
|
case "end": delete gestures[id], --active; // nobreak |
|
case "drag": p = point(container, id), n = active; break; |
|
} |
|
customEvent(new DragEvent(drag, type, s, id, n, p[0] + dx, p[1] + dy, p[0] - p0[0], p[1] - p0[1], sublisteners), sublisteners.apply, sublisteners, [type, that, args]); |
|
}; |
|
} |
|
|
|
drag.filter = function(_) { |
|
return arguments.length ? (filter = typeof _ === "function" ? _ : constant$2(!!_), drag) : filter; |
|
}; |
|
|
|
drag.container = function(_) { |
|
return arguments.length ? (container = typeof _ === "function" ? _ : constant$2(_), drag) : container; |
|
}; |
|
|
|
drag.subject = function(_) { |
|
return arguments.length ? (subject = typeof _ === "function" ? _ : constant$2(_), drag) : subject; |
|
}; |
|
|
|
drag.on = function() { |
|
var value = listeners.on.apply(listeners, arguments); |
|
return value === listeners ? drag : value; |
|
}; |
|
|
|
drag.clickDistance = function(_) { |
|
return arguments.length ? (clickDistance2 = (_ = +_) * _, drag) : Math.sqrt(clickDistance2); |
|
}; |
|
|
|
return drag; |
|
}; |
|
|
|
var define = function(constructor, factory, prototype) { |
|
constructor.prototype = factory.prototype = prototype; |
|
prototype.constructor = constructor; |
|
}; |
|
|
|
function extend(parent, definition) { |
|
var prototype = Object.create(parent.prototype); |
|
for (var key in definition) prototype[key] = definition[key]; |
|
return prototype; |
|
} |
|
|
|
function Color() {} |
|
|
|
var darker = 0.7; |
|
var brighter = 1 / darker; |
|
|
|
var reI = "\\s*([+-]?\\d+)\\s*"; |
|
var reN = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*"; |
|
var reP = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*"; |
|
var reHex3 = /^#([0-9a-f]{3})$/; |
|
var reHex6 = /^#([0-9a-f]{6})$/; |
|
var reRgbInteger = new RegExp("^rgb\\(" + [reI, reI, reI] + "\\)$"); |
|
var reRgbPercent = new RegExp("^rgb\\(" + [reP, reP, reP] + "\\)$"); |
|
var reRgbaInteger = new RegExp("^rgba\\(" + [reI, reI, reI, reN] + "\\)$"); |
|
var reRgbaPercent = new RegExp("^rgba\\(" + [reP, reP, reP, reN] + "\\)$"); |
|
var reHslPercent = new RegExp("^hsl\\(" + [reN, reP, reP] + "\\)$"); |
|
var reHslaPercent = new RegExp("^hsla\\(" + [reN, reP, reP, reN] + "\\)$"); |
|
|
|
var named = { |
|
aliceblue: 0xf0f8ff, |
|
antiquewhite: 0xfaebd7, |
|
aqua: 0x00ffff, |
|
aquamarine: 0x7fffd4, |
|
azure: 0xf0ffff, |
|
beige: 0xf5f5dc, |
|
bisque: 0xffe4c4, |
|
black: 0x000000, |
|
blanchedalmond: 0xffebcd, |
|
blue: 0x0000ff, |
|
blueviolet: 0x8a2be2, |
|
brown: 0xa52a2a, |
|
burlywood: 0xdeb887, |
|
cadetblue: 0x5f9ea0, |
|
chartreuse: 0x7fff00, |
|
chocolate: 0xd2691e, |
|
coral: 0xff7f50, |
|
cornflowerblue: 0x6495ed, |
|
cornsilk: 0xfff8dc, |
|
crimson: 0xdc143c, |
|
cyan: 0x00ffff, |
|
darkblue: 0x00008b, |
|
darkcyan: 0x008b8b, |
|
darkgoldenrod: 0xb8860b, |
|
darkgray: 0xa9a9a9, |
|
darkgreen: 0x006400, |
|
darkgrey: 0xa9a9a9, |
|
darkkhaki: 0xbdb76b, |
|
darkmagenta: 0x8b008b, |
|
darkolivegreen: 0x556b2f, |
|
darkorange: 0xff8c00, |
|
darkorchid: 0x9932cc, |
|
darkred: 0x8b0000, |
|
darksalmon: 0xe9967a, |
|
darkseagreen: 0x8fbc8f, |
|
darkslateblue: 0x483d8b, |
|
darkslategray: 0x2f4f4f, |
|
darkslategrey: 0x2f4f4f, |
|
darkturquoise: 0x00ced1, |
|
darkviolet: 0x9400d3, |
|
deeppink: 0xff1493, |
|
deepskyblue: 0x00bfff, |
|
dimgray: 0x696969, |
|
dimgrey: 0x696969, |
|
dodgerblue: 0x1e90ff, |
|
firebrick: 0xb22222, |
|
floralwhite: 0xfffaf0, |
|
forestgreen: 0x228b22, |
|
fuchsia: 0xff00ff, |
|
gainsboro: 0xdcdcdc, |
|
ghostwhite: 0xf8f8ff, |
|
gold: 0xffd700, |
|
goldenrod: 0xdaa520, |
|
gray: 0x808080, |
|
green: 0x008000, |
|
greenyellow: 0xadff2f, |
|
grey: 0x808080, |
|
honeydew: 0xf0fff0, |
|
hotpink: 0xff69b4, |
|
indianred: 0xcd5c5c, |
|
indigo: 0x4b0082, |
|
ivory: 0xfffff0, |
|
khaki: 0xf0e68c, |
|
lavender: 0xe6e6fa, |
|
lavenderblush: 0xfff0f5, |
|
lawngreen: 0x7cfc00, |
|
lemonchiffon: 0xfffacd, |
|
lightblue: 0xadd8e6, |
|
lightcoral: 0xf08080, |
|
lightcyan: 0xe0ffff, |
|
lightgoldenrodyellow: 0xfafad2, |
|
lightgray: 0xd3d3d3, |
|
lightgreen: 0x90ee90, |
|
lightgrey: 0xd3d3d3, |
|
lightpink: 0xffb6c1, |
|
lightsalmon: 0xffa07a, |
|
lightseagreen: 0x20b2aa, |
|
lightskyblue: 0x87cefa, |
|
lightslategray: 0x778899, |
|
lightslategrey: 0x778899, |
|
lightsteelblue: 0xb0c4de, |
|
lightyellow: 0xffffe0, |
|
lime: 0x00ff00, |
|
limegreen: 0x32cd32, |
|
linen: 0xfaf0e6, |
|
magenta: 0xff00ff, |
|
maroon: 0x800000, |
|
mediumaquamarine: 0x66cdaa, |
|
mediumblue: 0x0000cd, |
|
mediumorchid: 0xba55d3, |
|
mediumpurple: 0x9370db, |
|
mediumseagreen: 0x3cb371, |
|
mediumslateblue: 0x7b68ee, |
|
mediumspringgreen: 0x00fa9a, |
|
mediumturquoise: 0x48d1cc, |
|
mediumvioletred: 0xc71585, |
|
midnightblue: 0x191970, |
|
mintcream: 0xf5fffa, |
|
mistyrose: 0xffe4e1, |
|
moccasin: 0xffe4b5, |
|
navajowhite: 0xffdead, |
|
navy: 0x000080, |
|
oldlace: 0xfdf5e6, |
|
olive: 0x808000, |
|
olivedrab: 0x6b8e23, |
|
orange: 0xffa500, |
|
orangered: 0xff4500, |
|
orchid: 0xda70d6, |
|
palegoldenrod: 0xeee8aa, |
|
palegreen: 0x98fb98, |
|
paleturquoise: 0xafeeee, |
|
palevioletred: 0xdb7093, |
|
papayawhip: 0xffefd5, |
|
peachpuff: 0xffdab9, |
|
peru: 0xcd853f, |
|
pink: 0xffc0cb, |
|
plum: 0xdda0dd, |
|
powderblue: 0xb0e0e6, |
|
purple: 0x800080, |
|
rebeccapurple: 0x663399, |
|
red: 0xff0000, |
|
rosybrown: 0xbc8f8f, |
|
royalblue: 0x4169e1, |
|
saddlebrown: 0x8b4513, |
|
salmon: 0xfa8072, |
|
sandybrown: 0xf4a460, |
|
seagreen: 0x2e8b57, |
|
seashell: 0xfff5ee, |
|
sienna: 0xa0522d, |
|
silver: 0xc0c0c0, |
|
skyblue: 0x87ceeb, |
|
slateblue: 0x6a5acd, |
|
slategray: 0x708090, |
|
slategrey: 0x708090, |
|
snow: 0xfffafa, |
|
springgreen: 0x00ff7f, |
|
steelblue: 0x4682b4, |
|
tan: 0xd2b48c, |
|
teal: 0x008080, |
|
thistle: 0xd8bfd8, |
|
tomato: 0xff6347, |
|
turquoise: 0x40e0d0, |
|
violet: 0xee82ee, |
|
wheat: 0xf5deb3, |
|
white: 0xffffff, |
|
whitesmoke: 0xf5f5f5, |
|
yellow: 0xffff00, |
|
yellowgreen: 0x9acd32 |
|
}; |
|
|
|
define(Color, color, { |
|
displayable: function() { |
|
return this.rgb().displayable(); |
|
}, |
|
toString: function() { |
|
return this.rgb() + ""; |
|
} |
|
}); |
|
|
|
function color(format) { |
|
var m; |
|
format = (format + "").trim().toLowerCase(); |
|
return (m = reHex3.exec(format)) ? (m = parseInt(m[1], 16), new Rgb((m >> 8 & 0xf) | (m >> 4 & 0x0f0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1)) // #f00 |
|
: (m = reHex6.exec(format)) ? rgbn(parseInt(m[1], 16)) // #ff0000 |
|
: (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0) |
|
: (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%) |
|
: (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1) |
|
: (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1) |
|
: (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%) |
|
: (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1) |
|
: named.hasOwnProperty(format) ? rgbn(named[format]) |
|
: format === "transparent" ? new Rgb(NaN, NaN, NaN, 0) |
|
: null; |
|
} |
|
|
|
function rgbn(n) { |
|
return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1); |
|
} |
|
|
|
function rgba(r, g, b, a) { |
|
if (a <= 0) r = g = b = NaN; |
|
return new Rgb(r, g, b, a); |
|
} |
|
|
|
function rgbConvert(o) { |
|
if (!(o instanceof Color)) o = color(o); |
|
if (!o) return new Rgb; |
|
o = o.rgb(); |
|
return new Rgb(o.r, o.g, o.b, o.opacity); |
|
} |
|
|
|
function rgb(r, g, b, opacity) { |
|
return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity); |
|
} |
|
|
|
function Rgb(r, g, b, opacity) { |
|
this.r = +r; |
|
this.g = +g; |
|
this.b = +b; |
|
this.opacity = +opacity; |
|
} |
|
|
|
define(Rgb, rgb, extend(Color, { |
|
brighter: function(k) { |
|
k = k == null ? brighter : Math.pow(brighter, k); |
|
return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity); |
|
}, |
|
darker: function(k) { |
|
k = k == null ? darker : Math.pow(darker, k); |
|
return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity); |
|
}, |
|
rgb: function() { |
|
return this; |
|
}, |
|
displayable: function() { |
|
return (0 <= this.r && this.r <= 255) |
|
&& (0 <= this.g && this.g <= 255) |
|
&& (0 <= this.b && this.b <= 255) |
|
&& (0 <= this.opacity && this.opacity <= 1); |
|
}, |
|
toString: function() { |
|
var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a)); |
|
return (a === 1 ? "rgb(" : "rgba(") |
|
+ Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", " |
|
+ Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", " |
|
+ Math.max(0, Math.min(255, Math.round(this.b) || 0)) |
|
+ (a === 1 ? ")" : ", " + a + ")"); |
|
} |
|
})); |
|
|
|
function hsla(h, s, l, a) { |
|
if (a <= 0) h = s = l = NaN; |
|
else if (l <= 0 || l >= 1) h = s = NaN; |
|
else if (s <= 0) h = NaN; |
|
return new Hsl(h, s, l, a); |
|
} |
|
|
|
function hslConvert(o) { |
|
if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity); |
|
if (!(o instanceof Color)) o = color(o); |
|
if (!o) return new Hsl; |
|
if (o instanceof Hsl) return o; |
|
o = o.rgb(); |
|
var r = o.r / 255, |
|
g = o.g / 255, |
|
b = o.b / 255, |
|
min = Math.min(r, g, b), |
|
max = Math.max(r, g, b), |
|
h = NaN, |
|
s = max - min, |
|
l = (max + min) / 2; |
|
if (s) { |
|
if (r === max) h = (g - b) / s + (g < b) * 6; |
|
else if (g === max) h = (b - r) / s + 2; |
|
else h = (r - g) / s + 4; |
|
s /= l < 0.5 ? max + min : 2 - max - min; |
|
h *= 60; |
|
} else { |
|
s = l > 0 && l < 1 ? 0 : h; |
|
} |
|
return new Hsl(h, s, l, o.opacity); |
|
} |
|
|
|
function hsl(h, s, l, opacity) { |
|
return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity); |
|
} |
|
|
|
function Hsl(h, s, l, opacity) { |
|
this.h = +h; |
|
this.s = +s; |
|
this.l = +l; |
|
this.opacity = +opacity; |
|
} |
|
|
|
define(Hsl, hsl, extend(Color, { |
|
brighter: function(k) { |
|
k = k == null ? brighter : Math.pow(brighter, k); |
|
return new Hsl(this.h, this.s, this.l * k, this.opacity); |
|
}, |
|
darker: function(k) { |
|
k = k == null ? darker : Math.pow(darker, k); |
|
return new Hsl(this.h, this.s, this.l * k, this.opacity); |
|
}, |
|
rgb: function() { |
|
var h = this.h % 360 + (this.h < 0) * 360, |
|
s = isNaN(h) || isNaN(this.s) ? 0 : this.s, |
|
l = this.l, |
|
m2 = l + (l < 0.5 ? l : 1 - l) * s, |
|
m1 = 2 * l - m2; |
|
return new Rgb( |
|
hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2), |
|
hsl2rgb(h, m1, m2), |
|
hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2), |
|
this.opacity |
|
); |
|
}, |
|
displayable: function() { |
|
return (0 <= this.s && this.s <= 1 || isNaN(this.s)) |
|
&& (0 <= this.l && this.l <= 1) |
|
&& (0 <= this.opacity && this.opacity <= 1); |
|
} |
|
})); |
|
|
|
/* From FvD 13.37, CSS Color Module Level 3 */ |
|
function hsl2rgb(h, m1, m2) { |
|
return (h < 60 ? m1 + (m2 - m1) * h / 60 |
|
: h < 180 ? m2 |
|
: h < 240 ? m1 + (m2 - m1) * (240 - h) / 60 |
|
: m1) * 255; |
|
} |
|
|
|
var deg2rad = Math.PI / 180; |
|
var rad2deg = 180 / Math.PI; |
|
|
|
var Kn = 18; |
|
var Xn = 0.950470; |
|
var Yn = 1; |
|
var Zn = 1.088830; |
|
var t0 = 4 / 29; |
|
var t1 = 6 / 29; |
|
var t2 = 3 * t1 * t1; |
|
var t3 = t1 * t1 * t1; |
|
|
|
function labConvert(o) { |
|
if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity); |
|
if (o instanceof Hcl) { |
|
var h = o.h * deg2rad; |
|
return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity); |
|
} |
|
if (!(o instanceof Rgb)) o = rgbConvert(o); |
|
var b = rgb2xyz(o.r), |
|
a = rgb2xyz(o.g), |
|
l = rgb2xyz(o.b), |
|
x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn), |
|
y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.0721750 * l) / Yn), |
|
z = xyz2lab((0.0193339 * b + 0.1191920 * a + 0.9503041 * l) / Zn); |
|
return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity); |
|
} |
|
|
|
function lab(l, a, b, opacity) { |
|
return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity); |
|
} |
|
|
|
function Lab(l, a, b, opacity) { |
|
this.l = +l; |
|
this.a = +a; |
|
this.b = +b; |
|
this.opacity = +opacity; |
|
} |
|
|
|
define(Lab, lab, extend(Color, { |
|
brighter: function(k) { |
|
return new Lab(this.l + Kn * (k == null ? 1 : k), this.a, this.b, this.opacity); |
|
}, |
|
darker: function(k) { |
|
return new Lab(this.l - Kn * (k == null ? 1 : k), this.a, this.b, this.opacity); |
|
}, |
|
rgb: function() { |
|
var y = (this.l + 16) / 116, |
|
x = isNaN(this.a) ? y : y + this.a / 500, |
|
z = isNaN(this.b) ? y : y - this.b / 200; |
|
y = Yn * lab2xyz(y); |
|
x = Xn * lab2xyz(x); |
|
z = Zn * lab2xyz(z); |
|
return new Rgb( |
|
xyz2rgb( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB |
|
xyz2rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z), |
|
xyz2rgb( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z), |
|
this.opacity |
|
); |
|
} |
|
})); |
|
|
|
function xyz2lab(t) { |
|
return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0; |
|
} |
|
|
|
function lab2xyz(t) { |
|
return t > t1 ? t * t * t : t2 * (t - t0); |
|
} |
|
|
|
function xyz2rgb(x) { |
|
return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055); |
|
} |
|
|
|
function rgb2xyz(x) { |
|
return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4); |
|
} |
|
|
|
function hclConvert(o) { |
|
if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity); |
|
if (!(o instanceof Lab)) o = labConvert(o); |
|
var h = Math.atan2(o.b, o.a) * rad2deg; |
|
return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity); |
|
} |
|
|
|
function hcl(h, c, l, opacity) { |
|
return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity); |
|
} |
|
|
|
function Hcl(h, c, l, opacity) { |
|
this.h = +h; |
|
this.c = +c; |
|
this.l = +l; |
|
this.opacity = +opacity; |
|
} |
|
|
|
define(Hcl, hcl, extend(Color, { |
|
brighter: function(k) { |
|
return new Hcl(this.h, this.c, this.l + Kn * (k == null ? 1 : k), this.opacity); |
|
}, |
|
darker: function(k) { |
|
return new Hcl(this.h, this.c, this.l - Kn * (k == null ? 1 : k), this.opacity); |
|
}, |
|
rgb: function() { |
|
return labConvert(this).rgb(); |
|
} |
|
})); |
|
|
|
var A = -0.14861; |
|
var B = +1.78277; |
|
var C = -0.29227; |
|
var D = -0.90649; |
|
var E = +1.97294; |
|
var ED = E * D; |
|
var EB = E * B; |
|
var BC_DA = B * C - D * A; |
|
|
|
function cubehelixConvert(o) { |
|
if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity); |
|
if (!(o instanceof Rgb)) o = rgbConvert(o); |
|
var r = o.r / 255, |
|
g = o.g / 255, |
|
b = o.b / 255, |
|
l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB), |
|
bl = b - l, |
|
k = (E * (g - l) - C * bl) / D, |
|
s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1 |
|
h = s ? Math.atan2(k, bl) * rad2deg - 120 : NaN; |
|
return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity); |
|
} |
|
|
|
function cubehelix(h, s, l, opacity) { |
|
return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity); |
|
} |
|
|
|
function Cubehelix(h, s, l, opacity) { |
|
this.h = +h; |
|
this.s = +s; |
|
this.l = +l; |
|
this.opacity = +opacity; |
|
} |
|
|
|
define(Cubehelix, cubehelix, extend(Color, { |
|
brighter: function(k) { |
|
k = k == null ? brighter : Math.pow(brighter, k); |
|
return new Cubehelix(this.h, this.s, this.l * k, this.opacity); |
|
}, |
|
darker: function(k) { |
|
k = k == null ? darker : Math.pow(darker, k); |
|
return new Cubehelix(this.h, this.s, this.l * k, this.opacity); |
|
}, |
|
rgb: function() { |
|
var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad, |
|
l = +this.l, |
|
a = isNaN(this.s) ? 0 : this.s * l * (1 - l), |
|
cosh = Math.cos(h), |
|
sinh = Math.sin(h); |
|
return new Rgb( |
|
255 * (l + a * (A * cosh + B * sinh)), |
|
255 * (l + a * (C * cosh + D * sinh)), |
|
255 * (l + a * (E * cosh)), |
|
this.opacity |
|
); |
|
} |
|
})); |
|
|
|
function basis(t1, v0, v1, v2, v3) { |
|
var t2 = t1 * t1, t3 = t2 * t1; |
|
return ((1 - 3 * t1 + 3 * t2 - t3) * v0 |
|
+ (4 - 6 * t2 + 3 * t3) * v1 |
|
+ (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2 |
|
+ t3 * v3) / 6; |
|
} |
|
|
|
var basis$1 = function(values) { |
|
var n = values.length - 1; |
|
return function(t) { |
|
var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n), |
|
v1 = values[i], |
|
v2 = values[i + 1], |
|
v0 = i > 0 ? values[i - 1] : 2 * v1 - v2, |
|
v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1; |
|
return basis((t - i / n) * n, v0, v1, v2, v3); |
|
}; |
|
}; |
|
|
|
var basisClosed = function(values) { |
|
var n = values.length; |
|
return function(t) { |
|
var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n), |
|
v0 = values[(i + n - 1) % n], |
|
v1 = values[i % n], |
|
v2 = values[(i + 1) % n], |
|
v3 = values[(i + 2) % n]; |
|
return basis((t - i / n) * n, v0, v1, v2, v3); |
|
}; |
|
}; |
|
|
|
var constant$3 = function(x) { |
|
return function() { |
|
return x; |
|
}; |
|
}; |
|
|
|
function linear(a, d) { |
|
return function(t) { |
|
return a + t * d; |
|
}; |
|
} |
|
|
|
function exponential(a, b, y) { |
|
return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) { |
|
return Math.pow(a + t * b, y); |
|
}; |
|
} |
|
|
|
function hue(a, b) { |
|
var d = b - a; |
|
return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant$3(isNaN(a) ? b : a); |
|
} |
|
|
|
function gamma(y) { |
|
return (y = +y) === 1 ? nogamma : function(a, b) { |
|
return b - a ? exponential(a, b, y) : constant$3(isNaN(a) ? b : a); |
|
}; |
|
} |
|
|
|
function nogamma(a, b) { |
|
var d = b - a; |
|
return d ? linear(a, d) : constant$3(isNaN(a) ? b : a); |
|
} |
|
|
|
var interpolateRgb = (function rgbGamma(y) { |
|
var color$$1 = gamma(y); |
|
|
|
function rgb$$1(start, end) { |
|
var r = color$$1((start = rgb(start)).r, (end = rgb(end)).r), |
|
g = color$$1(start.g, end.g), |
|
b = color$$1(start.b, end.b), |
|
opacity = nogamma(start.opacity, end.opacity); |
|
return function(t) { |
|
start.r = r(t); |
|
start.g = g(t); |
|
start.b = b(t); |
|
start.opacity = opacity(t); |
|
return start + ""; |
|
}; |
|
} |
|
|
|
rgb$$1.gamma = rgbGamma; |
|
|
|
return rgb$$1; |
|
})(1); |
|
|
|
function rgbSpline(spline) { |
|
return function(colors) { |
|
var n = colors.length, |
|
r = new Array(n), |
|
g = new Array(n), |
|
b = new Array(n), |
|
i, color$$1; |
|
for (i = 0; i < n; ++i) { |
|
color$$1 = rgb(colors[i]); |
|
r[i] = color$$1.r || 0; |
|
g[i] = color$$1.g || 0; |
|
b[i] = color$$1.b || 0; |
|
} |
|
r = spline(r); |
|
g = spline(g); |
|
b = spline(b); |
|
color$$1.opacity = 1; |
|
return function(t) { |
|
color$$1.r = r(t); |
|
color$$1.g = g(t); |
|
color$$1.b = b(t); |
|
return color$$1 + ""; |
|
}; |
|
}; |
|
} |
|
|
|
var rgbBasis = rgbSpline(basis$1); |
|
var rgbBasisClosed = rgbSpline(basisClosed); |
|
|
|
var array$1 = function(a, b) { |
|
var nb = b ? b.length : 0, |
|
na = a ? Math.min(nb, a.length) : 0, |
|
x = new Array(nb), |
|
c = new Array(nb), |
|
i; |
|
|
|
for (i = 0; i < na; ++i) x[i] = interpolateValue(a[i], b[i]); |
|
for (; i < nb; ++i) c[i] = b[i]; |
|
|
|
return function(t) { |
|
for (i = 0; i < na; ++i) c[i] = x[i](t); |
|
return c; |
|
}; |
|
}; |
|
|
|
var date = function(a, b) { |
|
var d = new Date; |
|
return a = +a, b -= a, function(t) { |
|
return d.setTime(a + b * t), d; |
|
}; |
|
}; |
|
|
|
var reinterpolate = function(a, b) { |
|
return a = +a, b -= a, function(t) { |
|
return a + b * t; |
|
}; |
|
}; |
|
|
|
var object = function(a, b) { |
|
var i = {}, |
|
c = {}, |
|
k; |
|
|
|
if (a === null || typeof a !== "object") a = {}; |
|
if (b === null || typeof b !== "object") b = {}; |
|
|
|
for (k in b) { |
|
if (k in a) { |
|
i[k] = interpolateValue(a[k], b[k]); |
|
} else { |
|
c[k] = b[k]; |
|
} |
|
} |
|
|
|
return function(t) { |
|
for (k in i) c[k] = i[k](t); |
|
return c; |
|
}; |
|
}; |
|
|
|
var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g; |
|
var reB = new RegExp(reA.source, "g"); |
|
|
|
function zero(b) { |
|
return function() { |
|
return b; |
|
}; |
|
} |
|
|
|
function one(b) { |
|
return function(t) { |
|
return b(t) + ""; |
|
}; |
|
} |
|
|
|
var interpolateString = function(a, b) { |
|
var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b |
|
am, // current match in a |
|
bm, // current match in b |
|
bs, // string preceding current number in b, if any |
|
i = -1, // index in s |
|
s = [], // string constants and placeholders |
|
q = []; // number interpolators |
|
|
|
// Coerce inputs to strings. |
|
a = a + "", b = b + ""; |
|
|
|
// Interpolate pairs of numbers in a & b. |
|
while ((am = reA.exec(a)) |
|
&& (bm = reB.exec(b))) { |
|
if ((bs = bm.index) > bi) { // a string precedes the next number in b |
|
bs = b.slice(bi, bs); |
|
if (s[i]) s[i] += bs; // coalesce with previous string |
|
else s[++i] = bs; |
|
} |
|
if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match |
|
if (s[i]) s[i] += bm; // coalesce with previous string |
|
else s[++i] = bm; |
|
} else { // interpolate non-matching numbers |
|
s[++i] = null; |
|
q.push({i: i, x: reinterpolate(am, bm)}); |
|
} |
|
bi = reB.lastIndex; |
|
} |
|
|
|
// Add remains of b. |
|
if (bi < b.length) { |
|
bs = b.slice(bi); |
|
if (s[i]) s[i] += bs; // coalesce with previous string |
|
else s[++i] = bs; |
|
} |
|
|
|
// Special optimization for only a single match. |
|
// Otherwise, interpolate each of the numbers and rejoin the string. |
|
return s.length < 2 ? (q[0] |
|
? one(q[0].x) |
|
: zero(b)) |
|
: (b = q.length, function(t) { |
|
for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t); |
|
return s.join(""); |
|
}); |
|
}; |
|
|
|
var interpolateValue = function(a, b) { |
|
var t = typeof b, c; |
|
return b == null || t === "boolean" ? constant$3(b) |
|
: (t === "number" ? reinterpolate |
|
: t === "string" ? ((c = color(b)) ? (b = c, interpolateRgb) : interpolateString) |
|
: b instanceof color ? interpolateRgb |
|
: b instanceof Date ? date |
|
: Array.isArray(b) ? array$1 |
|
: typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? object |
|
: reinterpolate)(a, b); |
|
}; |
|
|
|
var interpolateRound = function(a, b) { |
|
return a = +a, b -= a, function(t) { |
|
return Math.round(a + b * t); |
|
}; |
|
}; |
|
|
|
var degrees = 180 / Math.PI; |
|
|
|
var identity$2 = { |
|
translateX: 0, |
|
translateY: 0, |
|
rotate: 0, |
|
skewX: 0, |
|
scaleX: 1, |
|
scaleY: 1 |
|
}; |
|
|
|
var decompose = function(a, b, c, d, e, f) { |
|
var scaleX, scaleY, skewX; |
|
if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX; |
|
if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX; |
|
if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY; |
|
if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX; |
|
return { |
|
translateX: e, |
|
translateY: f, |
|
rotate: Math.atan2(b, a) * degrees, |
|
skewX: Math.atan(skewX) * degrees, |
|
scaleX: scaleX, |
|
scaleY: scaleY |
|
}; |
|
}; |
|
|
|
var cssNode; |
|
var cssRoot; |
|
var cssView; |
|
var svgNode; |
|
|
|
function parseCss(value) { |
|
if (value === "none") return identity$2; |
|
if (!cssNode) cssNode = document.createElement("DIV"), cssRoot = document.documentElement, cssView = document.defaultView; |
|
cssNode.style.transform = value; |
|
value = cssView.getComputedStyle(cssRoot.appendChild(cssNode), null).getPropertyValue("transform"); |
|
cssRoot.removeChild(cssNode); |
|
value = value.slice(7, -1).split(","); |
|
return decompose(+value[0], +value[1], +value[2], +value[3], +value[4], +value[5]); |
|
} |
|
|
|
function parseSvg(value) { |
|
if (value == null) return identity$2; |
|
if (!svgNode) svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g"); |
|
svgNode.setAttribute("transform", value); |
|
if (!(value = svgNode.transform.baseVal.consolidate())) return identity$2; |
|
value = value.matrix; |
|
return decompose(value.a, value.b, value.c, value.d, value.e, value.f); |
|
} |
|
|
|
function interpolateTransform(parse, pxComma, pxParen, degParen) { |
|
|
|
function pop(s) { |
|
return s.length ? s.pop() + " " : ""; |
|
} |
|
|
|
function translate(xa, ya, xb, yb, s, q) { |
|
if (xa !== xb || ya !== yb) { |
|
var i = s.push("translate(", null, pxComma, null, pxParen); |
|
q.push({i: i - 4, x: reinterpolate(xa, xb)}, {i: i - 2, x: reinterpolate(ya, yb)}); |
|
} else if (xb || yb) { |
|
s.push("translate(" + xb + pxComma + yb + pxParen); |
|
} |
|
} |
|
|
|
function rotate(a, b, s, q) { |
|
if (a !== b) { |
|
if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path |
|
q.push({i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: reinterpolate(a, b)}); |
|
} else if (b) { |
|
s.push(pop(s) + "rotate(" + b + degParen); |
|
} |
|
} |
|
|
|
function skewX(a, b, s, q) { |
|
if (a !== b) { |
|
q.push({i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: reinterpolate(a, b)}); |
|
} else if (b) { |
|
s.push(pop(s) + "skewX(" + b + degParen); |
|
} |
|
} |
|
|
|
function scale(xa, ya, xb, yb, s, q) { |
|
if (xa !== xb || ya !== yb) { |
|
var i = s.push(pop(s) + "scale(", null, ",", null, ")"); |
|
q.push({i: i - 4, x: reinterpolate(xa, xb)}, {i: i - 2, x: reinterpolate(ya, yb)}); |
|
} else if (xb !== 1 || yb !== 1) { |
|
s.push(pop(s) + "scale(" + xb + "," + yb + ")"); |
|
} |
|
} |
|
|
|
return function(a, b) { |
|
var s = [], // string constants and placeholders |
|
q = []; // number interpolators |
|
a = parse(a), b = parse(b); |
|
translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q); |
|
rotate(a.rotate, b.rotate, s, q); |
|
skewX(a.skewX, b.skewX, s, q); |
|
scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q); |
|
a = b = null; // gc |
|
return function(t) { |
|
var i = -1, n = q.length, o; |
|
while (++i < n) s[(o = q[i]).i] = o.x(t); |
|
return s.join(""); |
|
}; |
|
}; |
|
} |
|
|
|
var interpolateTransformCss = interpolateTransform(parseCss, "px, ", "px)", "deg)"); |
|
var interpolateTransformSvg = interpolateTransform(parseSvg, ", ", ")", ")"); |
|
|
|
var rho = Math.SQRT2; |
|
var rho2 = 2; |
|
var rho4 = 4; |
|
var epsilon2 = 1e-12; |
|
|
|
function cosh(x) { |
|
return ((x = Math.exp(x)) + 1 / x) / 2; |
|
} |
|
|
|
function sinh(x) { |
|
return ((x = Math.exp(x)) - 1 / x) / 2; |
|
} |
|
|
|
function tanh(x) { |
|
return ((x = Math.exp(2 * x)) - 1) / (x + 1); |
|
} |
|
|
|
// p0 = [ux0, uy0, w0] |
|
// p1 = [ux1, uy1, w1] |
|
var interpolateZoom = function(p0, p1) { |
|
var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], |
|
ux1 = p1[0], uy1 = p1[1], w1 = p1[2], |
|
dx = ux1 - ux0, |
|
dy = uy1 - uy0, |
|
d2 = dx * dx + dy * dy, |
|
i, |
|
S; |
|
|
|
// Special case for u0 ≅ u1. |
|
if (d2 < epsilon2) { |
|
S = Math.log(w1 / w0) / rho; |
|
i = function(t) { |
|
return [ |
|
ux0 + t * dx, |
|
uy0 + t * dy, |
|
w0 * Math.exp(rho * t * S) |
|
]; |
|
}; |
|
} |
|
|
|
// General case. |
|
else { |
|
var d1 = Math.sqrt(d2), |
|
b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1), |
|
b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1), |
|
r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), |
|
r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1); |
|
S = (r1 - r0) / rho; |
|
i = function(t) { |
|
var s = t * S, |
|
coshr0 = cosh(r0), |
|
u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0)); |
|
return [ |
|
ux0 + u * dx, |
|
uy0 + u * dy, |
|
w0 * coshr0 / cosh(rho * s + r0) |
|
]; |
|
}; |
|
} |
|
|
|
i.duration = S * 1000; |
|
|
|
return i; |
|
}; |
|
|
|
function hsl$1(hue$$1) { |
|
return function(start, end) { |
|
var h = hue$$1((start = hsl(start)).h, (end = hsl(end)).h), |
|
s = nogamma(start.s, end.s), |
|
l = nogamma(start.l, end.l), |
|
opacity = nogamma(start.opacity, end.opacity); |
|
return function(t) { |
|
start.h = h(t); |
|
start.s = s(t); |
|
start.l = l(t); |
|
start.opacity = opacity(t); |
|
return start + ""; |
|
}; |
|
} |
|
} |
|
|
|
var hsl$2 = hsl$1(hue); |
|
var hslLong = hsl$1(nogamma); |
|
|
|
function lab$1(start, end) { |
|
var l = nogamma((start = lab(start)).l, (end = lab(end)).l), |
|
a = nogamma(start.a, end.a), |
|
b = nogamma(start.b, end.b), |
|
opacity = nogamma(start.opacity, end.opacity); |
|
return function(t) { |
|
start.l = l(t); |
|
start.a = a(t); |
|
start.b = b(t); |
|
start.opacity = opacity(t); |
|
return start + ""; |
|
}; |
|
} |
|
|
|
function hcl$1(hue$$1) { |
|
return function(start, end) { |
|
var h = hue$$1((start = hcl(start)).h, (end = hcl(end)).h), |
|
c = nogamma(start.c, end.c), |
|
l = nogamma(start.l, end.l), |
|
opacity = nogamma(start.opacity, end.opacity); |
|
return function(t) { |
|
start.h = h(t); |
|
start.c = c(t); |
|
start.l = l(t); |
|
start.opacity = opacity(t); |
|
return start + ""; |
|
}; |
|
} |
|
} |
|
|
|
var hcl$2 = hcl$1(hue); |
|
var hclLong = hcl$1(nogamma); |
|
|
|
function cubehelix$1(hue$$1) { |
|
return (function cubehelixGamma(y) { |
|
y = +y; |
|
|
|
function cubehelix$$1(start, end) { |
|
var h = hue$$1((start = cubehelix(start)).h, (end = cubehelix(end)).h), |
|
s = nogamma(start.s, end.s), |
|
l = nogamma(start.l, end.l), |
|
opacity = nogamma(start.opacity, end.opacity); |
|
return function(t) { |
|
start.h = h(t); |
|
start.s = s(t); |
|
start.l = l(Math.pow(t, y)); |
|
start.opacity = opacity(t); |
|
return start + ""; |
|
}; |
|
} |
|
|
|
cubehelix$$1.gamma = cubehelixGamma; |
|
|
|
return cubehelix$$1; |
|
})(1); |
|
} |
|
|
|
var cubehelix$2 = cubehelix$1(hue); |
|
var cubehelixLong = cubehelix$1(nogamma); |
|
|
|
var quantize = function(interpolator, n) { |
|
var samples = new Array(n); |
|
for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1)); |
|
return samples; |
|
}; |
|
|
|
var frame = 0; |
|
var timeout = 0; |
|
var interval = 0; |
|
var pokeDelay = 1000; |
|
var taskHead; |
|
var taskTail; |
|
var clockLast = 0; |
|
var clockNow = 0; |
|
var clockSkew = 0; |
|
var clock = typeof performance === "object" && performance.now ? performance : Date; |
|
var setFrame = typeof window === "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f) { setTimeout(f, 17); }; |
|
|
|
function now() { |
|
return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew); |
|
} |
|
|
|
function clearNow() { |
|
clockNow = 0; |
|
} |
|
|
|
function Timer() { |
|
this._call = |
|
this._time = |
|
this._next = null; |
|
} |
|
|
|
Timer.prototype = timer.prototype = { |
|
constructor: Timer, |
|
restart: function(callback, delay, time) { |
|
if (typeof callback !== "function") throw new TypeError("callback is not a function"); |
|
time = (time == null ? now() : +time) + (delay == null ? 0 : +delay); |
|
if (!this._next && taskTail !== this) { |
|
if (taskTail) taskTail._next = this; |
|
else taskHead = this; |
|
taskTail = this; |
|
} |
|
this._call = callback; |
|
this._time = time; |
|
sleep(); |
|
}, |
|
stop: function() { |
|
if (this._call) { |
|
this._call = null; |
|
this._time = Infinity; |
|
sleep(); |
|
} |
|
} |
|
}; |
|
|
|
function timer(callback, delay, time) { |
|
var t = new Timer; |
|
t.restart(callback, delay, time); |
|
return t; |
|
} |
|
|
|
function timerFlush() { |
|
now(); // Get the current time, if not already set. |
|
++frame; // Pretend we’ve set an alarm, if we haven’t already. |
|
var t = taskHead, e; |
|
while (t) { |
|
if ((e = clockNow - t._time) >= 0) t._call.call(null, e); |
|
t = t._next; |
|
} |
|
--frame; |
|
} |
|
|
|
function wake() { |
|
clockNow = (clockLast = clock.now()) + clockSkew; |
|
frame = timeout = 0; |
|
try { |
|
timerFlush(); |
|
} finally { |
|
frame = 0; |
|
nap(); |
|
clockNow = 0; |
|
} |
|
} |
|
|
|
function poke() { |
|
var now = clock.now(), delay = now - clockLast; |
|
if (delay > pokeDelay) clockSkew -= delay, clockLast = now; |
|
} |
|
|
|
function nap() { |
|
var t0, t1 = taskHead, t2, time = Infinity; |
|
while (t1) { |
|
if (t1._call) { |
|
if (time > t1._time) time = t1._time; |
|
t0 = t1, t1 = t1._next; |
|
} else { |
|
t2 = t1._next, t1._next = null; |
|
t1 = t0 ? t0._next = t2 : taskHead = t2; |
|
} |
|
} |
|
taskTail = t0; |
|
sleep(time); |
|
} |
|
|
|
function sleep(time) { |
|
if (frame) return; // Soonest alarm already set, or will be. |
|
if (timeout) timeout = clearTimeout(timeout); |
|
var delay = time - clockNow; |
|
if (delay > 24) { |
|
if (time < Infinity) timeout = setTimeout(wake, delay); |
|
if (interval) interval = clearInterval(interval); |
|
} else { |
|
if (!interval) clockLast = clockNow, interval = setInterval(poke, pokeDelay); |
|
frame = 1, setFrame(wake); |
|
} |
|
} |
|
|
|
var timeout$1 = function(callback, delay, time) { |
|
var t = new Timer; |
|
delay = delay == null ? 0 : +delay; |
|
t.restart(function(elapsed) { |
|
t.stop(); |
|
callback(elapsed + delay); |
|
}, delay, time); |
|
return t; |
|
}; |
|
|
|
var interval$1 = function(callback, delay, time) { |
|
var t = new Timer, total = delay; |
|
if (delay == null) return t.restart(callback, delay, time), t; |
|
delay = +delay, time = time == null ? now() : +time; |
|
t.restart(function tick(elapsed) { |
|
elapsed += total; |
|
t.restart(tick, total += delay, time); |
|
callback(elapsed); |
|
}, delay, time); |
|
return t; |
|
}; |
|
|
|
var emptyOn = dispatch("start", "end", "interrupt"); |
|
var emptyTween = []; |
|
|
|
var CREATED = 0; |
|
var SCHEDULED = 1; |
|
var STARTING = 2; |
|
var STARTED = 3; |
|
var RUNNING = 4; |
|
var ENDING = 5; |
|
var ENDED = 6; |
|
|
|
var schedule = function(node, name, id, index, group, timing) { |
|
var schedules = node.__transition; |
|
if (!schedules) node.__transition = {}; |
|
else if (id in schedules) return; |
|
create(node, id, { |
|
name: name, |
|
index: index, // For context during callback. |
|
group: group, // For context during callback. |
|
on: emptyOn, |
|
tween: emptyTween, |
|
time: timing.time, |
|
delay: timing.delay, |
|
duration: timing.duration, |
|
ease: timing.ease, |
|
timer: null, |
|
state: CREATED |
|
}); |
|
}; |
|
|
|
function init(node, id) { |
|
var schedule = node.__transition; |
|
if (!schedule || !(schedule = schedule[id]) || schedule.state > CREATED) throw new Error("too late"); |
|
return schedule; |
|
} |
|
|
|
function set$1(node, id) { |
|
var schedule = node.__transition; |
|
if (!schedule || !(schedule = schedule[id]) || schedule.state > STARTING) throw new Error("too late"); |
|
return schedule; |
|
} |
|
|
|
function get$1(node, id) { |
|
var schedule = node.__transition; |
|
if (!schedule || !(schedule = schedule[id])) throw new Error("too late"); |
|
return schedule; |
|
} |
|
|
|
function create(node, id, self) { |
|
var schedules = node.__transition, |
|
tween; |
|
|
|
// Initialize the self timer when the transition is created. |
|
// Note the actual delay is not known until the first callback! |
|
schedules[id] = self; |
|
self.timer = timer(schedule, 0, self.time); |
|
|
|
function schedule(elapsed) { |
|
self.state = SCHEDULED; |
|
self.timer.restart(start, self.delay, self.time); |
|
|
|
// If the elapsed delay is less than our first sleep, start immediately. |
|
if (self.delay <= elapsed) start(elapsed - self.delay); |
|
