ecomp-sdk-app/src/main/webapp/static/fusion/raptor/d3/js/d3.js

   1 (function(){d3 = {version: "1.8.5"}; // semver
   2 if (!Date.now) Date.now = function() {
   3   return +new Date();
   4 };
   5 if (!Object.create) Object.create = function(o) {
   6   /** @constructor */ function f() {}
   7   f.prototype = o;
   8   return new f();
   9 };
  10 var d3_array = d3_arraySlice; // conversion for NodeLists
  11
  12 function d3_arrayCopy(psuedoarray) {
  13   var i = -1, n = psuedoarray.length, array = [];
  14   while (++i < n) array.push(psuedoarray[i]);
  15   return array;
  16 }
  17
  18 function d3_arraySlice(psuedoarray) {
  19   return Array.prototype.slice.call(psuedoarray);
  20 }
  21
  22 try {
  23   d3_array(document.documentElement.childNodes)[0].nodeType;
  24 } catch(e) {
  25   d3_array = d3_arrayCopy;
  26 }
  27 function d3_functor(v) {
  28   return typeof v == "function" ? v : function() { return v; };
  29 }
  30 // A getter-setter method that preserves the appropriate `this` context.
  31 d3.rebind = function(object, method) {
  32   return function() {
  33     var x = method.apply(object, arguments);
  34     return arguments.length ? object : x;
  35   };
  36 };
  37 d3.ascending = function(a, b) {
  38   return a < b ? -1 : a > b ? 1 : 0;
  39 };
  40 d3.descending = function(a, b) {
  41   return b < a ? -1 : b > a ? 1 : 0;
  42 };
  43 d3.min = function(array, f) {
  44   var i = 0,
  45       n = array.length,
  46       a = array[0],
  47       b;
  48   if (arguments.length == 1) {
  49     while (++i < n) if (a > (b = array[i])) a = b;
  50   } else {
  51     a = f(array[0]);
  52     while (++i < n) if (a > (b = f(array[i]))) a = b;
  53   }
  54   return a;
  55 };
  56 d3.max = function(array, f) {
  57   var i = 0,
  58       n = array.length,
  59       a = array[0],
  60       b;
  61   if (arguments.length == 1) {
  62     while (++i < n) if (a < (b = array[i])) a = b;
  63   } else {
  64     a = f(a);
  65     while (++i < n) if (a < (b = f(array[i]))) a = b;
  66   }
  67   return a;
  68 };
  69 d3.nest = function() {
  70   var nest = {},
  71       keys = [],
  72       sortKeys = [],
  73       sortValues,
  74       rollup;
  75
  76   function map(array, depth) {
  77     if (depth >= keys.length) return rollup
  78         ? rollup.call(nest, array) : (sortValues
  79         ? array.sort(sortValues)
  80         : array);
  81
  82     var i = -1,
  83         n = array.length,
  84         key = keys[depth++],
  85         keyValue,
  86         object,
  87         o = {};
  88
  89     while (++i < n) {
  90       if ((keyValue = key(object = array[i])) in o) {
  91         o[keyValue].push(object);
  92       } else {
  93         o[keyValue] = [object];
  94       }
  95     }
  96
  97     for (keyValue in o) {
  98       o[keyValue] = map(o[keyValue], depth);
  99     }
 100
 101     return o;
 102   }
 103
 104   function entries(map, depth) {
 105     if (depth >= keys.length) return map;
 106
 107     var a = [],
 108         sortKey = sortKeys[depth++],
 109         key;
 110
 111     for (key in map) {
 112       a.push({key: key, values: entries(map[key], depth)});
 113     }
 114
 115     if (sortKey) a.sort(function(a, b) {
 116       return sortKey(a.key, b.key);
 117     });
 118
 119     return a;
 120   }
 121
 122   nest.map = function(array) {
 123     return map(array, 0);
 124   };
 125
 126   nest.entries = function(array) {
 127     return entries(map(array, 0), 0);
 128   };
 129
 130   nest.key = function(d) {
 131     keys.push(d);
 132     return nest;
 133   };
 134
 135   // Specifies the order for the most-recently specified key.
 136   // Note: only applies to entries. Map keys are unordered!
 137   nest.sortKeys = function(order) {
 138     sortKeys[keys.length - 1] = order;
 139     return nest;
 140   };
 141
 142   // Specifies the order for leaf values.
 143   // Applies to both maps and entries array.
 144   nest.sortValues = function(order) {
 145     sortValues = order;
 146     return nest;
 147   };
 148
 149   nest.rollup = function(f) {
 150     rollup = f;
 151     return nest;
 152   };
 153
 154   return nest;
 155 };
 156 d3.keys = function(map) {
 157   var keys = [];
 158   for (var key in map) keys.push(key);
 159   return keys;
 160 };
 161 d3.values = function(map) {
 162   var values = [];
 163   for (var key in map) values.push(map[key]);
 164   return values;
 165 };
 166 d3.entries = function(map) {
 167   var entries = [];
 168   for (var key in map) entries.push({key: key, value: map[key]});
 169   return entries;
 170 };
 171 d3.merge = function(arrays) {
 172   return Array.prototype.concat.apply([], arrays);
 173 };
 174 d3.split = function(array, f) {
 175   var arrays = [],
 176       values = [],
 177       value,
 178       i = -1,
 179       n = array.length;
 180   if (arguments.length < 2) f = d3_splitter;
 181   while (++i < n) {
 182     if (f.call(values, value = array[i], i)) {
 183       values = [];
 184     } else {
 185       if (!values.length) arrays.push(values);
 186       values.push(value);
 187     }
 188   }
 189   return arrays;
 190 };
 191
 192 function d3_splitter(d) {
 193   return d == null;
 194 }
 195 function d3_collapse(s) {
 196   return s.replace(/(^\s+)|(\s+$)/g, "").replace(/\s+/g, " ");
 197 }
 198 //
 199 // Note: assigning to the arguments array simultaneously changes the value of
 200 // the corresponding argument!
 201 //
 202 // TODO The `this` argument probably shouldn't be the first argument to the
 203 // callback, anyway, since it's redundant. However, that will require a major
 204 // version bump due to backwards compatibility, so I'm not changing it right
 205 // away.
 206 //
 207 function d3_call(callback) {
 208   callback.apply(this, (arguments[0] = this, arguments));
 209   return this;
 210 }
 211 /**
 212  * @param {number} start
 213  * @param {number=} stop
 214  * @param {number=} step
 215  */
 216 d3.range = function(start, stop, step) {
 217   if (arguments.length == 1) { stop = start; start = 0; }
 218   if (step == null) step = 1;
 219   if ((stop - start) / step == Infinity) throw new Error("infinite range");
 220   var range = [],
 221        i = -1,
 222        j;
 223   if (step < 0) while ((j = start + step * ++i) > stop) range.push(j);
 224   else while ((j = start + step * ++i) < stop) range.push(j);
 225   return range;
 226 };
 227 d3.requote = function(s) {
 228   return s.replace(d3_requote_re, "\\$&");
 229 };
 230
 231 var d3_requote_re = /[\\\^\$\*\+\?\[\]\(\)\.\{\}]/g;
 232 d3.xhr = function(url, mime, callback) {
 233   var req = new XMLHttpRequest();
 234   if (arguments.length < 3) callback = mime;
 235   else if (mime && req.overrideMimeType) req.overrideMimeType(mime);
 236   req.open("GET", url, true);
 237   req.onreadystatechange = function() {
 238     if (req.readyState == 4) callback(req.status < 300 ? req : null);
 239   };
 240   req.send(null);
 241 };
 242 d3.text = function(url, mime, callback) {
 243   function ready(req) {
 244     callback(req && req.responseText);
 245   }
 246   if (arguments.length < 3) {
 247     callback = mime;
 248     mime = null;
 249   }
 250   d3.xhr(url, mime, ready);
 251 };
 252 d3.json = function(url, callback) {
 253   d3.text(url, "application/json", function(text) {
 254     callback(text ? JSON.parse(text) : null);
 255   });
 256 };
 257 d3.html = function(url, callback) {
 258   d3.text(url, "text/html", function(text) {
 259     if (text != null) { // Treat empty string as valid HTML.
 260       var range = document.createRange();
 261       range.selectNode(document.body);
 262       text = range.createContextualFragment(text);
 263     }
 264     callback(text);
 265   });
 266 };
 267 d3.xml = function(url, mime, callback) {
 268   function ready(req) {
 269     callback(req && req.responseXML);
 270   }
 271   if (arguments.length < 3) {
 272     callback = mime;
 273     mime = null;
 274   }
 275   d3.xhr(url, mime, ready);
 276 };
 277 d3.ns = {
 278
 279   prefix: {
 280     svg: "http://www.w3.org/2000/svg",
 281     xhtml: "http://www.w3.org/1999/xhtml",
 282     xlink: "http://www.w3.org/1999/xlink",
 283     xml: "http://www.w3.org/XML/1998/namespace",
 284     xmlns: "http://www.w3.org/2000/xmlns/"
 285   },
 286
 287   qualify: function(name) {
 288     var i = name.indexOf(":");
 289     return i < 0 ? name : {
 290       space: d3.ns.prefix[name.substring(0, i)],
 291       local: name.substring(i + 1)
 292     };
 293   }
 294
 295 };
 296 /** @param {...string} types */
 297 d3.dispatch = function(types) {
 298   var dispatch = {},
 299       type;
 300   for (var i = 0, n = arguments.length; i < n; i++) {
 301     type = arguments[i];
 302     dispatch[type] = d3_dispatch(type);
 303   }
 304   return dispatch;
 305 };
 306
 307 function d3_dispatch(type) {
 308   var dispatch = {},
 309       listeners = [];
 310
 311   dispatch.add = function(listener) {
 312     for (var i = 0; i < listeners.length; i++) {
 313       if (listeners[i].listener == listener) return dispatch; // already registered
 314     }
 315     listeners.push({listener: listener, on: true});
 316     return dispatch;
 317   };
 318
 319   dispatch.remove = function(listener) {
 320     for (var i = 0; i < listeners.length; i++) {
 321       var l = listeners[i];
 322       if (l.listener == listener) {
 323         l.on = false;
 324         listeners = listeners.slice(0, i).concat(listeners.slice(i + 1));
 325         break;
 326       }
 327     }
 328     return dispatch;
 329   };
 330
 331   dispatch.dispatch = function() {
 332     var ls = listeners; // defensive reference
 333     for (var i = 0, n = ls.length; i < n; i++) {
 334       var l = ls[i];
 335       if (l.on) l.listener.apply(this, arguments);
 336     }
 337   };
 338
 339   return dispatch;
 340 };
 341 // TODO align, type
 342 d3.format = function(specifier) {
 343   var match = d3_format_re.exec(specifier),
 344       fill = match[1] || " ",
 345       sign = match[3] || "",
 346       zfill = match[5],
 347       width = +match[6],
 348       comma = match[7],
 349       precision = match[8],
 350       type = match[9];
 351   if (precision) precision = precision.substring(1);
 352   if (zfill) {
 353     fill = "0"; // TODO align = "=";
 354     if (comma) width -= Math.floor((width - 1) / 4);
 355   }
 356   if (type == "d") precision = "0";
 357   return function(value) {
 358     var number = +value,
 359         negative = (number < 0) && (number = -number) ? "\u2212" : sign;
 360
 361     // Return the empty string for floats formatted as ints.
 362     if ((type == "d") && (number % 1)) return "";
 363
 364     // Convert the input value to the desired precision.
 365     if (precision) value = number.toFixed(precision);
 366     else value = "" + number;
 367
 368     // If the fill character is 0, the sign and group is applied after the fill.
 369     if (zfill) {
 370       var length = value.length + negative.length;
 371       if (length < width) value = new Array(width - length + 1).join(fill) + value;
 372       if (comma) value = d3_format_group(value);
 373       value = negative + value;
 374     }
 375
 376     // Otherwise (e.g., space-filling), the sign and group is applied before.
 377     else {
 378       if (comma) value = d3_format_group(value);
 379       value = negative + value;
 380       var length = value.length;
 381       if (length < width) value = new Array(width - length + 1).join(fill) + value;
 382     }
 383
 384     return value;
 385   };
 386 };
 387
 388 // [[fill]align][sign][#][0][width][,][.precision][type]
 389 var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?(#)?(0)?([0-9]+)?(,)?(\.[0-9]+)?([a-zA-Z%])?/;
 390
 391 // Apply comma grouping for thousands.
 392 function d3_format_group(value) {
 393   var i = value.lastIndexOf("."),
 394       f = i >= 0 ? value.substring(i) : (i = value.length, ""),
 395       t = [];
 396   while (i > 0) t.push(value.substring(i -= 3, i + 3));
 397   return t.reverse().join(",") + f;
 398 }
 399 /*
 400  * TERMS OF USE - EASING EQUATIONS
 401  *
 402  * Open source under the BSD License.
 403  *
 404  * Copyright 2001 Robert Penner
 405  * All rights reserved.
 406  *
 407  * Redistribution and use in source and binary forms, with or without
 408  * modification, are permitted provided that the following conditions are met:
 409  *
 410  * - Redistributions of source code must retain the above copyright notice, this
 411  *   list of conditions and the following disclaimer.
 412  *
 413  * - Redistributions in binary form must reproduce the above copyright notice,
 414  *   this list of conditions and the following disclaimer in the documentation
 415  *   and/or other materials provided with the distribution.
 416  *
 417  * - Neither the name of the author nor the names of contributors may be used to
 418  *   endorse or promote products derived from this software without specific
 419  *   prior written permission.
 420  *
 421  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 422  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 423  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 424  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 425  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 426  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 427  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 428  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 429  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 430  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 431  * POSSIBILITY OF SUCH DAMAGE.
 432  */
 433
 434 var d3_ease_quad = d3_ease_poly(2),
 435     d3_ease_cubic = d3_ease_poly(3);
 436
 437 var d3_ease = {
 438   linear: function() { return d3_ease_linear; },
 439   poly: d3_ease_poly,
 440   quad: function() { return d3_ease_quad; },
 441   cubic: function() { return d3_ease_cubic; },
 442   sin: function() { return d3_ease_sin; },
 443   exp: function() { return d3_ease_exp; },
 444   circle: function() { return d3_ease_circle; },
 445   elastic: d3_ease_elastic,
 446   back: d3_ease_back,
 447   bounce: function() { return d3_ease_bounce; }
 448 };
 449
 450 var d3_ease_mode = {
 451   "in": function(f) { return f; },
 452   "out": d3_ease_reverse,
 453   "in-out": d3_ease_reflect,
 454   "out-in": function(f) { return d3_ease_reflect(d3_ease_reverse(f)); }
 455 };
 456
 457 d3.ease = function(name) {
 458   var i = name.indexOf("-"),
 459       t = i >= 0 ? name.substring(0, i) : name,
 460       m = i >= 0 ? name.substring(i + 1) : "in";
 461   return d3_ease_mode[m](d3_ease[t].apply(null, Array.prototype.slice.call(arguments, 1)));
 462 };
 463
 464 function d3_ease_reverse(f) {
 465   return function(t) {
 466     return 1 - f(1 - t);
 467   };
 468 }
 469
 470 function d3_ease_reflect(f) {
 471   return function(t) {
 472     return .5 * (t < .5 ? f(2 * t) : (2 - f(2 - 2 * t)));
 473   };
 474 }
 475
 476 function d3_ease_linear(t) {
 477   return t;
 478 }
 479
 480 function d3_ease_poly(e) {
 481   return function(t) {
 482     return Math.pow(t, e);
 483   }
 484 }
 485
 486 function d3_ease_sin(t) {
 487   return 1 - Math.cos(t * Math.PI / 2);
 488 }
 489
 490 function d3_ease_exp(t) {
 491   return t ? Math.pow(2, 10 * (t - 1)) - 1e-3 : 0;
 492 }
 493
 494 function d3_ease_circle(t) {
 495   return 1 - Math.sqrt(1 - t * t);
 496 }
 497
 498 function d3_ease_elastic(a, p) {
 499   var s;
 500   if (arguments.length < 2) p = 0.45;
 501   if (arguments.length < 1) { a = 1; s = p / 4; }
 502   else s = p / (2 * Math.PI) * Math.asin(1 / a);
 503   return function(t) {
 504     return 1 + a * Math.pow(2, 10 * -t) * Math.sin((t - s) * 2 * Math.PI / p);
 505   };
 506 }
 507
 508 function d3_ease_back(s) {
 509   if (!s) s = 1.70158;
 510   return function(t) {
 511     return t * t * ((s + 1) * t - s);
 512   };
 513 }
 514
 515 function d3_ease_bounce(t) {
 516   return t < 1 / 2.75 ? 7.5625 * t * t
 517       : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75
 518       : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375
 519       : 7.5625 * (t -= 2.625 / 2.75) * t + .984375;
 520 }
 521 d3.event = null;
 522 d3.interpolate = function(a, b) {
 523   if (typeof b == "number") return d3.interpolateNumber(+a, b);
 524   if (typeof b == "string") {
 525     return (b in d3_rgb_names) || /^(#|rgb\(|hsl\()/.test(b)
 526         ? d3.interpolateRgb(String(a), b)
 527         : d3.interpolateString(String(a), b);
 528   }
 529   if (b instanceof Array) return d3.interpolateArray(a, b);
 530   return d3.interpolateObject(a, b);
 531 };
 532
 533 d3.interpolateNumber = function(a, b) {
 534   b -= a;
 535   return function(t) { return a + b * t; };
 536 };
 537
 538 d3.interpolateRound = function(a, b) {
 539   b -= a;
 540   return function(t) { return Math.round(a + b * t); };
 541 };
 542
 543 d3.interpolateString = function(a, b) {
 544   var m, // current match
 545       i, // current index
 546       j, // current index (for coallescing)
 547       s0 = 0, // start index of current string prefix
 548       s1 = 0, // end index of current string prefix
 549       s = [], // string constants and placeholders
 550       q = [], // number interpolators
 551       n, // q.length
 552       o;
 553
 554   // Find all numbers in b.
 555   for (i = 0; m = d3_interpolate_number.exec(b); ++i) {
 556     if (m.index) s.push(b.substring(s0, s1 = m.index));
 557     q.push({i: s.length, x: m[0]});
 558     s.push(null);
 559     s0 = d3_interpolate_number.lastIndex;
 560   }
 561   if (s0 < b.length) s.push(b.substring(s0));
 562
 563   // Find all numbers in a.
 564   for (i = 0, n = q.length; (m = d3_interpolate_number.exec(a)) && i < n; ++i) {
 565     o = q[i];
 566     if (o.x == m[0]) { // The numbers match, so coallesce.
 567       if (o.i) {
 568         if (s[o.i + 1] == null) { // This match is followed by another number.
 569           s[o.i - 1] += o.x;
 570           s.splice(o.i, 1);
 571           for (j = i + 1; j < n; ++j) q[j].i--;
 572         } else { // This match is followed by a string, so coallesce twice.
 573           s[o.i - 1] += o.x + s[o.i + 1];
 574           s.splice(o.i, 2);
 575           for (j = i + 1; j < n; ++j) q[j].i -= 2;
 576         }
 577       } else {
 578           if (s[o.i + 1] == null) { // This match is followed by another number.
 579           s[o.i] = o.x;
 580         } else { // This match is followed by a string, so coallesce twice.
 581           s[o.i] = o.x + s[o.i + 1];
 582           s.splice(o.i + 1, 1);
 583           for (j = i + 1; j < n; ++j) q[j].i--;
 584         }
 585       }
 586       q.splice(i, 1);
 587       n--;
 588       i--;
 589     } else {
 590       o.x = d3.interpolateNumber(parseFloat(m[0]), parseFloat(o.x));
 591     }
 592   }
 593
 594   // Remove any numbers in b not found in a.
 595   while (i < n) {
 596     o = q.pop();
 597     if (s[o.i + 1] == null) { // This match is followed by another number.
 598       s[o.i] = o.x;
 599     } else { // This match is followed by a string, so coallesce twice.
 600       s[o.i] = o.x + s[o.i + 1];
 601       s.splice(o.i + 1, 1);
 602     }
 603     n--;
 604   }
 605
 606   // Special optimization for only a single match.
 607   if (s.length == 1) {
 608     return s[0] == null ? q[0].x : function() { return b; };
 609   }
 610
 611   // Otherwise, interpolate each of the numbers and rejoin the string.
 612   return function(t) {
 613     for (i = 0; i < n; ++i) s[(o = q[i]).i] = o.x(t);
 614     return s.join("");
 615   };
 616 };
 617
 618 d3.interpolateRgb = function(a, b) {
 619   a = d3.rgb(a);
 620   b = d3.rgb(b);
 621   var ar = a.r,
 622       ag = a.g,
 623       ab = a.b,
 624       br = b.r - ar,
 625       bg = b.g - ag,
 626       bb = b.b - ab;
 627   return function(t) {
 628     return "rgb(" + Math.round(ar + br * t)
 629         + "," + Math.round(ag + bg * t)
 630         + "," + Math.round(ab + bb * t)
 631         + ")";
 632   };
 633 };
 634
 635 // interpolates HSL space, but outputs RGB string (for compatibility)
 636 d3.interpolateHsl = function(a, b) {
 637   a = d3.hsl(a);
 638   b = d3.hsl(b);
 639   var h0 = a.h,
 640       s0 = a.s,
 641       l0 = a.l,
 642       h1 = b.h - h0,
 643       s1 = b.s - s0,
 644       l1 = b.l - l0;
 645   return function(t) {
 646     return d3_hsl_rgb(h0 + h1 * t, s0 + s1 * t, l0 + l1 * t).toString();
 647   };
 648 };
 649
 650 d3.interpolateArray = function(a, b) {
 651   var x = [],
 652       c = [],
 653       na = a.length,
 654       nb = b.length,
 655       n0 = Math.min(a.length, b.length),
 656       i;
 657   for (i = 0; i < n0; ++i) x.push(d3.interpolate(a[i], b[i]));
 658   for (; i < na; ++i) c[i] = a[i];
 659   for (; i < nb; ++i) c[i] = b[i];
 660   return function(t) {
 661     for (i = 0; i < n0; ++i) c[i] = x[i](t);
 662     return c;
 663   };
 664 };
 665
 666 d3.interpolateObject = function(a, b) {
 667   var i = {},
 668       c = {},
 669       k;
 670   for (k in a) {
 671     if (k in b) {
 672       i[k] = d3_interpolateByName(k)(a[k], b[k]);
 673     } else {
 674       c[k] = a[k];
 675     }
 676   }
 677   for (k in b) {
 678     if (!(k in a)) {
 679       c[k] = b[k];
 680     }
 681   }
 682   return function(t) {
 683     for (k in i) c[k] = i[k](t);
 684     return c;
 685   };
 686 }
 687
 688 var d3_interpolate_number = /[-+]?(?:\d+\.\d+|\d+\.|\.\d+|\d+)(?:[eE][-]?\d+)?/g,
 689     d3_interpolate_digits = /[-+]?\d*\.?\d*(?:[eE][-]?\d+)?(.*)/,
 690     d3_interpolate_rgb = {background: 1, fill: 1, stroke: 1};
 691
 692 function d3_interpolateByName(n) {
 693   return n in d3_interpolate_rgb || /\bcolor\b/.test(n)
 694       ? d3.interpolateRgb
 695       : d3.interpolate;
 696 }
 697 /**
 698  * @param {number=} g
 699  * @param {number=} b
 700  */
 701 d3.rgb = function(r, g, b) {
 702   return arguments.length == 1
 703       ? d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb)
 704       : d3_rgb(~~r, ~~g, ~~b);
 705 };
 706
 707 function d3_rgb(r, g, b) {
 708   return {r: r, g: g, b: b, toString: d3_rgb_format};
 709 }
 710
 711 /** @this d3_rgb */
 712 function d3_rgb_format() {
 713   return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b);
 714 }
 715
 716 function d3_rgb_hex(v) {
 717   return v < 0x10 ? "0" + v.toString(16) : v.toString(16);
 718 }
 719
 720 function d3_rgb_parse(format, rgb, hsl) {
 721   var r = 0, // red channel; int in [0, 255]
 722       g = 0, // green channel; int in [0, 255]
 723       b = 0, // blue channel; int in [0, 255]
 724       m1, // CSS color specification match
 725       m2, // CSS color specification type (e.g., rgb)
 726       name;
 727
 728   /* Handle hsl, rgb. */
 729   m1 = /([a-z]+)\((.*)\)/i.exec(format);
 730   if (m1) {
 731     m2 = m1[2].split(",");
 732     switch (m1[1]) {
 733       case "hsl": {
 734         return hsl(
 735           parseFloat(m2[0]), // degrees
 736           parseFloat(m2[1]) / 100, // percentage
 737           parseFloat(m2[2]) / 100 // percentage
 738         );
 739       }
 740       case "rgb": {
 741         return rgb(
 742           d3_rgb_parseNumber(m2[0]),
 743           d3_rgb_parseNumber(m2[1]),
 744           d3_rgb_parseNumber(m2[2])
 745         );
 746       }
 747     }
 748   }
 749
 750   /* Named colors. */
 751   if (name = d3_rgb_names[format]) return rgb(name.r, name.g, name.b);
 752
 753   /* Hexadecimal colors: #rgb and #rrggbb. */
 754   if (format != null && format.charAt(0) == "#") {
 755     if (format.length == 4) {
 756       r = format.charAt(1); r += r;
 757       g = format.charAt(2); g += g;
 758       b = format.charAt(3); b += b;
 759     } else if (format.length == 7) {
 760       r = format.substring(1, 3);
 761       g = format.substring(3, 5);
 762       b = format.substring(5, 7);
 763     }
 764     r = parseInt(r, 16);
 765     g = parseInt(g, 16);
 766     b = parseInt(b, 16);
 767   }
 768
 769   return rgb(r, g, b);
 770 }
 771
 772 function d3_rgb_hsl(r, g, b) {
 773   var min = Math.min(r /= 255, g /= 255, b /= 255),
 774       max = Math.max(r, g, b),
 775       d = max - min,
 776       h,
 777       s,
 778       l = (max + min) / 2;
 779   if (d) {
 780     s = l < .5 ? d / (max + min) : d / (2 - max - min);
 781     if (r == max) h = (g - b) / d + (g < b ? 6 : 0);
 782     else if (g == max) h = (b - r) / d + 2;
 783     else h = (r - g) / d + 4;
 784     h *= 60;
 785   } else {
 786     s = h = 0;
 787   }
 788   return d3_hsl(h, s, l);
 789 }
 790
 791 function d3_rgb_parseNumber(c) { // either integer or percentage
 792   var f = parseFloat(c);
 793   return c.charAt(c.length - 1) == "%" ? Math.round(f * 2.55) : f;
 794 }
 795
 796 var d3_rgb_names = {
 797   aliceblue: "#f0f8ff",
 798   antiquewhite: "#faebd7",
 799   aqua: "#00ffff",
 800   aquamarine: "#7fffd4",
 801   azure: "#f0ffff",
 802   beige: "#f5f5dc",
 803   bisque: "#ffe4c4",
 804   black: "#000000",
 805   blanchedalmond: "#ffebcd",
 806   blue: "#0000ff",
 807   blueviolet: "#8a2be2",
 808   brown: "#a52a2a",
 809   burlywood: "#deb887",
 810   cadetblue: "#5f9ea0",
 811   chartreuse: "#7fff00",
 812   chocolate: "#d2691e",
 813   coral: "#ff7f50",
 814   cornflowerblue: "#6495ed",
 815   cornsilk: "#fff8dc",
 816   crimson: "#dc143c",
 817   cyan: "#00ffff",
 818   darkblue: "#00008b",
 819   darkcyan: "#008b8b",
 820   darkgoldenrod: "#b8860b",
 821   darkgray: "#a9a9a9",
 822   darkgreen: "#006400",
 823   darkgrey: "#a9a9a9",
 824   darkkhaki: "#bdb76b",
 825   darkmagenta: "#8b008b",
 826   darkolivegreen: "#556b2f",
 827   darkorange: "#ff8c00",
 828   darkorchid: "#9932cc",
 829   darkred: "#8b0000",
 830   darksalmon: "#e9967a",
 831   darkseagreen: "#8fbc8f",
 832   darkslateblue: "#483d8b",
 833   darkslategray: "#2f4f4f",
 834   darkslategrey: "#2f4f4f",
 835   darkturquoise: "#00ced1",
 836   darkviolet: "#9400d3",
 837   deeppink: "#ff1493",
 838   deepskyblue: "#00bfff",
 839   dimgray: "#696969",
 840   dimgrey: "#696969",
 841   dodgerblue: "#1e90ff",
 842   firebrick: "#b22222",
 843   floralwhite: "#fffaf0",
 844   forestgreen: "#228b22",
 845   fuchsia: "#ff00ff",
 846   gainsboro: "#dcdcdc",
 847   ghostwhite: "#f8f8ff",
 848   gold: "#ffd700",
 849   goldenrod: "#daa520",
 850   gray: "#808080",
 851   green: "#008000",
 852   greenyellow: "#adff2f",
 853   grey: "#808080",
 854   honeydew: "#f0fff0",
 855   hotpink: "#ff69b4",
 856   indianred: "#cd5c5c",
 857   indigo: "#4b0082",
 858   ivory: "#fffff0",
 859   khaki: "#f0e68c",
 860   lavender: "#e6e6fa",
 861   lavenderblush: "#fff0f5",
 862   lawngreen: "#7cfc00",
 863   lemonchiffon: "#fffacd",
 864   lightblue: "#add8e6",
 865   lightcoral: "#f08080",
 866   lightcyan: "#e0ffff",
 867   lightgoldenrodyellow: "#fafad2",
 868   lightgray: "#d3d3d3",
 869   lightgreen: "#90ee90",
 870   lightgrey: "#d3d3d3",
 871   lightpink: "#ffb6c1",
 872   lightsalmon: "#ffa07a",
 873   lightseagreen: "#20b2aa",
 874   lightskyblue: "#87cefa",
 875   lightslategray: "#778899",
 876   lightslategrey: "#778899",
 877   lightsteelblue: "#b0c4de",
 878   lightyellow: "#ffffe0",
 879   lime: "#00ff00",
 880   limegreen: "#32cd32",
 881   linen: "#faf0e6",
 882   magenta: "#ff00ff",
 883   maroon: "#800000",
 884   mediumaquamarine: "#66cdaa",
 885   mediumblue: "#0000cd",
 886   mediumorchid: "#ba55d3",
 887   mediumpurple: "#9370db",
 888   mediumseagreen: "#3cb371",
 889   mediumslateblue: "#7b68ee",
 890   mediumspringgreen: "#00fa9a",
 891   mediumturquoise: "#48d1cc",
 892   mediumvioletred: "#c71585",
 893   midnightblue: "#191970",
 894   mintcream: "#f5fffa",
 895   mistyrose: "#ffe4e1",
 896   moccasin: "#ffe4b5",
 897   navajowhite: "#ffdead",
 898   navy: "#000080",
 899   oldlace: "#fdf5e6",
 900   olive: "#808000",
 901   olivedrab: "#6b8e23",
 902   orange: "#ffa500",
 903   orangered: "#ff4500",
 904   orchid: "#da70d6",
 905   palegoldenrod: "#eee8aa",
 906   palegreen: "#98fb98",
 907   paleturquoise: "#afeeee",
 908   palevioletred: "#db7093",
 909   papayawhip: "#ffefd5",
 910   peachpuff: "#ffdab9",
 911   peru: "#cd853f",
 912   pink: "#ffc0cb",
 913   plum: "#dda0dd",
 914   powderblue: "#b0e0e6",
 915   purple: "#800080",
 916   red: "#ff0000",
 917   rosybrown: "#bc8f8f",
 918   royalblue: "#4169e1",
 919   saddlebrown: "#8b4513",
 920   salmon: "#fa8072",
 921   sandybrown: "#f4a460",
 922   seagreen: "#2e8b57",
 923   seashell: "#fff5ee",
 924   sienna: "#a0522d",
 925   silver: "#c0c0c0",
 926   skyblue: "#87ceeb",
 927   slateblue: "#6a5acd",
 928   slategray: "#708090",
 929   slategrey: "#708090",
 930   snow: "#fffafa",
 931   springgreen: "#00ff7f",
 932   steelblue: "#4682b4",
 933   tan: "#d2b48c",
 934   teal: "#008080",
 935   thistle: "#d8bfd8",
 936   tomato: "#ff6347",
 937   turquoise: "#40e0d0",
 938   violet: "#ee82ee",
 939   wheat: "#f5deb3",
 940   white: "#ffffff",
 941   whitesmoke: "#f5f5f5",
 942   yellow: "#ffff00",
 943   yellowgreen: "#9acd32"
 944 };
 945
 946 for (var d3_rgb_name in d3_rgb_names) {
 947   d3_rgb_names[d3_rgb_name] = d3_rgb_parse(
 948       d3_rgb_names[d3_rgb_name],
 949       d3_rgb,
 950       d3_hsl_rgb);
 951 }
 952 /**
 953  * @param {number=} s
 954  * @param {number=} l
 955  */
 956 d3.hsl = function(h, s, l) {
 957   return arguments.length == 1
 958       ? d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl)
 959       : d3_hsl(+h, +s, +l);
 960 };
 961
 962 function d3_hsl(h, s, l) {
 963   return {h: h, s: s, l: l, toString: d3_hsl_format};
 964 }
 965
 966 /** @this d3_hsl */
 967 function d3_hsl_format() {
 968   return "hsl(" + this.h + "," + this.s * 100 + "%," + this.l * 100 + "%)";
 969 }
 970
 971 function d3_hsl_rgb(h, s, l) {
 972   var m1,
 973       m2;
 974
 975   /* Some simple corrections for h, s and l. */
 976   h = h % 360; if (h < 0) h += 360;
 977   s = s < 0 ? 0 : s > 1 ? 1 : s;
 978   l = l < 0 ? 0 : l > 1 ? 1 : l;
 979
 980   /* From FvD 13.37, CSS Color Module Level 3 */
 981   m2 = l <= .5 ? l * (1 + s) : l + s - l * s;
 982   m1 = 2 * l - m2;
 983
 984   function v(h) {
 985     if (h > 360) h -= 360;
 986     else if (h < 0) h += 360;
 987     if (h < 60) return m1 + (m2 - m1) * h / 60;
 988     if (h < 180) return m2;
 989     if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60;
 990     return m1;
 991   }
 992
 993   function vv(h) {
 994     return Math.round(v(h) * 255);
 995   }
 996
 997   return d3_rgb(vv(h + 120), vv(h), vv(h - 120));
 998 }
 999 var d3_select = function(s, n) { return n.querySelector(s); },
1000     d3_selectAll = function(s, n) { return d3_array(n.querySelectorAll(s)); };
1001
1002 // Use Sizzle, if available.
1003 if (typeof Sizzle == "function") {
1004   d3_select = function(s, n) { return Sizzle(s, n)[0]; };
1005   d3_selectAll = function(s, n) { return Sizzle.uniqueSort(Sizzle(s, n)); };
1006 }
1007
1008 var d3_root = d3_selection([[document]]);
1009 d3_root[0].parentNode = document.documentElement;
1010
1011 // TODO fast singleton implementation!
1012 d3.select = function(selector) {
1013   return typeof selector == "string"
1014       ? d3_root.select(selector)
1015       : d3_selection([[selector]]); // assume node
1016 };
1017
1018 d3.selectAll = function(selector) {
1019   return typeof selector == "string"
1020       ? d3_root.selectAll(selector)
1021       : d3_selection([d3_array(selector)]); // assume node[]
1022 };
1023
1024 function d3_selection(groups) {
1025
1026   function select(select) {
1027     var subgroups = [],
1028         subgroup,
1029         subnode,
1030         group,
1031         node;
1032     for (var j = 0, m = groups.length; j < m; j++) {
1033       group = groups[j];
1034       subgroups.push(subgroup = []);
1035       subgroup.parentNode = group.parentNode;
1036       subgroup.parentData = group.parentData;
1037       for (var i = 0, n = group.length; i < n; i++) {
1038         if (node = group[i]) {
1039           subgroup.push(subnode = select(node));
1040           if (subnode && "__data__" in node) subnode.__data__ = node.__data__;
1041         } else {
1042           subgroup.push(null);
1043         }
1044       }
1045     }
1046     return d3_selection(subgroups);
1047   }
1048
1049   function selectAll(selectAll) {
1050     var subgroups = [],
1051         subgroup,
1052         group,
1053         node;
1054     for (var j = 0, m = groups.length; j < m; j++) {
1055       group = groups[j];
1056       for (var i = 0, n = group.length; i < n; i++) {
1057         if (node = group[i]) {
1058           subgroups.push(subgroup = selectAll(node));
1059           subgroup.parentNode = node;
1060           subgroup.parentData = node.__data__;
1061         }
1062       }
1063     }
1064     return d3_selection(subgroups);
1065   }
1066
1067   // TODO select(function)?
1068   groups.select = function(selector) {
1069     return select(function(node) {
1070       return d3_select(selector, node);
1071     });
1072   };
1073
1074   // TODO selectAll(function)?
1075   groups.selectAll = function(selector) {
1076     return selectAll(function(node) {
1077       return d3_selectAll(selector, node);
1078     });
1079   };
1080
1081   // TODO preserve null elements to maintain index?
1082   groups.filter = function(filter) {
1083     var subgroups = [],
1084         subgroup,
1085         group,
1086         node;
1087     for (var j = 0, m = groups.length; j < m; j++) {
1088       group = groups[j];
1089       subgroups.push(subgroup = []);
1090       subgroup.parentNode = group.parentNode;
1091       subgroup.parentData = group.parentData;
1092       for (var i = 0, n = group.length; i < n; i++) {
1093         if ((node = group[i]) && filter.call(node, node.__data__, i)) {
1094           subgroup.push(node);
1095         }
1096       }
1097     }
1098     return d3_selection(subgroups);
1099   };
1100
1101   groups.map = function(map) {
1102     var group,
1103         node;
1104     for (var j = 0, m = groups.length; j < m; j++) {
1105       group = groups[j];
1106       for (var i = 0, n = group.length; i < n; i++) {
1107         if (node = group[i]) node.__data__ = map.call(node, node.__data__, i);
1108       }
1109     }
1110     return groups;
1111   };
1112
1113   // TODO data(null) for clearing data?
1114   groups.data = function(data, join) {
1115     var enter = [],
1116         update = [],
1117         exit = [];
1118
1119     function bind(group, groupData) {
1120       var i = 0,
1121           n = group.length,
1122           m = groupData.length,
1123           n0 = Math.min(n, m),
1124           n1 = Math.max(n, m),
1125           updateNodes = [],
1126           enterNodes = [],
1127           exitNodes = [],
1128           node,
1129           nodeData;
1130
1131       function enterNode(data) {
1132         return {__data__: data};
1133       }
1134
1135       if (join) {
1136         var nodeByKey = {},
1137             exitData = [],
1138             keys = [],
1139             key,
1140             j = groupData.length;
1141
1142         for (i = 0; i < n; i++) {
1143           key = join.call(node = group[i], node.__data__, i);
1144           if (key in nodeByKey) {
1145             exitNodes[j++] = group[i];
1146           } else {
1147             nodeByKey[key] = node;
1148             keys.push(key);
1149           }
1150         }
1151
1152         for (i = 0; i < m; i++) {
1153           node = nodeByKey[key = join.call(groupData, nodeData = groupData[i], i)];
1154           if (node) {
1155             node.__data__ = nodeData;
1156             updateNodes[i] = node;
1157             enterNodes[i] = exitNodes[i] = null;
1158           } else {
1159             enterNodes[i] = enterNode(nodeData),
1160             updateNodes[i] = exitNodes[i] = null;
1161           }
1162           delete nodeByKey[key];
1163         }
1164
1165         for (i = 0; i < n; i++) {
1166           if (keys[i] in nodeByKey) {
1167             exitNodes[i] = group[i];
1168           }
1169         }
1170       } else {
1171         for (; i < n0; i++) {
1172           node = group[i];
1173           nodeData = groupData[i];
1174           if (node) {
1175             node.__data__ = nodeData;
1176             updateNodes[i] = node;
1177             enterNodes[i] = exitNodes[i] = null;
1178           } else {
1179             enterNodes[i] = enterNode(nodeData);
1180             updateNodes[i] = exitNodes[i] = null;
1181           }
1182         }
1183         for (; i < m; i++) {
1184           enterNodes[i] = enterNode(groupData[i]);
1185           updateNodes[i] = exitNodes[i] = null;
1186         }
1187         for (; i < n1; i++) {
1188           exitNodes[i] = group[i];
1189           enterNodes[i] = updateNodes[i] = null;
1190         }
1191       }
1192
1193       enterNodes.parentNode
1194           = updateNodes.parentNode
1195           = exitNodes.parentNode
1196           = group.parentNode;
1197
1198       enterNodes.parentData
1199           = updateNodes.parentData
1200           = exitNodes.parentData
1201           = group.parentData;
1202
1203       enter.push(enterNodes);
1204       update.push(updateNodes);
1205       exit.push(exitNodes);
1206     }
1207
1208     var i = -1,
1209         n = groups.length,
1210         group;
1211     if (typeof data == "function") {
1212       while (++i < n) {
1213         bind(group = groups[i], data.call(group, group.parentData, i));
1214       }
1215     } else {
1216       while (++i < n) {
1217         bind(group = groups[i], data);
1218       }
1219     }
1220
1221     var selection = d3_selection(update);
1222     selection.enter = function() {
1223       return d3_selectionEnter(enter);
1224     };
1225     selection.exit = function() {
1226       return d3_selection(exit);
1227     };
1228     return selection;
1229   };
1230
1231   // TODO mask forEach? or rename for eachData?
1232   // TODO offer the same semantics for map, reduce, etc.?
1233   groups.each = function(callback) {
1234     for (var j = 0, m = groups.length; j < m; j++) {
1235       var group = groups[j];
1236       for (var i = 0, n = group.length; i < n; i++) {
1237         var node = group[i];
1238         if (node) callback.call(node, node.__data__, i);
1239       }
1240     }
1241     return groups;
1242   };
1243
1244   function first(callback) {
1245     for (var j = 0, m = groups.length; j < m; j++) {
1246       var group = groups[j];
1247       for (var i = 0, n = group.length; i < n; i++) {
1248         var node = group[i];
1249         if (node) return callback.call(node, node.__data__, i);
1250       }
1251     }
1252     return null;
1253   }
1254
1255   groups.empty = function() {
1256     return !first(function() { return true; });
1257   };
1258
1259   groups.node = function() {
1260     return first(function() { return this; });
1261   };
1262
1263   groups.attr = function(name, value) {
1264     name = d3.ns.qualify(name);
1265
1266     // If no value is specified, return the first value.
1267     if (arguments.length < 2) {
1268       return first(name.local
1269           ? function() { return this.getAttributeNS(name.space, name.local); }
1270           : function() { return this.getAttribute(name); });
1271     }
1272
1273     /** @this {Element} */
1274     function attrNull() {
1275       this.removeAttribute(name);
1276     }
1277
1278     /** @this {Element} */
1279     function attrNullNS() {
1280       this.removeAttributeNS(name.space, name.local);
1281     }
1282
1283     /** @this {Element} */
1284     function attrConstant() {
1285       this.setAttribute(name, value);
1286     }
1287
1288     /** @this {Element} */
1289     function attrConstantNS() {
1290       this.setAttributeNS(name.space, name.local, value);
1291     }
1292
1293     /** @this {Element} */
1294     function attrFunction() {
1295       var x = value.apply(this, arguments);
1296       if (x == null) this.removeAttribute(name);
1297       else this.setAttribute(name, x);
1298     }
1299
1300     /** @this {Element} */
1301     function attrFunctionNS() {
1302       var x = value.apply(this, arguments);
1303       if (x == null) this.removeAttributeNS(name.space, name.local);
1304       else this.setAttributeNS(name.space, name.local, x);
1305     }
1306
1307     return groups.each(value == null
1308         ? (name.local ? attrNullNS : attrNull) : (typeof value == "function"
1309         ? (name.local ? attrFunctionNS : attrFunction)
1310         : (name.local ? attrConstantNS : attrConstant)));
1311   };
1312
1313   groups.classed = function(name, value) {
1314     var re = new RegExp("(^|\\s+)" + d3.requote(name) + "(\\s+|$)", "g");
1315
1316     // If no value is specified, return the first value.
1317     if (arguments.length < 2) {
1318       return first(function() {
1319         re.lastIndex = 0;
1320         return re.test(this.className);
1321       });
1322     }
1323
1324     /** @this {Element} */
1325     function classedAdd() {
1326       var classes = this.className;
1327       re.lastIndex = 0;
1328       if (!re.test(classes)) {
1329         this.className = d3_collapse(classes + " " + name);
1330       }
1331     }
1332
1333     /** @this {Element} */
1334     function classedRemove() {
1335       var classes = d3_collapse(this.className.replace(re, " "));
1336       this.className = classes.length ? classes : null;
1337     }
1338
1339     /** @this {Element} */
1340     function classedFunction() {
1341       (value.apply(this, arguments)
1342           ? classedAdd
1343           : classedRemove).call(this);
1344     }
1345
1346     return groups.each(typeof value == "function"
1347         ? classedFunction : value
1348         ? classedAdd
1349         : classedRemove);
1350   };
1351
1352   groups.style = function(name, value, priority) {
1353     if (arguments.length < 3) priority = null;
1354
1355     // If no value is specified, return the first value.
1356     if (arguments.length < 2) {
1357       return first(function() {
1358         return window.getComputedStyle(this, null).getPropertyValue(name);
1359       });
1360     }
1361
1362     /** @this {Element} */
1363     function styleNull() {
1364       this.style.removeProperty(name);
1365     }
1366
1367     /** @this {Element} */
1368     function styleConstant() {
1369       this.style.setProperty(name, value, priority);
1370     }
1371
1372     /** @this {Element} */
1373     function styleFunction() {
1374       var x = value.apply(this, arguments);
1375       if (x == null) this.style.removeProperty(name);
1376       else this.style.setProperty(name, x, priority);
1377     }
1378
1379     return groups.each(value == null
1380         ? styleNull : (typeof value == "function"
1381         ? styleFunction : styleConstant));
1382   };
1383
1384   groups.property = function(name, value) {
1385     name = d3.ns.qualify(name);
1386
1387     // If no value is specified, return the first value.
1388     if (arguments.length < 2) {
1389       return first(function() {
1390         return this[name];
1391       });
1392     }
1393
1394     /** @this {Element} */
1395     function propertyNull() {
1396       delete this[name];
1397     }
1398
1399     /** @this {Element} */
1400     function propertyConstant() {
1401       this[name] = value;
1402     }
1403
1404     /** @this {Element} */
1405     function propertyFunction() {
1406       var x = value.apply(this, arguments);
1407       if (x == null) delete this[name];
1408       else this[name] = x;
1409     }
1410
1411     return groups.each(value == null
1412         ? propertyNull : (typeof value == "function"
1413         ? propertyFunction : propertyConstant));
1414   };
1415
1416   groups.text = function(value) {
1417
1418     // If no value is specified, return the first value.
1419     if (arguments.length < 1) {
1420       return first(function() {
1421         return this.textContent;
1422       });
1423     }
1424
1425     /** @this {Element} */
1426     function textNull() {
1427       while (this.lastChild) this.removeChild(this.lastChild);
1428     }
1429
1430     /** @this {Element} */
1431     function textConstant() {
1432       this.appendChild(document.createTextNode(value));
1433     }
1434
1435     /** @this {Element} */
1436     function textFunction() {
1437       var x = value.apply(this, arguments);
1438       if (x != null) this.appendChild(document.createTextNode(x));
1439     }
1440
1441     groups.each(textNull);
1442     return value == null ? groups
1443         : groups.each(typeof value == "function"
1444         ? textFunction : textConstant);
1445   };
1446
1447   groups.html = function(value) {
1448
1449     // If no value is specified, return the first value.
1450     if (arguments.length < 1) {
1451       return first(function() {
1452         return this.innerHTML;
1453       });
1454     }
1455
1456     /** @this {Element} */
1457     function htmlConstant() {
1458       this.innerHTML = value;
1459     }
1460
1461     /** @this {Element} */
1462     function htmlFunction() {
1463       this.innerHTML = value.apply(this, arguments);
1464     }
1465
1466     return groups.each(typeof value == "function"
1467         ? htmlFunction : htmlConstant);
1468   };
1469
1470   // TODO append(node)?
1471   // TODO append(function)?
1472   groups.append = function(name) {
1473     name = d3.ns.qualify(name);
1474
1475     function append(node) {
1476       return node.appendChild(document.createElement(name));
1477     }
1478
1479     function appendNS(node) {
1480       return node.appendChild(document.createElementNS(name.space, name.local));
1481     }
1482
1483     return select(name.local ? appendNS : append);
1484   };
1485
1486   // TODO insert(node, function)?
1487   // TODO insert(function, string)?
1488   // TODO insert(function, function)?
1489   groups.insert = function(name, before) {
1490     name = d3.ns.qualify(name);
1491
1492     function insert(node) {
1493       return node.insertBefore(
1494           document.createElement(name),
1495           d3_select(before, node));
1496     }
1497
1498     function insertNS(node) {
1499       return node.insertBefore(
1500           document.createElementNS(name.space, name.local),
1501           d3_select(before, node));
1502     }
1503
1504     return select(name.local ? insertNS : insert);
1505   };
1506
1507   // TODO remove(selector)?
1508   // TODO remove(node)?
1509   // TODO remove(function)?
1510   groups.remove = function() {
1511     return select(function(node) {
1512       var parent = node.parentNode;
1513       parent.removeChild(node);
1514       return parent;
1515     });
1516   };
1517
1518   groups.sort = function(comparator) {
1519     comparator = d3_selection_comparator.apply(this, arguments);
1520     for (var j = 0, m = groups.length; j < m; j++) {
1521       var group = groups[j];
1522       group.sort(comparator);
1523       for (var i = 1, n = group.length, prev = group[0]; i < n; i++) {
1524         var node = group[i];
1525         if (node) {
1526           if (prev) prev.parentNode.insertBefore(node, prev.nextSibling);
1527           prev = node;
1528         }
1529       }
1530     }
1531     return groups;
1532   };
1533
1534   // type can be namespaced, e.g., "click.foo"
1535   // listener can be null for removal
1536   groups.on = function(type, listener) {
1537
1538     // parse the type specifier
1539     var i = type.indexOf("."),
1540         typo = i == -1 ? type : type.substring(0, i),
1541         name = "__on" + type;
1542
1543     // remove the old event listener, and add the new event listener
1544     return groups.each(function(d, i) {
1545       if (this[name]) this.removeEventListener(typo, this[name], false);
1546       if (listener) this.addEventListener(typo, this[name] = l, false);
1547
1548       // wrapped event listener that preserves d, i
1549       function l(e) {
1550         var o = d3.event; // Events can be reentrant (e.g., focus).
1551         d3.event = e;
1552         try {
1553           listener.call(this, d, i);
1554         } finally {
1555           d3.event = o;
1556         }
1557       }
1558     });
1559   };
1560
1561   // TODO slice?
1562
1563   groups.transition = function() {
1564     return d3_transition(groups);
1565   };
1566
1567   groups.call = d3_call;
1568
1569   return groups;
1570 }
1571
1572 function d3_selectionEnter(groups) {
1573
1574   function select(select) {
1575     var subgroups = [],
1576         subgroup,
1577         subnode,
1578         group,
1579         node;
1580     for (var j = 0, m = groups.length; j < m; j++) {
1581       group = groups[j];
1582       subgroups.push(subgroup = []);
1583       subgroup.parentNode = group.parentNode;
1584       subgroup.parentData = group.parentData;
1585       for (var i = 0, n = group.length; i < n; i++) {
1586         if (node = group[i]) {
1587           subgroup.push(subnode = select(group.parentNode));
1588           subnode.__data__ = node.__data__;
1589         } else {
1590           subgroup.push(null);
1591         }
1592       }
1593     }
1594     return d3_selection(subgroups);
1595   }
1596
1597   // TODO append(node)?
1598   // TODO append(function)?
1599   groups.append = function(name) {
1600     name = d3.ns.qualify(name);
1601
1602     function append(node) {
1603       return node.appendChild(document.createElement(name));
1604     }
1605
1606     function appendNS(node) {
1607       return node.appendChild(document.createElementNS(name.space, name.local));
1608     }
1609
1610     return select(name.local ? appendNS : append);
1611   };
1612
1613   // TODO insert(node, function)?
1614   // TODO insert(function, string)?
1615   // TODO insert(function, function)?
1616   groups.insert = function(name, before) {
1617     name = d3.ns.qualify(name);
1618
1619     function insert(node) {
1620       return node.insertBefore(
1621           document.createElement(name),
1622           d3_select(before, node));
1623     }
1624
1625     function insertNS(node) {
1626       return node.insertBefore(
1627           document.createElementNS(name.space, name.local),
1628           d3_select(before, node));
1629     }
1630
1631     return select(name.local ? insertNS : insert);
1632   };
1633
1634   return groups;
1635 }
1636
1637 function d3_selection_comparator(comparator) {
1638   if (!arguments.length) comparator = d3.ascending;
1639   return function(a, b) {
1640     return comparator(a && a.__data__, b && b.__data__);
1641   };
1642 }
1643 d3.transition = d3_root.transition;
1644
1645 var d3_transitionId = 0,
1646     d3_transitionInheritId = 0;
1647
1648 function d3_transition(groups) {
1649   var transition = {},
1650       transitionId = d3_transitionInheritId || ++d3_transitionId,
1651       tweens = {},
1652       interpolators = [],
1653       remove = false,
1654       event = d3.dispatch("start", "end"),
1655       stage = [],
1656       delay = [],
1657       duration = [],
1658       durationMax,
1659       ease = d3.ease("cubic-in-out");
1660
1661   //
1662   // Be careful with concurrent transitions!
1663   //
1664   // Say transition A causes an exit. Before A finishes, a transition B is
1665   // created, and believes it only needs to do an update, because the elements
1666   // haven't been removed yet (which happens at the very end of the exit
1667   // transition).
1668   //
1669   // Even worse, what if either transition A or B has a staggered delay? Then,
1670   // some elements may be removed, while others remain. Transition B does not
1671   // know to enter the elements because they were still present at the time
1672   // the transition B was created (but not yet started).
1673   //
1674   // To prevent such confusion, we only trigger end events for transitions if
1675   // the transition ending is the only one scheduled for the given element.
1676   // Similarly, we only allow one transition to be active for any given
1677   // element, so that concurrent transitions do not overwrite each other's
1678   // properties.
1679   //
1680   // TODO Support transition namespaces, so that transitions can proceed
1681   // concurrently on the same element if needed. Hopefully, this is rare!
1682   //
1683
1684   groups.each(function() {
1685     (this.__transition__ || (this.__transition__ = {})).owner = transitionId;
1686   });
1687
1688   function step(elapsed) {
1689     var clear = true,
1690         k = -1;
1691     groups.each(function() {
1692       if (stage[++k] == 2) return; // ended
1693       var t = (elapsed - delay[k]) / duration[k],
1694           tx = this.__transition__,
1695           te, // ease(t)
1696           tk, // tween key
1697           ik = interpolators[k];
1698
1699       // Check if the (un-eased) time is outside the range [0,1].
1700       if (t < 1) {
1701         clear = false;
1702         if (t < 0) return;
1703       } else {
1704         t = 1;
1705       }
1706
1707       // Determine the stage of this transition.
1708       // 0 - Not yet started.
1709       // 1 - In progress.
1710       // 2 - Ended.
1711       if (stage[k]) {
1712         if (!tx || tx.active != transitionId) {
1713           stage[k] = 2;
1714           return;
1715         }
1716       } else if (!tx || tx.active > transitionId) {
1717         stage[k] = 2;
1718         return;
1719       } else {
1720         stage[k] = 1;
1721         event.start.dispatch.apply(this, arguments);
1722         ik = interpolators[k] = {};
1723         tx.active = transitionId;
1724         for (tk in tweens) ik[tk] = tweens[tk].apply(this, arguments);
1725       }
1726
1727       // Apply the interpolators!
1728       te = ease(t);
1729       for (tk in tweens) ik[tk].call(this, te);
1730
1731       // Handle ending transitions.
1732       if (t == 1) {
1733         stage[k] = 2;
1734         if (tx.active == transitionId) {
1735           var owner = tx.owner;
1736           if (owner == transitionId) {
1737             delete this.__transition__;
1738             if (remove) this.parentNode.removeChild(this);
1739           }
1740           d3_transitionInheritId = transitionId;
1741           event.end.dispatch.apply(this, arguments);
1742           d3_transitionInheritId = 0;
1743           tx.owner = owner;
1744         }
1745       }
1746     });
1747     return clear;
1748   }
1749
1750   transition.delay = function(value) {
1751     var delayMin = Infinity,
1752         k = -1;
1753     if (typeof value == "function") {
1754       groups.each(function(d, i) {
1755         var x = delay[++k] = +value.apply(this, arguments);
1756         if (x < delayMin) delayMin = x;
1757       });
1758     } else {
1759       delayMin = +value;
1760       groups.each(function(d, i) {
1761         delay[++k] = delayMin;
1762       });
1763     }
1764     d3_timer(step, delayMin);
1765     return transition;
1766   };
1767
1768   transition.duration = function(value) {
1769     var k = -1;
1770     if (typeof value == "function") {
1771       durationMax = 0;
1772       groups.each(function(d, i) {
1773         var x = duration[++k] = +value.apply(this, arguments);
1774         if (x > durationMax) durationMax = x;
1775       });
1776     } else {
1777       durationMax = +value;
1778       groups.each(function(d, i) {
1779         duration[++k] = durationMax;
1780       });
1781     }
1782     return transition;
1783   };
1784
1785   transition.ease = function(value) {
1786     ease = typeof value == "function" ? value : d3.ease.apply(d3, arguments);
1787     return transition;
1788   };
1789
1790   transition.attrTween = function(name, tween) {
1791
1792     /** @this {Element} */
1793     function attrTween(d, i) {
1794       var f = tween.call(this, d, i, this.getAttribute(name));
1795       return function(t) {
1796         this.setAttribute(name, f(t));
1797       };
1798     }
1799
1800     /** @this {Element} */
1801     function attrTweenNS(d, i) {
1802       var f = tween.call(this, d, i, this.getAttributeNS(name.space, name.local));
1803       return function(t) {
1804         this.setAttributeNS(name.space, name.local, f(t));
1805       };
1806     }
1807
1808     tweens["attr." + name] = name.local ? attrTweenNS : attrTween;
1809     return transition;
1810   };
1811
1812   transition.attr = function(name, value) {
1813     return transition.attrTween(name, d3_transitionTween(value));
1814   };
1815
1816   transition.styleTween = function(name, tween, priority) {
1817     if (arguments.length < 3) priority = null;
1818
1819     /** @this {Element} */
1820     function styleTween(d, i) {
1821       var f = tween.call(this, d, i, window.getComputedStyle(this, null).getPropertyValue(name));
1822       return function(t) {
1823         this.style.setProperty(name, f(t), priority);
1824       };
1825     }
1826
1827     tweens["style." + name] = styleTween;
1828     return transition;
1829   };
1830
1831   transition.style = function(name, value, priority) {
1832     if (arguments.length < 3) priority = null;
1833     return transition.styleTween(name, d3_transitionTween(value), priority);
1834   };
1835
1836   transition.select = function(query) {
1837     var k, t = d3_transition(groups.select(query)).ease(ease);
1838     k = -1; t.delay(function(d, i) { return delay[++k]; });
1839     k = -1; t.duration(function(d, i) { return duration[++k]; });
1840     return t;
1841   };
1842
1843   transition.selectAll = function(query) {
1844     var k, t = d3_transition(groups.selectAll(query)).ease(ease);
1845     k = -1; t.delay(function(d, i) { return delay[i ? k : ++k]; })
1846     k = -1; t.duration(function(d, i) { return duration[i ? k : ++k]; });
1847     return t;
1848   };
1849
1850   transition.remove = function() {
1851     remove = true;
1852     return transition;
1853   };
1854
1855   transition.each = function(type, listener) {
1856     event[type].add(listener);
1857     return transition;
1858   };
1859
1860   transition.call = d3_call;
1861
1862   return transition.delay(0).duration(250);
1863 }
1864
1865 function d3_transitionTween(b) {
1866   return typeof b == "function"
1867       ? function(d, i, a) { return d3.interpolate(a, String(b.call(this, d, i))); }
1868       : (b = String(b), function(d, i, a) { return d3.interpolate(a, b); });
1869 }
1870 var d3_timer_queue = null,
1871     d3_timer_timeout = 0,
1872     d3_timer_interval;
1873
1874 // The timer will continue to fire until callback returns true.
1875 d3.timer = function(callback) {
1876   d3_timer(callback, 0);
1877 };
1878
1879 function d3_timer(callback, delay) {
1880   var now = Date.now(),
1881       found = false,
1882       start = now + delay,
1883       t0,
1884       t1 = d3_timer_queue;
1885
1886   if (!isFinite(delay)) return;
1887
1888   // Scan the queue for earliest callback.
1889   while (t1) {
1890     if (t1.callback == callback) {
1891       t1.then = now;
1892       t1.delay = delay;
1893       found = true;
1894     } else {
1895       var x = t1.then + t1.delay;
1896       if (x < start) start = x;
1897     }
1898     t0 = t1;
1899     t1 = t1.next;
1900   }
1901
1902   // Otherwise, add the callback to the queue.
1903   if (!found) d3_timer_queue = {
1904     callback: callback,
1905     then: now,
1906     delay: delay,
1907     next: d3_timer_queue
1908   };
1909
1910   if (!d3_timer_interval) {
1911     clearTimeout(d3_timer_timeout);
1912     d3_timer_timeout = setTimeout(d3_timer_start, Math.max(24, start - now));
1913   }
1914 }
1915
1916 function d3_timer_start() {
1917   d3_timer_interval = 1;
1918   d3_timer_timeout = 0;
1919   d3_timer_frame(d3_timer_step);
1920 }
1921
1922 function d3_timer_step() {
1923   var elapsed,
1924       now = Date.now(),
1925       t0 = null,
1926       t1 = d3_timer_queue;
1927   while (t1) {
1928     elapsed = now - t1.then;
1929     if (elapsed > t1.delay) t1.flush = t1.callback(elapsed);
1930     t1 = (t0 = t1).next;
1931   }
1932   d3_timer_flush();
1933   if (d3_timer_interval) d3_timer_frame(d3_timer_step);
1934 }
1935
1936 // Flush after callbacks, to avoid concurrent queue modification.
1937 function d3_timer_flush() {
1938   var t0 = null,
1939       t1 = d3_timer_queue;
1940   while (t1) {
1941     t1 = t1.flush
1942         ? (t0 ? t0.next = t1.next : d3_timer_queue = t1.next)
1943         : (t0 = t1).next;
1944   }
1945   if (!t0) d3_timer_interval = 0;
1946 }
1947
1948 var d3_timer_frame = window.requestAnimationFrame
1949     || window.webkitRequestAnimationFrame
1950     || window.mozRequestAnimationFrame
1951     || window.oRequestAnimationFrame
1952     || window.msRequestAnimationFrame
1953     || function(callback) { setTimeout(callback, 17); };
1954 d3.scale = {};
1955 d3.scale.linear = function() {
1956   var x0 = 0,
1957       x1 = 1,
1958       y0 = 0,
1959       y1 = 1,
1960       kx = 1, // 1 / (x1 - x0)
1961       ky = 1, // (x1 - x0) / (y1 - y0)
1962       interpolate = d3.interpolate,
1963       i = interpolate(y0, y1);
1964
1965   function scale(x) {
1966     return i((x - x0) * kx);
1967   }
1968
1969   // Note: requires range is coercible to number!
1970   scale.invert = function(y) {
1971     return (y - y0) * ky + x0;
1972   };
1973
1974   scale.domain = function(x) {
1975     if (!arguments.length) return [x0, x1];
1976     x0 = +x[0];
1977     x1 = +x[1];
1978     kx = 1 / (x1 - x0);
1979     ky = (x1 - x0) / (y1 - y0);
1980     return scale;
1981   };
1982
1983   scale.range = function(x) {
1984     if (!arguments.length) return [y0, y1];
1985     y0 = x[0];
1986     y1 = x[1];
1987     ky = (x1 - x0) / (y1 - y0);
1988     i = interpolate(y0, y1);
1989     return scale;
1990   };
1991
1992   scale.rangeRound = function(x) {
1993     return scale.range(x).interpolate(d3.interpolateRound);
1994   };
1995
1996   scale.interpolate = function(x) {
1997     if (!arguments.length) return interpolate;
1998     i = (interpolate = x)(y0, y1);
1999     return scale;
2000   };
2001
2002   // TODO Dates? Ugh.
2003   function tickRange(m) {
2004     var start = Math.min(x0, x1),
2005         stop = Math.max(x0, x1),
2006         span = stop - start,
2007         step = Math.pow(10, Math.floor(Math.log(span / m) / Math.LN10)),
2008         err = m / (span / step);
2009
2010     // Filter ticks to get closer to the desired count.
2011     if (err <= .15) step *= 10;
2012     else if (err <= .35) step *= 5;
2013     else if (err <= .75) step *= 2;
2014
2015     // Round start and stop values to step interval.
2016     return {
2017       start: Math.ceil(start / step) * step,
2018       stop: Math.floor(stop / step) * step + step * .5, // inclusive
2019       step: step
2020     };
2021   }
2022
2023   scale.ticks = function(m) {
2024     var range = tickRange(m);
2025     return d3.range(range.start, range.stop, range.step);
2026   };
2027
2028   scale.tickFormat = function(m) {
2029     var n = Math.max(0, -Math.floor(Math.log(tickRange(m).step) / Math.LN10 + .01));
2030     return d3.format(",." + n + "f");
2031   };
2032
2033   return scale;
2034 };
2035 d3.scale.log = function() {
2036   var linear = d3.scale.linear(),
2037       log = d3_scale_log,
2038       pow = log.pow;
2039
2040   function scale(x) {
2041     return linear(log(x));
2042   }
2043
2044   scale.invert = function(x) {
2045     return pow(linear.invert(x));
2046   };
2047
2048   scale.domain = function(x) {
2049     if (!arguments.length) return linear.domain().map(pow);
2050     log = (x[0] || x[1]) < 0 ? d3_scale_logn : d3_scale_log;
2051     pow = log.pow;
2052     linear.domain(x.map(log));
2053     return scale;
2054   };
2055
2056   scale.range = d3.rebind(scale, linear.range);
2057   scale.rangeRound = d3.rebind(scale, linear.rangeRound);
2058   scale.interpolate = d3.rebind(scale, linear.interpolate);
2059
2060   scale.ticks = function() {
2061     var d = linear.domain(),
2062         ticks = [];
2063     if (d.every(isFinite)) {
2064       var i = Math.floor(d[0]),
2065           j = Math.ceil(d[1]),
2066           u = pow(d[0]),
2067           v = pow(d[1]);
2068       if (log === d3_scale_logn) {
2069         ticks.push(pow(i));
2070         for (; i++ < j;) for (var k = 9; k > 0; k--) ticks.push(pow(i) * k);
2071       } else {
2072         for (; i < j; i++) for (var k = 1; k < 10; k++) ticks.push(pow(i) * k);
2073         ticks.push(pow(i));
2074       }
2075       for (i = 0; ticks[i] < u; i++) {} // strip small values
2076       for (j = ticks.length; ticks[j - 1] > v; j--) {} // strip big values
2077       ticks = ticks.slice(i, j);
2078     }
2079     return ticks;
2080   };
2081
2082   scale.tickFormat = function() {
2083     return function(d) { return d.toPrecision(1); };
2084   };
2085
2086   return scale;
2087 };
2088
2089 function d3_scale_log(x) {
2090   return Math.log(x) / Math.LN10;
2091 }
2092
2093 function d3_scale_logn(x) {
2094   return -Math.log(-x) / Math.LN10;
2095 }
2096
2097 d3_scale_log.pow = function(x) {
2098   return Math.pow(10, x);
2099 };
2100
2101 d3_scale_logn.pow = function(x) {
2102   return -Math.pow(10, -x);
2103 };
2104 d3.scale.pow = function() {
2105   var linear = d3.scale.linear(),
2106       tick = d3.scale.linear(), // TODO better tick formatting...
2107       exponent = 1,
2108       powp = Number,
2109       powb = powp;
2110
2111   function scale(x) {
2112     return linear(powp(x));
2113   }
2114
2115   scale.invert = function(x) {
2116     return powb(linear.invert(x));
2117   };
2118
2119   scale.domain = function(x) {
2120     if (!arguments.length) return linear.domain().map(powb);
2121     var pow = (x[0] || x[1]) < 0 ? d3_scale_pown : d3_scale_pow;
2122     powp = pow(exponent);
2123     powb = pow(1 / exponent);
2124     linear.domain(x.map(powp));
2125     tick.domain(x);
2126     return scale;
2127   };
2128
2129   scale.range = d3.rebind(scale, linear.range);
2130   scale.rangeRound = d3.rebind(scale, linear.rangeRound);
2131   scale.interpolate = d3.rebind(scale, linear.interpolate);
2132   scale.ticks = tick.ticks;
2133   scale.tickFormat = tick.tickFormat;
2134
2135   scale.exponent = function(x) {
2136     if (!arguments.length) return exponent;
2137     var domain = scale.domain();
2138     exponent = x;
2139     return scale.domain(domain);
2140   };
2141
2142   return scale;
2143 };
2144
2145 function d3_scale_pow(e) {
2146   return function(x) {
2147     return Math.pow(x, e);
2148   };
2149 }
2150
2151 function d3_scale_pown(e) {
2152   return function(x) {
2153     return -Math.pow(-x, e);
2154   };
2155 }
2156 d3.scale.sqrt = function() {
2157   return d3.scale.pow().exponent(.5);
2158 };
2159 d3.scale.ordinal = function() {
2160   var domain = [],
2161       index = {},
2162       range = [],
2163       rangeBand = 0;
2164
2165   function scale(x) {
2166     var i = x in index ? index[x] : (index[x] = domain.push(x) - 1);
2167     return range[i % range.length];
2168   }
2169
2170   scale.domain = function(x) {
2171     if (!arguments.length) return domain;
2172     domain = x;
2173     index = {};
2174     var i = -1, j = -1, n = domain.length; while (++i < n) {
2175       x = domain[i];
2176       if (!(x in index)) index[x] = ++j;
2177     }
2178     return scale;
2179   };
2180
2181   scale.range = function(x) {
2182     if (!arguments.length) return range;
2183     range = x;
2184     return scale;
2185   };
2186
2187   scale.rangePoints = function(x, padding) {
2188     if (arguments.length < 2) padding = 0;
2189     var start = x[0],
2190         stop = x[1],
2191         step = (stop - start) / (domain.length - 1 + padding);
2192     range = domain.length == 1
2193         ? [(start + stop) / 2]
2194         : d3.range(start + step * padding / 2, stop + step / 2, step);
2195     rangeBand = 0;
2196     return scale;
2197   };
2198
2199   scale.rangeBands = function(x, padding) {
2200     if (arguments.length < 2) padding = 0;
2201     var start = x[0],
2202         stop = x[1],
2203         step = (stop - start) / (domain.length + padding);
2204     range = d3.range(start + step * padding, stop, step);
2205     rangeBand = step * (1 - padding);
2206     return scale;
2207   };
2208
2209   scale.rangeRoundBands = function(x, padding) {
2210     if (arguments.length < 2) padding = 0;
2211     var start = x[0],
2212         stop = x[1],
2213         diff = stop - start,
2214         step = Math.floor(diff / (domain.length + padding)),
2215         err = diff - (domain.length - padding) * step;
2216     range = d3.range(start + Math.round(err / 2), stop, step);
2217     rangeBand = Math.round(step * (1 - padding));
2218     return scale;
2219   };
2220
2221   scale.rangeBand = function() {
2222     return rangeBand;
2223   };
2224
2225   return scale;
2226 };
2227 /*
2228  * This product includes color specifications and designs developed by Cynthia
2229  * Brewer (http://colorbrewer.org/). See lib/colorbrewer for more information.
2230  */
2231
2232 d3.scale.category10 = function() {
2233   return d3.scale.ordinal().range(d3_category10);
2234 };
2235
2236 d3.scale.category20 = function() {
2237   return d3.scale.ordinal().range(d3_category20);
2238 };
2239
2240 d3.scale.category20b = function() {
2241   return d3.scale.ordinal().range(d3_category20b);
2242 };
2243
2244 d3.scale.category20c = function() {
2245   return d3.scale.ordinal().range(d3_category20c);
2246 };
2247
2248 var d3_category10 = [
2249   "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd",
2250   "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"
2251 ];
2252
2253 var d3_category20 = [
2254   "#1f77b4", "#aec7e8",
2255   "#ff7f0e", "#ffbb78",
2256   "#2ca02c", "#98df8a",
2257   "#d62728", "#ff9896",
2258   "#9467bd", "#c5b0d5",
2259   "#8c564b", "#c49c94",
2260   "#e377c2", "#f7b6d2",
2261   "#7f7f7f", "#c7c7c7",
2262   "#bcbd22", "#dbdb8d",
2263   "#17becf", "#9edae5"
2264 ];
2265
2266 var d3_category20b = [
2267   "#393b79", "#5254a3", "#6b6ecf", "#9c9ede",
2268   "#637939", "#8ca252", "#b5cf6b", "#cedb9c",
2269   "#8c6d31", "#bd9e39", "#e7ba52", "#e7cb94",
2270   "#843c39", "#ad494a", "#d6616b", "#e7969c",
2271   "#7b4173", "#a55194", "#ce6dbd", "#de9ed6"
2272 ];
2273
2274 var d3_category20c = [
2275   "#3182bd", "#6baed6", "#9ecae1", "#c6dbef",
2276   "#e6550d", "#fd8d3c", "#fdae6b", "#fdd0a2",
2277   "#31a354", "#74c476", "#a1d99b", "#c7e9c0",
2278   "#756bb1", "#9e9ac8", "#bcbddc", "#dadaeb",
2279   "#636363", "#969696", "#bdbdbd", "#d9d9d9"
2280 ];
2281 d3.scale.quantile = function() {
2282   var domain = [],
2283       range = [],
2284       thresholds = [];
2285
2286   function rescale() {
2287     var i = -1,
2288         n = thresholds.length = range.length,
2289         k = domain.length / n;
2290     while (++i < n) thresholds[i] = domain[~~(i * k)];
2291   }
2292
2293   function quantile(value) {
2294     if (isNaN(value = +value)) return NaN;
2295     var low = 0, high = thresholds.length - 1;
2296     while (low <= high) {
2297       var mid = (low + high) >> 1, midValue = thresholds[mid];
2298       if (midValue < value) low = mid + 1;
2299       else if (midValue > value) high = mid - 1;
2300       else return mid;
2301     }
2302     return high < 0 ? 0 : high;
2303   }
2304
2305   function scale(x) {
2306     return range[quantile(x)];
2307   }
2308
2309   scale.domain = function(x) {
2310     if (!arguments.length) return domain;
2311     domain = x.filter(function(d) { return !isNaN(d); }).sort(d3.ascending);
2312     rescale();
2313     return scale;
2314   };
2315
2316   scale.range = function(x) {
2317     if (!arguments.length) return range;
2318     range = x;
2319     rescale();
2320     return scale;
2321   };
2322
2323   scale.quantiles = function() {
2324     return thresholds;
2325   };
2326
2327   return scale;
2328 };
2329 d3.scale.quantize = function() {
2330   var x0 = 0,
2331       x1 = 1,
2332       kx = 2,
2333       i = 1,
2334       range = [0, 1];
2335
2336   function scale(x) {
2337     return range[Math.max(0, Math.min(i, Math.floor(kx * (x - x0))))];
2338   }
2339
2340   scale.domain = function(x) {
2341     if (!arguments.length) return [x0, x1];
2342     x0 = x[0];
2343     x1 = x[1];
2344     kx = range.length / (x1 - x0);
2345     return scale;
2346   };
2347
2348   scale.range = function(x) {
2349     if (!arguments.length) return range;
2350     range = x;
2351     kx = range.length / (x1 - x0);
2352     i = range.length - 1;
2353     return scale;
2354   };
2355
2356   return scale;
2357 };
2358 d3.svg = {};
2359 d3.svg.arc = function() {
2360   var innerRadius = d3_svg_arcInnerRadius,
2361       outerRadius = d3_svg_arcOuterRadius,
2362       startAngle = d3_svg_arcStartAngle,
2363       endAngle = d3_svg_arcEndAngle;
2364
2365   function arc() {
2366     var r0 = innerRadius.apply(this, arguments),
2367         r1 = outerRadius.apply(this, arguments),
2368         a0 = startAngle.apply(this, arguments) + d3_svg_arcOffset,
2369         a1 = endAngle.apply(this, arguments) + d3_svg_arcOffset,
2370         da = a1 - a0,
2371         df = da < Math.PI ? "0" : "1",
2372         c0 = Math.cos(a0),
2373         s0 = Math.sin(a0),
2374         c1 = Math.cos(a1),
2375         s1 = Math.sin(a1);
2376     return da >= d3_svg_arcMax
2377       ? (r0
2378       ? "M0," + r1
2379       + "A" + r1 + "," + r1 + " 0 1,1 0," + (-r1)
2380       + "A" + r1 + "," + r1 + " 0 1,1 0," + r1
2381       + "M0," + r0
2382       + "A" + r0 + "," + r0 + " 0 1,1 0," + (-r0)
2383       + "A" + r0 + "," + r0 + " 0 1,1 0," + r0
2384       + "Z"
2385       : "M0," + r1
2386       + "A" + r1 + "," + r1 + " 0 1,1 0," + (-r1)
2387       + "A" + r1 + "," + r1 + " 0 1,1 0," + r1
2388       + "Z")
2389       : (r0
2390       ? "M" + r1 * c0 + "," + r1 * s0
2391       + "A" + r1 + "," + r1 + " 0 " + df + ",1 " + r1 * c1 + "," + r1 * s1
2392       + "L" + r0 * c1 + "," + r0 * s1
2393       + "A" + r0 + "," + r0 + " 0 " + df + ",0 " + r0 * c0 + "," + r0 * s0
2394       + "Z"
2395       : "M" + r1 * c0 + "," + r1 * s0
2396       + "A" + r1 + "," + r1 + " 0 " + df + ",1 " + r1 * c1 + "," + r1 * s1
2397       + "L0,0"
2398       + "Z");
2399   }
2400
2401   arc.innerRadius = function(v) {
2402     if (!arguments.length) return innerRadius;
2403     innerRadius = d3_functor(v);
2404     return arc;
2405   };
2406
2407   arc.outerRadius = function(v) {
2408     if (!arguments.length) return outerRadius;
2409     outerRadius = d3_functor(v);
2410     return arc;
2411   };
2412
2413   arc.startAngle = function(v) {
2414     if (!arguments.length) return startAngle;
2415     startAngle = d3_functor(v);
2416     return arc;
2417   };
2418
2419   arc.endAngle = function(v) {
2420     if (!arguments.length) return endAngle;
2421     endAngle = d3_functor(v);
2422     return arc;
2423   };
2424
2425   arc.centroid = function() {
2426     var r = (innerRadius.apply(this, arguments)
2427         + outerRadius.apply(this, arguments)) / 2,
2428         a = (startAngle.apply(this, arguments)
2429         + endAngle.apply(this, arguments)) / 2 + d3_svg_arcOffset;
2430     return [Math.cos(a) * r, Math.sin(a) * r];
2431   };
2432
2433   return arc;
2434 };
2435
2436 var d3_svg_arcOffset = -Math.PI / 2,
2437     d3_svg_arcMax = 2 * Math.PI - 1e-6;
2438
2439 function d3_svg_arcInnerRadius(d) {
2440   return d.innerRadius;
2441 }
2442
2443 function d3_svg_arcOuterRadius(d) {
2444   return d.outerRadius;
2445 }
2446
2447 function d3_svg_arcStartAngle(d) {
2448   return d.startAngle;
2449 }
2450
2451 function d3_svg_arcEndAngle(d) {
2452   return d.endAngle;
2453 }
2454 d3.svg.line = function() {
2455   var x = d3_svg_lineX,
2456       y = d3_svg_lineY,
2457       interpolate = "linear",
2458       interpolator = d3_svg_lineInterpolators[interpolate],
2459       tension = .7;
2460
2461   function line(d) {
2462     return d.length < 1 ? null
2463         : "M" + interpolator(d3_svg_linePoints(this, d, x, y), tension);
2464   }
2465
2466   line.x = function(v) {
2467     if (!arguments.length) return x;
2468     x = v;
2469     return line;
2470   };
2471
2472   line.y = function(v) {
2473     if (!arguments.length) return y;
2474     y = v;
2475     return line;
2476   };
2477
2478   line.interpolate = function(v) {
2479     if (!arguments.length) return interpolate;
2480     interpolator = d3_svg_lineInterpolators[interpolate = v];
2481     return line;
2482   };
2483
2484   line.tension = function(v) {
2485     if (!arguments.length) return tension;
2486     tension = v;
2487     return line;
2488   };
2489
2490   return line;
2491 };
2492
2493 // Converts the specified array of data into an array of points
2494 // (x-y tuples), by evaluating the specified `x` and `y` functions on each
2495 // data point. The `this` context of the evaluated functions is the specified
2496 // "self" object; each function is passed the current datum and index.
2497 function d3_svg_linePoints(self, d, x, y) {
2498   var points = [],
2499       i = -1,
2500       n = d.length,
2501       fx = typeof x == "function",
2502       fy = typeof y == "function",
2503       value;
2504   if (fx && fy) {
2505     while (++i < n) points.push([
2506       x.call(self, value = d[i], i),
2507       y.call(self, value, i)
2508     ]);
2509   } else if (fx) {
2510     while (++i < n) points.push([x.call(self, d[i], i), y]);
2511   } else if (fy) {
2512     while (++i < n) points.push([x, y.call(self, d[i], i)]);
2513   } else {
2514     while (++i < n) points.push([x, y]);
2515   }
2516   return points;
2517 }
2518
2519 // The default `x` property, which references d[0].
2520 function d3_svg_lineX(d) {
2521   return d[0];
2522 }
2523
2524 // The default `y` property, which references d[1].
2525 function d3_svg_lineY(d) {
2526   return d[1];
2527 }
2528
2529 // The various interpolators supported by the `line` class.
2530 var d3_svg_lineInterpolators = {
2531   "linear": d3_svg_lineLinear,
2532   "step-before": d3_svg_lineStepBefore,
2533   "step-after": d3_svg_lineStepAfter,
2534   "basis": d3_svg_lineBasis,
2535   "basis-closed": d3_svg_lineBasisClosed,
2536   "cardinal": d3_svg_lineCardinal,
2537   "cardinal-closed": d3_svg_lineCardinalClosed
2538 };
2539
2540 // Linear interpolation; generates "L" commands.
2541 function d3_svg_lineLinear(points) {
2542   var path = [],
2543       i = 0,
2544       n = points.length,
2545       p = points[0];
2546   path.push(p[0], ",", p[1]);
2547   while (++i < n) path.push("L", (p = points[i])[0], ",", p[1]);
2548   return path.join("");
2549 }
2550
2551 // Step interpolation; generates "H" and "V" commands.
2552 function d3_svg_lineStepBefore(points) {
2553   var path = [],
2554       i = 0,
2555       n = points.length,
2556       p = points[0];
2557   path.push(p[0], ",", p[1]);
2558   while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]);
2559   return path.join("");
2560 }
2561
2562 // Step interpolation; generates "H" and "V" commands.
2563 function d3_svg_lineStepAfter(points) {
2564   var path = [],
2565       i = 0,
2566       n = points.length,
2567       p = points[0];
2568   path.push(p[0], ",", p[1]);
2569   while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]);
2570   return path.join("");
2571 }
2572
2573 // Closed cardinal spline interpolation; generates "C" commands.
2574 function d3_svg_lineCardinalClosed(points, tension) {
2575   return points.length < 3
2576       ? d3_svg_lineLinear(points)
2577       : points[0] + d3_svg_lineHermite(points,
2578         d3_svg_lineCardinalTangents([points[points.length - 2]]
2579         .concat(points, [points[1]]), tension));
2580 }
2581
2582 // Cardinal spline interpolation; generates "C" commands.
2583 function d3_svg_lineCardinal(points, tension, closed) {
2584   return points.length < 3
2585       ? d3_svg_lineLinear(points)
2586       : points[0] + d3_svg_lineHermite(points,
2587         d3_svg_lineCardinalTangents(points, tension));
2588 }
2589
2590 // Hermite spline construction; generates "C" commands.
2591 function d3_svg_lineHermite(points, tangents) {
2592   if (tangents.length < 1
2593       || (points.length != tangents.length
2594       && points.length != tangents.length + 2)) {
2595     return d3_svg_lineLinear(points);
2596   }
2597
2598   var quad = points.length != tangents.length,
2599       path = "",
2600       p0 = points[0],
2601       p = points[1],
2602       t0 = tangents[0],
2603       t = t0,
2604       pi = 1;
2605
2606   if (quad) {
2607     path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3)
2608         + "," + p[0] + "," + p[1];
2609     p0 = points[1];
2610     pi = 2;
2611   }
2612
2613   if (tangents.length > 1) {
2614     t = tangents[1];
2615     p = points[pi];
2616     pi++;
2617     path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1])
2618         + "," + (p[0] - t[0]) + "," + (p[1] - t[1])
2619         + "," + p[0] + "," + p[1];
2620     for (var i = 2; i < tangents.length; i++, pi++) {
2621       p = points[pi];
2622       t = tangents[i];
2623       path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1])
2624           + "," + p[0] + "," + p[1];
2625     }
2626   }
2627
2628   if (quad) {
2629     var lp = points[pi];
2630     path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3)
2631         + "," + lp[0] + "," + lp[1];
2632   }
2633
2634   return path;
2635 }
2636
2637 // Generates tangents for a cardinal spline.
2638 function d3_svg_lineCardinalTangents(points, tension) {
2639   var tangents = [],
2640       a = (1 - tension) / 2,
2641       p0 = points[0],
2642       p1 = points[1],
2643       p2 = points[2],
2644       i = 2,
2645       n = points.length;
2646   while (++i < n) {
2647     tangents.push([a * (p2[0] - p0[0]), a * (p2[1] - p0[1])]);
2648     p0 = p1;
2649     p1 = p2;
2650     p2 = points[i];
2651   }
2652   tangents.push([a * (p2[0] - p0[0]), a * (p2[1] - p0[1])]);
2653   return tangents;
2654 }
2655
2656 // Open B-spline interpolation; generates "C" commands.
2657 function d3_svg_lineBasis(points) {
2658   if (points.length < 3) return d3_svg_lineLinear(points);
2659   var path = [],
2660       i = 1,
2661       n = points.length,
2662       pi = points[0],
2663       x0 = pi[0],
2664       y0 = pi[1],
2665       px = [x0, x0, x0, (pi = points[1])[0]],
2666       py = [y0, y0, y0, pi[1]];
2667   path.push(x0, ",", y0);
2668   d3_svg_lineBasisBezier(path, px, py);
2669   while (++i < n) {
2670     pi = points[i];
2671     px.shift(); px.push(pi[0]);
2672     py.shift(); py.push(pi[1]);
2673     d3_svg_lineBasisBezier(path, px, py);
2674   }
2675   i = -1;
2676   while (++i < 2) {
2677     px.shift(); px.push(pi[0]);
2678     py.shift(); py.push(pi[1]);
2679     d3_svg_lineBasisBezier(path, px, py);
2680   }
2681   return path.join("");
2682 }
2683
2684 // Closed B-spline interpolation; generates "C" commands.
2685 function d3_svg_lineBasisClosed(points) {
2686   var path,
2687       i = -1,
2688       n = points.length,
2689       m = n + 4,
2690       pi,
2691       px = [],
2692       py = [];
2693   while (++i < 4) {
2694     pi = points[i % n];
2695     px.push(pi[0]);
2696     py.push(pi[1]);
2697   }
2698   path = [
2699     d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",",
2700     d3_svg_lineDot4(d3_svg_lineBasisBezier3, py)
2701   ];
2702   --i; while (++i < m) {
2703     pi = points[i % n];
2704     px.shift(); px.push(pi[0]);
2705     py.shift(); py.push(pi[1]);
2706     d3_svg_lineBasisBezier(path, px, py);
2707   }
2708   return path.join("");
2709 }
2710
2711 // Returns the dot product of the given four-element vectors.
2712 function d3_svg_lineDot4(a, b) {
2713   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
2714 }
2715
2716 // Matrix to transform basis (b-spline) control points to bezier
2717 // control points. Derived from FvD 11.2.8.
2718 var d3_svg_lineBasisBezier1 = [0, 2/3, 1/3, 0],
2719     d3_svg_lineBasisBezier2 = [0, 1/3, 2/3, 0],
2720     d3_svg_lineBasisBezier3 = [0, 1/6, 2/3, 1/6];
2721
2722 // Pushes a "C" Bézier curve onto the specified path array, given the
2723 // two specified four-element arrays which define the control points.
2724 function d3_svg_lineBasisBezier(path, x, y) {
2725   path.push(
2726       "C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x),
2727       ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1, y),
2728       ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, x),
2729       ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, y),
2730       ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, x),
2731       ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, y));
2732 }
2733 d3.svg.area = function() {
2734   var x = d3_svg_lineX,
2735       y0 = d3_svg_areaY0,
2736       y1 = d3_svg_lineY,
2737       interpolate = "linear",
2738       interpolator = d3_svg_lineInterpolators[interpolate],
2739       tension = .7;
2740
2741   // TODO horizontal / vertical / radial orientation
2742
2743   function area(d) {
2744     return d.length < 1 ? null
2745         : "M" + interpolator(d3_svg_linePoints(this, d, x, y1), tension)
2746         + "L" + interpolator(d3_svg_linePoints(this, d, x, y0).reverse(), tension)
2747         + "Z";
2748   }
2749
2750   area.x = function(v) {
2751     if (!arguments.length) return x;
2752     x = v;
2753     return area;
2754   };
2755
2756   area.y0 = function(v) {
2757     if (!arguments.length) return y0;
2758     y0 = v;
2759     return area;
2760   };
2761
2762   area.y1 = function(v) {
2763     if (!arguments.length) return y1;
2764     y1 = v;
2765     return area;
2766   };
2767
2768   area.interpolate = function(v) {
2769     if (!arguments.length) return interpolate;
2770     interpolator = d3_svg_lineInterpolators[interpolate = v];
2771     return area;
2772   };
2773
2774   area.tension = function(v) {
2775     if (!arguments.length) return tension;
2776     tension = v;
2777     return area;
2778   };
2779
2780   return area;
2781 };
2782
2783 function d3_svg_areaY0() {
2784   return 0;
2785 }
2786 d3.svg.chord = function() {
2787   var source = d3_svg_chordSource,
2788       target = d3_svg_chordTarget,
2789       radius = d3_svg_chordRadius,
2790       startAngle = d3_svg_arcStartAngle,
2791       endAngle = d3_svg_arcEndAngle;
2792
2793   // TODO Allow control point to be customized.
2794
2795   function chord(d, i) {
2796     var s = subgroup(this, source, d, i),
2797         t = subgroup(this, target, d, i);
2798     return "M" + s.p0
2799       + arc(s.r, s.p1) + (equals(s, t)
2800       ? curve(s.r, s.p1, s.r, s.p0)
2801       : curve(s.r, s.p1, t.r, t.p0)
2802       + arc(t.r, t.p1)
2803       + curve(t.r, t.p1, s.r, s.p0))
2804       + "Z";
2805   }
2806
2807   function subgroup(self, f, d, i) {
2808     var subgroup = f.call(self, d, i),
2809         r = radius.call(self, subgroup, i),
2810         a0 = startAngle.call(self, subgroup, i) + d3_svg_arcOffset,
2811         a1 = endAngle.call(self, subgroup, i) + d3_svg_arcOffset;
2812     return {
2813       r: r,
2814       a0: a0,
2815       a1: a1,
2816       p0: [r * Math.cos(a0), r * Math.sin(a0)],
2817       p1: [r * Math.cos(a1), r * Math.sin(a1)]
2818     };
2819   }
2820
2821   function equals(a, b) {
2822     return a.a0 == b.a0 && a.a1 == b.a1;
2823   }
2824
2825   function arc(r, p) {
2826     return "A" + r + "," + r + " 0 0,1 " + p;
2827   }
2828
2829   function curve(r0, p0, r1, p1) {
2830     return "Q 0,0 " + p1;
2831   }
2832
2833   chord.radius = function(v) {
2834     if (!arguments.length) return radius;
2835     radius = d3_functor(v);
2836     return chord;
2837   };
2838
2839   chord.source = function(v) {
2840     if (!arguments.length) return source;
2841     source = d3_functor(v);
2842     return chord;
2843   };
2844
2845   chord.target = function(v) {
2846     if (!arguments.length) return target;
2847     target = d3_functor(v);
2848     return chord;
2849   };
2850
2851   chord.startAngle = function(v) {
2852     if (!arguments.length) return startAngle;
2853     startAngle = d3_functor(v);
2854     return chord;
2855   };
2856
2857   chord.endAngle = function(v) {
2858     if (!arguments.length) return endAngle;
2859     endAngle = d3_functor(v);
2860     return chord;
2861   };
2862
2863   return chord;
2864 };
2865
2866 function d3_svg_chordSource(d) {
2867   return d.source;
2868 }
2869
2870 function d3_svg_chordTarget(d) {
2871   return d.target;
2872 }
2873
2874 function d3_svg_chordRadius(d) {
2875   return d.radius;
2876 }
2877
2878 function d3_svg_chordStartAngle(d) {
2879   return d.startAngle;
2880 }
2881
2882 function d3_svg_chordEndAngle(d) {
2883   return d.endAngle;
2884 }
2885 d3.svg.mouse = function(container) {
2886   var point = (container.ownerSVGElement || container).createSVGPoint();
2887   if ((d3_mouse_bug44083 < 0) && (window.scrollX || window.scrollY)) {
2888     var svg = d3.select(document.body)
2889       .append("svg:svg")
2890         .style("position", "absolute")
2891         .style("top", 0)
2892         .style("left", 0);
2893     var ctm = svg[0][0].getScreenCTM();
2894     d3_mouse_bug44083 = !(ctm.f || ctm.e);
2895     svg.remove();
2896   }
2897   if (d3_mouse_bug44083) {
2898     point.x = d3.event.pageX;
2899     point.y = d3.event.pageY;
2900   } else {
2901     point.x = d3.event.clientX;
2902     point.y = d3.event.clientY;
2903   }
2904   point = point.matrixTransform(container.getScreenCTM().inverse());
2905   return [point.x, point.y];
2906 };
2907
2908 // https://bugs.webkit.org/show_bug.cgi?id=44083
2909 var d3_mouse_bug44083 = /WebKit/.test(navigator.userAgent) ? -1 : 0;
2910 d3.svg.symbol = function() {
2911   var type = d3_svg_symbolType,
2912       size = d3_svg_symbolSize;
2913
2914   function symbol(d, i) {
2915     return (d3_svg_symbols[type.call(this, d, i)]
2916         || d3_svg_symbols.circle)
2917         (size.call(this, d, i));
2918   }
2919
2920   symbol.type = function(x) {
2921     if (!arguments.length) return type;
2922     type = d3_functor(x);
2923     return symbol;
2924   };
2925
2926   // size of symbol in square pixels
2927   symbol.size = function(x) {
2928     if (!arguments.length) return size;
2929     size = d3_functor(x);
2930     return symbol;
2931   };
2932
2933   return symbol;
2934 };
2935
2936 // TODO cross-diagonal?
2937 d3.svg.symbolTypes = [
2938   "circle",
2939   "cross",
2940   "diamond",
2941   "square",
2942   "triangle-down",
2943   "triangle-up"
2944 ];
2945
2946 function d3_svg_symbolSize() {
2947   return 64;
2948 }
2949
2950 function d3_svg_symbolType() {
2951   return "circle";
2952 }
2953
2954 var d3_svg_symbols = {
2955   "circle": function(size) {
2956     var r = Math.sqrt(size / Math.PI);
2957     return "M0," + r
2958         + "A" + r + "," + r + " 0 1,1 0," + (-r)
2959         + "A" + r + "," + r + " 0 1,1 0," + r
2960         + "Z";
2961   },
2962   "cross": function(size) {
2963     var r = Math.sqrt(size / 5) / 2;
2964     return "M" + -3 * r + "," + -r
2965         + "H" + -r
2966         + "V" + -3 * r
2967         + "H" + r
2968         + "V" + -r
2969         + "H" + 3 * r
2970         + "V" + r
2971         + "H" + r
2972         + "V" + 3 * r
2973         + "H" + -r
2974         + "V" + r
2975         + "H" + -3 * r
2976         + "Z";
2977   },
2978   "diamond": function(size) {
2979     var ry = Math.sqrt(size / (2 * d3_svg_symbolTan30)),
2980         rx = ry * d3_svg_symbolTan30;
2981     return "M0," + -ry
2982         + "L" + rx + ",0"
2983         + " 0," + ry
2984         + " " + -rx + ",0"
2985         + "Z";
2986   },
2987   "square": function(size) {
2988     var r = Math.sqrt(size) / 2;
2989     return "M" + -r + "," + -r
2990         + "L" + r + "," + -r
2991         + " " + r + "," + r
2992         + " " + -r + "," + r
2993         + "Z";
2994   },
2995   "triangle-down": function(size) {
2996     var rx = Math.sqrt(size / d3_svg_symbolSqrt3),
2997         ry = rx * d3_svg_symbolSqrt3 / 2;
2998     return "M0," + ry
2999         + "L" + rx +"," + -ry
3000         + " " + -rx + "," + -ry
3001         + "Z";
3002   },
3003   "triangle-up": function(size) {
3004     var rx = Math.sqrt(size / d3_svg_symbolSqrt3),
3005         ry = rx * d3_svg_symbolSqrt3 / 2;
3006     return "M0," + -ry
3007         + "L" + rx +"," + ry
3008         + " " + -rx + "," + ry
3009         + "Z";
3010   }
3011 };
3012
3013 var d3_svg_symbolSqrt3 = Math.sqrt(3),
3014     d3_svg_symbolTan30 = Math.tan(30 * Math.PI / 180);
3015 })()