(function(){if (!Date.now) Date.now = function() {

return +new Date;

};

try {

document.createElement("div").style.setProperty("opacity", 0, "");

} catch (error) {

var d3_style_prototype = CSSStyleDeclaration.prototype,

d3_style_setProperty = d3_style_prototype.setProperty;

d3_style_prototype.setProperty = function(name, value, priority) {

d3_style_setProperty.call(this, name, value + "", priority);

};

}

d3 = {version: "2.9.4"}; // semver

function d3_class(ctor, properties) {

try {

for (var key in properties) {

Object.defineProperty(ctor.prototype, key, {

value: properties[key],

enumerable: false

});

}

} catch (e) {

ctor.prototype = properties;

}

}

var d3_array = d3_arraySlice; // conversion for NodeLists

function d3_arrayCopy(pseudoarray) {

var i = -1, n = pseudoarray.length, array = [];

while (++i < n) array.push(pseudoarray[i]);

return array;

}

function d3_arraySlice(pseudoarray) {

return Array.prototype.slice.call(pseudoarray);

}

try {

d3_array(document.documentElement.childNodes)[0].nodeType;

} catch(e) {

d3_array = d3_arrayCopy;

}

var d3_arraySubclass = [].__proto__?

// Until ECMAScript supports array subclassing, prototype injection works well.

function(array, prototype) {

array.__proto__ = prototype;

}:

// And if your browser doesn't support __proto__, we'll use direct extension.

function(array, prototype) {

for (var property in prototype) array[property] = prototype[property];

};

d3.map = function(object) {

var map = new d3_Map;

for (var key in object) map.set(key, object[key]);

return map;

};

function d3_Map() {}

d3_class(d3_Map, {

has: function(key) {

return d3_map_prefix + key in this;

},

get: function(key) {

return this[d3_map_prefix + key];

},

set: function(key, value) {

return this[d3_map_prefix + key] = value;

},

remove: function(key) {

key = d3_map_prefix + key;

return key in this && delete this[key];

},

keys: function() {

var keys = [];

this.forEach(function(key) { keys.push(key); });

return keys;

},

values: function() {

var values = [];

this.forEach(function(key, value) { values.push(value); });

return values;

},

entries: function() {

var entries = [];

this.forEach(function(key, value) { entries.push({key: key, value: value}); });

return entries;

},

forEach: function(f) {

for (var key in this) {

if (key.charCodeAt(0) === d3_map_prefixCode) {

f.call(this, key.substring(1), this[key]);

}

}

}

});

var d3_map_prefix = "\0", // prevent collision with built-ins

d3_map_prefixCode = d3_map_prefix.charCodeAt(0);

function d3_identity(d) {

return d;

}

function d3_this() {

return this;

}

function d3_true() {

return true;

}

function d3_functor(v) {

return typeof v === "function" ? v : function() { return v; };

}

d3.functor = d3_functor;

// Copies a variable number of methods from source to target.

d3.rebind = function(target, source) {

var i = 1, n = arguments.length, method;

while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]);

return target;

};

// Method is assumed to be a standard D3 getter-setter:

// If passed with no arguments, gets the value.

// If passed with arguments, sets the value and returns the target.

function d3_rebind(target, source, method) {

return function() {

var value = method.apply(source, arguments);

return arguments.length ? target : value;

};

}

d3.ascending = function(a, b) {

return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;

};

d3.descending = function(a, b) {

return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;

};

d3.mean = function(array, f) {

var n = array.length,

a,

m = 0,

i = -1,

j = 0;

if (arguments.length === 1) {

while (++i < n) if (d3_number(a = array[i])) m += (a - m) / ++j;

} else {

while (++i < n) if (d3_number(a = f.call(array, array[i], i))) m += (a - m) / ++j;

}

return j ? m : undefined;

};

d3.median = function(array, f) {

if (arguments.length > 1) array = array.map(f);

array = array.filter(d3_number);

return array.length ? d3.quantile(array.sort(d3.ascending), .5) : undefined;

};

d3.min = function(array, f) {

var i = -1,

n = array.length,

a,

b;

if (arguments.length === 1) {

while (++i < n && ((a = array[i]) == null || a != a)) a = undefined;

while (++i < n) if ((b = array[i]) != null && a > b) a = b;

} else {

while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined;

while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;

}

return a;

};

d3.max = function(array, f) {

var i = -1,

n = array.length,

a,

b;

if (arguments.length === 1) {

while (++i < n && ((a = array[i]) == null || a != a)) a = undefined;

while (++i < n) if ((b = array[i]) != null && b > a) a = b;

} else {

while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined;

while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;

}

return a;

};

d3.extent = function(array, f) {

var i = -1,

n = array.length,

a,

b,

c;

if (arguments.length === 1) {

while (++i < n && ((a = c = array[i]) == null || a != a)) a = c = undefined;

while (++i < n) if ((b = array[i]) != null) {

if (a > b) a = b;

if (c < b) c = b;

}

} else {

while (++i < n && ((a = c = f.call(array, array[i], i)) == null || a != a)) a = undefined;

while (++i < n) if ((b = f.call(array, array[i], i)) != null) {

if (a > b) a = b;

if (c < b) c = b;

}

}

return [a, c];

};

d3.random = {

normal: function(mean, deviation) {

if (arguments.length < 2) deviation = 1;

if (arguments.length < 1) mean = 0;

return function() {

var x, y, r;

do {

x = Math.random() * 2 - 1;

y = Math.random() * 2 - 1;

r = x * x + y * y;

} while (!r || r > 1);

return mean + deviation * x * Math.sqrt(-2 * Math.log(r) / r);

};

}

};

function d3_number(x) {

return x != null && !isNaN(x);

}

d3.sum = function(array, f) {

var s = 0,

n = array.length,

a,

i = -1;

if (arguments.length === 1) {

while (++i < n) if (!isNaN(a = +array[i])) s += a;

} else {

while (++i < n) if (!isNaN(a = +f.call(array, array[i], i))) s += a;

}

return s;

};

// R-7 per <http://en.wikipedia.org/wiki/Quantile>

d3.quantile = function(values, p) {

var H = (values.length - 1) * p + 1,

h = Math.floor(H),

v = values[h - 1],

e = H - h;

return e ? v + e * (values[h] - v) : v;

};

d3.transpose = function(matrix) {

return d3.zip.apply(d3, matrix);

};

d3.zip = function() {

if (!(n = arguments.length)) return [];

for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m;) {

for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n;) {

zip[j] = arguments[j][i];

}

}

return zips;

};

function d3_zipLength(d) {

return d.length;

}

d3.bisector = function(f) {

return {

left: function(a, x, lo, hi) {

if (arguments.length < 3) lo = 0;

if (arguments.length < 4) hi = a.length;

while (lo < hi) {

var mid = lo + hi >> 1;

if (f.call(a, a[mid], mid) < x) lo = mid + 1;

else hi = mid;

}

return lo;

},

right: function(a, x, lo, hi) {

if (arguments.length < 3) lo = 0;

if (arguments.length < 4) hi = a.length;

while (lo < hi) {

var mid = lo + hi >> 1;

if (x < f.call(a, a[mid], mid)) hi = mid;

else lo = mid + 1;

}

return lo;

}

};

};

var d3_bisector = d3.bisector(function(d) { return d; });

d3.bisectLeft = d3_bisector.left;

d3.bisect = d3.bisectRight = d3_bisector.right;

d3.first = function(array, f) {

var i = 0,

n = array.length,

a = array[0],

b;

if (arguments.length === 1) f = d3.ascending;

while (++i < n) {

if (f.call(array, a, b = array[i]) > 0) {

a = b;

}

}

return a;

};

d3.last = function(array, f) {

var i = 0,

n = array.length,

a = array[0],

b;

if (arguments.length === 1) f = d3.ascending;

while (++i < n) {

if (f.call(array, a, b = array[i]) <= 0) {

a = b;

}

}

return a;

};

d3.nest = function() {

var nest = {},

keys = [],

sortKeys = [],

sortValues,

rollup;

function map(array, depth) {

if (depth >= keys.length) return rollup

? rollup.call(nest, array) : (sortValues

? array.sort(sortValues)

: array);

var i = -1,

n = array.length,

key = keys[depth++],

keyValue,

object,

valuesByKey = new d3_Map,

values,

o = {};

while (++i < n) {

if (values = valuesByKey.get(keyValue = key(object = array[i]))) {

values.push(object);

} else {

valuesByKey.set(keyValue, [object]);

}

}

valuesByKey.forEach(function(keyValue) {

o[keyValue] = map(valuesByKey.get(keyValue), depth);

});

return o;

}

function entries(map, depth) {

if (depth >= keys.length) return map;

var a = [],

sortKey = sortKeys[depth++],

key;

for (key in map) {

a.push({key: key, values: entries(map[key], depth)});

}

if (sortKey) a.sort(function(a, b) {

return sortKey(a.key, b.key);

});

return a;

}

nest.map = function(array) {

return map(array, 0);

};

nest.entries = function(array) {

return entries(map(array, 0), 0);

};

nest.key = function(d) {

keys.push(d);

return nest;

};

// Specifies the order for the most-recently specified key.

// Note: only applies to entries. Map keys are unordered!

nest.sortKeys = function(order) {

sortKeys[keys.length - 1] = order;

return nest;

};

// Specifies the order for leaf values.

// Applies to both maps and entries array.

nest.sortValues = function(order) {

sortValues = order;

return nest;

};

nest.rollup = function(f) {

rollup = f;

return nest;

};

return nest;

};

d3.keys = function(map) {

var keys = [];

for (var key in map) keys.push(key);

return keys;

};

d3.values = function(map) {

var values = [];

for (var key in map) values.push(map[key]);

return values;

};

d3.entries = function(map) {

var entries = [];

for (var key in map) entries.push({key: key, value: map[key]});

return entries;

};

d3.permute = function(array, indexes) {

var permutes = [],

i = -1,

n = indexes.length;

while (++i < n) permutes[i] = array[indexes[i]];

return permutes;

};

d3.merge = function(arrays) {

return Array.prototype.concat.apply([], arrays);

};

d3.split = function(array, f) {

var arrays = [],

values = [],

value,

i = -1,

n = array.length;

if (arguments.length < 2) f = d3_splitter;

while (++i < n) {

if (f.call(values, value = array[i], i)) {

values = [];

} else {

if (!values.length) arrays.push(values);

values.push(value);

}

}

return arrays;

};

function d3_splitter(d) {

return d == null;

}

function d3_collapse(s) {

return s.replace(/(^\s+)|(\s+$)/g, "").replace(/\s+/g, " ");

}

d3.range = function(start, stop, step) {

if (arguments.length < 3) {

step = 1;

if (arguments.length < 2) {

stop = start;

start = 0;

}

}

if ((stop - start) / step === Infinity) throw new Error("infinite range");

var range = [],

k = d3_range_integerScale(Math.abs(step)),

i = -1,

j;

start *= k, stop *= k, step *= k;

if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k);

else while ((j = start + step * ++i) < stop) range.push(j / k);

return range;

};

function d3_range_integerScale(x) {

var k = 1;

while (x * k % 1) k *= 10;

return k;

}

d3.requote = function(s) {

return s.replace(d3_requote_re, "\\$&");

};

var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;

d3.round = function(x, n) {

return n

? Math.round(x * (n = Math.pow(10, n))) / n

: Math.round(x);

};

d3.xhr = function(url, mime, callback) {

var req = new XMLHttpRequest;

if (arguments.length < 3) callback = mime, mime = null;

else if (mime && req.overrideMimeType) req.overrideMimeType(mime);

req.open("GET", url, true);

if (mime) req.setRequestHeader("Accept", mime);

req.onreadystatechange = function() {

if (req.readyState === 4) {

var s = req.status;

callback(!s && req.response || s >= 200 && s < 300 || s === 304 ? req : null);

}

};

req.send(null);

};

d3.text = function(url, mime, callback) {

function ready(req) {

callback(req && req.responseText);

}

if (arguments.length < 3) {

callback = mime;

mime = null;

}

d3.xhr(url, mime, ready);

};

d3.json = function(url, callback) {

d3.text(url, "application/json", function(text) {

callback(text ? JSON.parse(text) : null);

});

};

d3.html = function(url, callback) {

d3.text(url, "text/html", function(text) {

if (text != null) { // Treat empty string as valid HTML.

var range = document.createRange();

range.selectNode(document.body);

text = range.createContextualFragment(text);

}

callback(text);

});

};

d3.xml = function(url, mime, callback) {

function ready(req) {

callback(req && req.responseXML);

}

if (arguments.length < 3) {

callback = mime;

mime = null;

}

d3.xhr(url, mime, ready);

};

var d3_nsPrefix = {

svg: "http://www.w3.org/2000/svg",

xhtml: "http://www.w3.org/1999/xhtml",

xlink: "http://www.w3.org/1999/xlink",

xml: "http://www.w3.org/XML/1998/namespace",

xmlns: "http://www.w3.org/2000/xmlns/"

};

d3.ns = {

prefix: d3_nsPrefix,

qualify: function(name) {

var i = name.indexOf(":"),

prefix = name;

if (i >= 0) {

prefix = name.substring(0, i);

name = name.substring(i + 1);

}

return d3_nsPrefix.hasOwnProperty(prefix)

? {space: d3_nsPrefix[prefix], local: name}

: name;

}

};

d3.dispatch = function() {

var dispatch = new d3_dispatch,

i = -1,

n = arguments.length;

while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);

return dispatch;

};

function d3_dispatch() {}

d3_dispatch.prototype.on = function(type, listener) {

var i = type.indexOf("."),

name = "";

// Extract optional namespace, e.g., "click.foo"

if (i > 0) {

name = type.substring(i + 1);

type = type.substring(0, i);

}

return arguments.length < 2

? this[type].on(name)

: this[type].on(name, listener);

};

function d3_dispatch_event(dispatch) {

var listeners = [],

listenerByName = new d3_Map;

function event() {

var z = listeners, // defensive reference

i = -1,

n = z.length,

l;

while (++i < n) if (l = z[i].on) l.apply(this, arguments);

return dispatch;

}

event.on = function(name, listener) {

var l = listenerByName.get(name),

i;

// return the current listener, if any

if (arguments.length < 2) return l && l.on;

// remove the old listener, if any (with copy-on-write)

if (l) {

l.on = null;

listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1));

listenerByName.remove(name);

}

// add the new listener, if any

if (listener) listeners.push(listenerByName.set(name, {on: listener}));

return dispatch;

};

return event;

}

// TODO align

d3.format = function(specifier) {

var match = d3_format_re.exec(specifier),

fill = match[1] || " ",

sign = match[3] || "",

zfill = match[5],

width = +match[6],

comma = match[7],

precision = match[8],

type = match[9],

scale = 1,

suffix = "",

integer = false;

if (precision) precision = +precision.substring(1);

if (zfill) {

fill = "0"; // TODO align = "=";

if (comma) width -= Math.floor((width - 1) / 4);

}

switch (type) {

case "n": comma = true; type = "g"; break;

case "%": scale = 100; suffix = "%"; type = "f"; break;

case "p": scale = 100; suffix = "%"; type = "r"; break;

case "d": integer = true; precision = 0; break;

case "s": scale = -1; type = "r"; break;

}

// If no precision is specified for r, fallback to general notation.

if (type == "r" && !precision) type = "g";

type = d3_format_types.get(type) || d3_format_typeDefault;

return function(value) {

// Return the empty string for floats formatted as ints.

if (integer && (value % 1)) return "";

// Convert negative to positive, and record the sign prefix.

var negative = (value < 0) && (value = -value) ? "\u2212" : sign;

// Apply the scale, computing it from the value's exponent for si format.

if (scale < 0) {

var prefix = d3.formatPrefix(value, precision);

value = prefix.scale(value);

suffix = prefix.symbol;

} else {

value *= scale;

}

// Convert to the desired precision.

value = type(value, precision);

// If the fill character is 0, the sign and group is applied after the fill.

if (zfill) {

var length = value.length + negative.length;

if (length < width) value = new Array(width - length + 1).join(fill) + value;

if (comma) value = d3_format_group(value);

value = negative + value;

}

// Otherwise (e.g., space-filling), the sign and group is applied before.

else {

if (comma) value = d3_format_group(value);

value = negative + value;

var length = value.length;

if (length < width) value = new Array(width - length + 1).join(fill) + value;

}

return value + suffix;

};

};

// [[fill]align][sign][#][0][width][,][.precision][type]

var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?(#)?(0)?([0-9]+)?(,)?(\.[0-9]+)?([a-zA-Z%])?/;

var d3_format_types = d3.map({

g: function(x, p) { return x.toPrecision(p); },

e: function(x, p) { return x.toExponential(p); },

f: function(x, p) { return x.toFixed(p); },

r: function(x, p) { return d3.round(x, p = d3_format_precision(x, p)).toFixed(Math.max(0, Math.min(20, p))); }

});

function d3_format_precision(x, p) {

return p - (x ? 1 + Math.floor(Math.log(x + Math.pow(10, 1 + Math.floor(Math.log(x) / Math.LN10) - p)) / Math.LN10) : 1);

}

function d3_format_typeDefault(x) {

return x + "";

}

// Apply comma grouping for thousands.

function d3_format_group(value) {

var i = value.lastIndexOf("."),

f = i >= 0 ? value.substring(i) : (i = value.length, ""),

t = [];

while (i > 0) t.push(value.substring(i -= 3, i + 3));

return t.reverse().join(",") + f;

}

var d3_formatPrefixes = ["y","z","a","f","p","n","μ","m","","k","M","G","T","P","E","Z","Y"].map(d3_formatPrefix);

d3.formatPrefix = function(value, precision) {

var i = 0;

if (value) {

if (value < 0) value *= -1;

if (precision) value = d3.round(value, d3_format_precision(value, precision));

i = 1 + Math.floor(1e-12 + Math.log(value) / Math.LN10);

i = Math.max(-24, Math.min(24, Math.floor((i <= 0 ? i + 1 : i - 1) / 3) * 3));

}

return d3_formatPrefixes[8 + i / 3];

};

function d3_formatPrefix(d, i) {

var k = Math.pow(10, Math.abs(8 - i) * 3);

return {

scale: i > 8 ? function(d) { return d / k; } : function(d) { return d * k; },

symbol: d

};

}

/*

* TERMS OF USE - EASING EQUATIONS

*

* Open source under the BSD License.

*

* Copyright 2001 Robert Penner

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are met:

*

* - Redistributions of source code must retain the above copyright notice, this

* list of conditions and the following disclaimer.

*

* - Redistributions in binary form must reproduce the above copyright notice,

* this list of conditions and the following disclaimer in the documentation

* and/or other materials provided with the distribution.

*

* - Neither the name of the author nor the names of contributors may be used to

* endorse or promote products derived from this software without specific

* prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

* POSSIBILITY OF SUCH DAMAGE.

*/

var d3_ease_quad = d3_ease_poly(2),

d3_ease_cubic = d3_ease_poly(3),

d3_ease_default = function() { return d3_ease_identity; };

var d3_ease = d3.map({

linear: d3_ease_default,

poly: d3_ease_poly,

quad: function() { return d3_ease_quad; },

cubic: function() { return d3_ease_cubic; },

sin: function() { return d3_ease_sin; },

exp: function() { return d3_ease_exp; },

circle: function() { return d3_ease_circle; },

elastic: d3_ease_elastic,

back: d3_ease_back,

bounce: function() { return d3_ease_bounce; }

});

var d3_ease_mode = d3.map({

"in": d3_ease_identity,

"out": d3_ease_reverse,

"in-out": d3_ease_reflect,

"out-in": function(f) { return d3_ease_reflect(d3_ease_reverse(f)); }

});

d3.ease = function(name) {

var i = name.indexOf("-"),

t = i >= 0 ? name.substring(0, i) : name,

m = i >= 0 ? name.substring(i + 1) : "in";

t = d3_ease.get(t) || d3_ease_default;

m = d3_ease_mode.get(m) || d3_ease_identity;

return d3_ease_clamp(m(t.apply(null, Array.prototype.slice.call(arguments, 1))));

};

function d3_ease_clamp(f) {

return function(t) {

return t <= 0 ? 0 : t >= 1 ? 1 : f(t);

};

}

function d3_ease_reverse(f) {

return function(t) {

return 1 - f(1 - t);

};

}

function d3_ease_reflect(f) {

return function(t) {

return .5 * (t < .5 ? f(2 * t) : (2 - f(2 - 2 * t)));

};

}

function d3_ease_identity(t) {

return t;

}

function d3_ease_poly(e) {

return function(t) {

return Math.pow(t, e);

};

}

function d3_ease_sin(t) {

return 1 - Math.cos(t * Math.PI / 2);

}

function d3_ease_exp(t) {

return Math.pow(2, 10 * (t - 1));

}

function d3_ease_circle(t) {

return 1 - Math.sqrt(1 - t * t);

}

function d3_ease_elastic(a, p) {

var s;

if (arguments.length < 2) p = 0.45;

if (arguments.length < 1) { a = 1; s = p / 4; }

else s = p / (2 * Math.PI) * Math.asin(1 / a);

return function(t) {

return 1 + a * Math.pow(2, 10 * -t) * Math.sin((t - s) * 2 * Math.PI / p);

};

}

function d3_ease_back(s) {

if (!s) s = 1.70158;

return function(t) {

return t * t * ((s + 1) * t - s);

};

}

function d3_ease_bounce(t) {

return t < 1 / 2.75 ? 7.5625 * t * t

: t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75

: t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375

: 7.5625 * (t -= 2.625 / 2.75) * t + .984375;

}

d3.event = null;

function d3_eventCancel() {

d3.event.stopPropagation();

d3.event.preventDefault();

}

function d3_eventSource() {

var e = d3.event, s;

while (s = e.sourceEvent) e = s;

return e;

}

// Like d3.dispatch, but for custom events abstracting native UI events. These

// events have a target component (such as a brush), a target element (such as

// the svg:g element containing the brush) and the standard arguments `d` (the

// target element's data) and `i` (the selection index of the target element).

function d3_eventDispatch(target) {

var dispatch = new d3_dispatch,

i = 0,

n = arguments.length;

while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);

// Creates a dispatch context for the specified `thiz` (typically, the target

// DOM element that received the source event) and `argumentz` (typically, the

// data `d` and index `i` of the target element). The returned function can be

// used to dispatch an event to any registered listeners; the function takes a

// single argument as input, being the event to dispatch. The event must have

// a "type" attribute which corresponds to a type registered in the

// constructor. This context will automatically populate the "sourceEvent" and

// "target" attributes of the event, as well as setting the `d3.event` global

// for the duration of the notification.

dispatch.of = function(thiz, argumentz) {

return function(e1) {

try {

var e0 =

e1.sourceEvent = d3.event;

e1.target = target;

d3.event = e1;

dispatch[e1.type].apply(thiz, argumentz);

} finally {

d3.event = e0;

}

};

};

return dispatch;

}

d3.interpolate = function(a, b) {

var i = d3.interpolators.length, f;

while (--i >= 0 && !(f = d3.interpolators[i](a, b)));

return f;

};

d3.interpolateNumber = function(a, b) {

b -= a;

return function(t) { return a + b * t; };

};

d3.interpolateRound = function(a, b) {

b -= a;

return function(t) { return Math.round(a + b * t); };

};

d3.interpolateString = function(a, b) {

var m, // current match

i, // current index

j, // current index (for coallescing)

s0 = 0, // start index of current string prefix

s1 = 0, // end index of current string prefix

s = [], // string constants and placeholders

q = [], // number interpolators

n, // q.length

o;

// Reset our regular expression!

d3_interpolate_number.lastIndex = 0;

// Find all numbers in b.

for (i = 0; m = d3_interpolate_number.exec(b); ++i) {

if (m.index) s.push(b.substring(s0, s1 = m.index));

q.push({i: s.length, x: m[0]});

s.push(null);

s0 = d3_interpolate_number.lastIndex;

}

if (s0 < b.length) s.push(b.substring(s0));

// Find all numbers in a.

for (i = 0, n = q.length; (m = d3_interpolate_number.exec(a)) && i < n; ++i) {

o = q[i];

if (o.x == m[0]) { // The numbers match, so coallesce.

if (o.i) {

if (s[o.i + 1] == null) { // This match is followed by another number.

s[o.i - 1] += o.x;

s.splice(o.i, 1);

for (j = i + 1; j < n; ++j) q[j].i--;

} else { // This match is followed by a string, so coallesce twice.

s[o.i - 1] += o.x + s[o.i + 1];

s.splice(o.i, 2);

for (j = i + 1; j < n; ++j) q[j].i -= 2;

}

} else {

if (s[o.i + 1] == null) { // This match is followed by another number.

s[o.i] = o.x;

} else { // This match is followed by a string, so coallesce twice.

s[o.i] = o.x + s[o.i + 1];

s.splice(o.i + 1, 1);

for (j = i + 1; j < n; ++j) q[j].i--;

}

}

q.splice(i, 1);

n--;

i--;

} else {

o.x = d3.interpolateNumber(parseFloat(m[0]), parseFloat(o.x));

}

}

// Remove any numbers in b not found in a.

while (i < n) {

o = q.pop();

if (s[o.i + 1] == null) { // This match is followed by another number.

s[o.i] = o.x;

} else { // This match is followed by a string, so coallesce twice.

s[o.i] = o.x + s[o.i + 1];

s.splice(o.i + 1, 1);

}

n--;

}