Last active
April 16, 2017 06:05
-
-
Save cool-Blue/e38f799cb9730cd361e2ea378dec1b18 to your computer and use it in GitHub Desktop.
d2v4 force simulation with velocityJS animation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # Created by .ignore support plugin (hsz.mobi) | |
| ### Example user template template | |
| ### Example user template | |
| # IntelliJ project files | |
| .idea | |
| *.iml | |
| out | |
| gen | |
| .gitignore |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| (function (global, factory) { | |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory() : | |
| typeof define === 'function' && define.amd ? define(factory) : | |
| (factory()); | |
| }(this, (function () { 'use strict'; | |
| function __$styleInject(css, returnValue) { | |
| if (typeof document === 'undefined') { | |
| return returnValue; | |
| } | |
| css = css || ''; | |
| var head = document.head || document.getElementsByTagName('head')[0]; | |
| var style = document.createElement('style'); | |
| style.type = 'text/css'; | |
| if (style.styleSheet){ | |
| style.styleSheet.cssText = css; | |
| } else { | |
| style.appendChild(document.createTextNode(css)); | |
| } | |
| head.appendChild(style); | |
| return returnValue; | |
| } | |
| __$styleInject("g.plot rect{\r\n will-change: transform;\r\n perspective: 1000px;\r\n transform: translateZ(0);\r\n\r\n -webkit-backface-visibility: hidden;\r\n -moz-backface-visibility: hidden;\r\n -ms-backface-visibility: hidden;\r\n backface-visibility: hidden;\r\n\r\n -webkit-transition: all 0.1s linear;\r\n -moz-transition: all 0.1s linear;\r\n -o-transition: all 0.1s linear;\r\n transition: all 0.1s linear;\r\n}\r\n#histogram {\r\n margin: 0 0 0 0;\r\n position: absolute;\r\n}",undefined); | |
| var xhtml = "http://www.w3.org/1999/xhtml"; | |
| var namespaces = { | |
| svg: "http://www.w3.org/2000/svg", | |
| xhtml: xhtml, | |
| xlink: "http://www.w3.org/1999/xlink", | |
| xml: "http://www.w3.org/XML/1998/namespace", | |
| xmlns: "http://www.w3.org/2000/xmlns/" | |
| }; | |
| var namespace = function(name) { | |
| var prefix = name += "", i = prefix.indexOf(":"); | |
| if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1); | |
| return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name; | |
| }; | |
| function creatorInherit(name) { | |
| return function() { | |
| var document = this.ownerDocument, | |
| uri = this.namespaceURI; | |
| return uri === xhtml && document.documentElement.namespaceURI === xhtml | |
| ? document.createElement(name) | |
| : document.createElementNS(uri, name); | |
| }; | |
| } | |
| function creatorFixed(fullname) { | |
| return function() { | |
| return this.ownerDocument.createElementNS(fullname.space, fullname.local); | |
| }; | |
| } | |
| var creator = function(name) { | |
| var fullname = namespace(name); | |
| return (fullname.local | |
| ? creatorFixed | |
| : creatorInherit)(fullname); | |
| }; | |
| var matcher = function(selector) { | |
| return function() { | |
| return this.matches(selector); | |
| }; | |
| }; | |
| if (typeof document !== "undefined") { | |
| var element = document.documentElement; | |
| if (!element.matches) { | |
| var vendorMatches = element.webkitMatchesSelector | |
| || element.msMatchesSelector | |
| || element.mozMatchesSelector | |
| || element.oMatchesSelector; | |
| matcher = function(selector) { | |
| return function() { | |
| return vendorMatches.call(this, selector); | |
| }; | |
| }; | |
| } | |
| } | |
| var matcher$1 = matcher; | |
| var filterEvents = {}; | |
| var event = null; | |
| if (typeof document !== "undefined") { | |
| var element$1 = document.documentElement; | |
| if (!("onmouseenter" in element$1)) { | |
| filterEvents = {mouseenter: "mouseover", mouseleave: "mouseout"}; | |
| } | |
| } | |
| function filterContextListener(listener, index, group) { | |
| listener = contextListener(listener, index, group); | |
| return function(event) { | |
| var related = event.relatedTarget; | |
| if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) { | |
| listener.call(this, event); | |
| } | |
| }; | |
| } | |
| function contextListener(listener, index, group) { | |
| return function(event1) { | |
| var event0 = event; // Events can be reentrant (e.g., focus). | |
| event = event1; | |
| try { | |
| listener.call(this, this.__data__, index, group); | |
| } finally { | |
| event = event0; | |
| } | |
| }; | |
| } | |
| function parseTypenames(typenames) { | |
| return typenames.trim().split(/^|\s+/).map(function(t) { | |
| var name = "", i = t.indexOf("."); | |
| if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i); | |
| return {type: t, name: name}; | |
| }); | |
| } | |
| function onRemove(typename) { | |
| return function() { | |
| var on = this.__on; | |
| if (!on) return; | |
| for (var j = 0, i = -1, m = on.length, o; j < m; ++j) { | |
| if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) { | |
| this.removeEventListener(o.type, o.listener, o.capture); | |
| } else { | |
| on[++i] = o; | |
| } | |
| } | |
| if (++i) on.length = i; | |
| else delete this.__on; | |
| }; | |
| } | |
| function onAdd(typename, value, capture) { | |
| var wrap = filterEvents.hasOwnProperty(typename.type) ? filterContextListener : contextListener; | |
| return function(d, i, group) { | |
| var on = this.__on, o, listener = wrap(value, i, group); | |
| if (on) for (var j = 0, m = on.length; j < m; ++j) { | |
| if ((o = on[j]).type === typename.type && o.name === typename.name) { | |
| this.removeEventListener(o.type, o.listener, o.capture); | |
| this.addEventListener(o.type, o.listener = listener, o.capture = capture); | |
| o.value = value; | |
| return; | |
| } | |
| } | |
| this.addEventListener(typename.type, listener, capture); | |
| o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture}; | |
| if (!on) this.__on = [o]; | |
| else on.push(o); | |
| }; | |
| } | |
| var selection_on = function(typename, value, capture) { | |
| var typenames = parseTypenames(typename + ""), i, n = typenames.length, t; | |
| if (arguments.length < 2) { | |
| var on = this.node().__on; | |
| if (on) for (var j = 0, m = on.length, o; j < m; ++j) { | |
| for (i = 0, o = on[j]; i < n; ++i) { | |
| if ((t = typenames[i]).type === o.type && t.name === o.name) { | |
| return o.value; | |
| } | |
| } | |
| } | |
| return; | |
| } | |
| on = value ? onAdd : onRemove; | |
| if (capture == null) capture = false; | |
| for (i = 0; i < n; ++i) this.each(on(typenames[i], value, capture)); | |
| return this; | |
| }; | |
| function none() {} | |
| var selector = function(selector) { | |
| return selector == null ? none : function() { | |
| return this.querySelector(selector); | |
| }; | |
| }; | |
| var selection_select = function(select) { | |
| if (typeof select !== "function") select = selector(select); | |
| for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) { | |
| if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) { | |
| if ("__data__" in node) subnode.__data__ = node.__data__; | |
| subgroup[i] = subnode; | |
| } | |
| } | |
| } | |
| return new Selection(subgroups, this._parents); | |
| }; | |
| function empty() { | |
| return []; | |
| } | |
| var selectorAll = function(selector) { | |
| return selector == null ? empty : function() { | |
| return this.querySelectorAll(selector); | |
| }; | |
| }; | |
| var selection_selectAll = function(select) { | |
| if (typeof select !== "function") select = selectorAll(select); | |
| for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { | |
| if (node = group[i]) { | |
| subgroups.push(select.call(node, node.__data__, i, group)); | |
| parents.push(node); | |
| } | |
| } | |
| } | |
| return new Selection(subgroups, parents); | |
| }; | |
| var selection_filter = function(match) { | |
| if (typeof match !== "function") match = matcher$1(match); | |
| for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) { | |
| if ((node = group[i]) && match.call(node, node.__data__, i, group)) { | |
| subgroup.push(node); | |
| } | |
| } | |
| } | |
| return new Selection(subgroups, this._parents); | |
| }; | |
| var sparse = function(update) { | |
| return new Array(update.length); | |
| }; | |
| var selection_enter = function() { | |
| return new Selection(this._enter || this._groups.map(sparse), this._parents); | |
| }; | |
| function EnterNode(parent, datum) { | |
| this.ownerDocument = parent.ownerDocument; | |
| this.namespaceURI = parent.namespaceURI; | |
| this._next = null; | |
| this._parent = parent; | |
| this.__data__ = datum; | |
| } | |
| EnterNode.prototype = { | |
| constructor: EnterNode, | |
| appendChild: function(child) { return this._parent.insertBefore(child, this._next); }, | |
| insertBefore: function(child, next) { return this._parent.insertBefore(child, next); }, | |
| querySelector: function(selector) { return this._parent.querySelector(selector); }, | |
| querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); } | |
| }; | |
| var constant = function(x) { | |
| return function() { | |
| return x; | |
| }; | |
| }; | |
| var keyPrefix = "$"; // Protect against keys like “__proto__”. | |
| function bindIndex(parent, group, enter, update, exit, data) { | |
| var i = 0, | |
| node, | |
| groupLength = group.length, | |
| dataLength = data.length; | |
| // Put any non-null nodes that fit into update. | |
| // Put any null nodes into enter. | |
| // Put any remaining data into enter. | |
| for (; i < dataLength; ++i) { | |
| if (node = group[i]) { | |
| node.__data__ = data[i]; | |
| update[i] = node; | |
| } else { | |
| enter[i] = new EnterNode(parent, data[i]); | |
| } | |
| } | |
| // Put any non-null nodes that don’t fit into exit. | |
| for (; i < groupLength; ++i) { | |
| if (node = group[i]) { | |
| exit[i] = node; | |
| } | |
| } | |
| } | |
| function bindKey(parent, group, enter, update, exit, data, key) { | |
| var i, | |
| node, | |
| nodeByKeyValue = {}, | |
| groupLength = group.length, | |
| dataLength = data.length, | |
| keyValues = new Array(groupLength), | |
| keyValue; | |
| // Compute the key for each node. | |
| // If multiple nodes have the same key, the duplicates are added to exit. | |
| for (i = 0; i < groupLength; ++i) { | |
| if (node = group[i]) { | |
| keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group); | |
| if (keyValue in nodeByKeyValue) { | |
| exit[i] = node; | |
| } else { | |
| nodeByKeyValue[keyValue] = node; | |
| } | |
| } | |
| } | |
| // Compute the key for each datum. | |
| // If there a node associated with this key, join and add it to update. | |
| // If there is not (or the key is a duplicate), add it to enter. | |
| for (i = 0; i < dataLength; ++i) { | |
| keyValue = keyPrefix + key.call(parent, data[i], i, data); | |
| if (node = nodeByKeyValue[keyValue]) { | |
| update[i] = node; | |
| node.__data__ = data[i]; | |
| nodeByKeyValue[keyValue] = null; | |
| } else { | |
| enter[i] = new EnterNode(parent, data[i]); | |
| } | |
| } | |
| // Add any remaining nodes that were not bound to data to exit. | |
| for (i = 0; i < groupLength; ++i) { | |
| if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) { | |
| exit[i] = node; | |
| } | |
| } | |
| } | |
| var selection_data = function(value, key) { | |
| if (!value) { | |
| data = new Array(this.size()), j = -1; | |
| this.each(function(d) { data[++j] = d; }); | |
| return data; | |
| } | |
| var bind = key ? bindKey : bindIndex, | |
| parents = this._parents, | |
| groups = this._groups; | |
| if (typeof value !== "function") value = constant(value); | |
| for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) { | |
| var parent = parents[j], | |
| group = groups[j], | |
| groupLength = group.length, | |
| data = value.call(parent, parent && parent.__data__, j, parents), | |
| dataLength = data.length, | |
| enterGroup = enter[j] = new Array(dataLength), | |
| updateGroup = update[j] = new Array(dataLength), | |
| exitGroup = exit[j] = new Array(groupLength); | |
| bind(parent, group, enterGroup, updateGroup, exitGroup, data, key); | |
| // Now connect the enter nodes to their following update node, such that | |
| // appendChild can insert the materialized enter node before this node, | |
| // rather than at the end of the parent node. | |
| for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) { | |
| if (previous = enterGroup[i0]) { | |
| if (i0 >= i1) i1 = i0 + 1; | |
| while (!(next = updateGroup[i1]) && ++i1 < dataLength); | |
| previous._next = next || null; | |
| } | |
| } | |
| } | |
| update = new Selection(update, parents); | |
| update._enter = enter; | |
| update._exit = exit; | |
| return update; | |
| }; | |
| var selection_exit = function() { | |
| return new Selection(this._exit || this._groups.map(sparse), this._parents); | |
| }; | |
| var selection_merge = function(selection) { | |
| for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) { | |
| for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) { | |
| if (node = group0[i] || group1[i]) { | |
| merge[i] = node; | |
| } | |
| } | |
| } | |
| for (; j < m0; ++j) { | |
| merges[j] = groups0[j]; | |
| } | |
| return new Selection(merges, this._parents); | |
| }; | |
| var selection_order = function() { | |
| for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) { | |
| for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) { | |
| if (node = group[i]) { | |
| if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next); | |
| next = node; | |
| } | |
| } | |
| } | |
| return this; | |
| }; | |
| var selection_sort = function(compare) { | |
| if (!compare) compare = ascending; | |
| function compareNode(a, b) { | |
| return a && b ? compare(a.__data__, b.__data__) : !a - !b; | |
| } | |
| for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) { | |
| if (node = group[i]) { | |
| sortgroup[i] = node; | |
| } | |
| } | |
| sortgroup.sort(compareNode); | |
| } | |
| return new Selection(sortgroups, this._parents).order(); | |
| }; | |
| function ascending(a, b) { | |
| return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; | |
| } | |
| var selection_call = function() { | |
| var callback = arguments[0]; | |
| arguments[0] = this; | |
| callback.apply(null, arguments); | |
| return this; | |
| }; | |
| var selection_nodes = function() { | |
| var nodes = new Array(this.size()), i = -1; | |
| this.each(function() { nodes[++i] = this; }); | |
| return nodes; | |
| }; | |
| var selection_node = function() { | |
| for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { | |
| for (var group = groups[j], i = 0, n = group.length; i < n; ++i) { | |
| var node = group[i]; | |
| if (node) return node; | |
| } | |
| } | |
| return null; | |
| }; | |
| var selection_size = function() { | |
| var size = 0; | |
| this.each(function() { ++size; }); | |
| return size; | |
| }; | |
| var selection_empty = function() { | |
| return !this.node(); | |
| }; | |
| var selection_each = function(callback) { | |
| for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { | |
| for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) { | |
| if (node = group[i]) callback.call(node, node.__data__, i, group); | |
| } | |
| } | |
| return this; | |
| }; | |
| function attrRemove(name) { | |
| return function() { | |
| this.removeAttribute(name); | |
| }; | |
| } | |
| function attrRemoveNS(fullname) { | |
| return function() { | |
| this.removeAttributeNS(fullname.space, fullname.local); | |
| }; | |
| } | |
| function attrConstant(name, value) { | |
| return function() { | |
| this.setAttribute(name, value); | |
| }; | |
| } | |
| function attrConstantNS(fullname, value) { | |
| return function() { | |
| this.setAttributeNS(fullname.space, fullname.local, value); | |
| }; | |
| } | |
| function attrFunction(name, value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| if (v == null) this.removeAttribute(name); | |
| else this.setAttribute(name, v); | |
| }; | |
| } | |
| function attrFunctionNS(fullname, value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| if (v == null) this.removeAttributeNS(fullname.space, fullname.local); | |
| else this.setAttributeNS(fullname.space, fullname.local, v); | |
| }; | |
| } | |
| var selection_attr = function(name, value) { | |
| var fullname = namespace(name); | |
| if (arguments.length < 2) { | |
| var node = this.node(); | |
| return fullname.local | |
| ? node.getAttributeNS(fullname.space, fullname.local) | |
| : node.getAttribute(fullname); | |
| } | |
| return this.each((value == null | |
| ? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === "function" | |
| ? (fullname.local ? attrFunctionNS : attrFunction) | |
| : (fullname.local ? attrConstantNS : attrConstant)))(fullname, value)); | |
| }; | |
| var window$1 = function(node) { | |
| return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node | |
| || (node.document && node) // node is a Window | |
| || node.defaultView; // node is a Document | |
| }; | |
| function styleRemove(name) { | |
| return function() { | |
| this.style.removeProperty(name); | |
| }; | |
| } | |
| function styleConstant(name, value, priority) { | |
| return function() { | |
| this.style.setProperty(name, value, priority); | |
| }; | |
| } | |
| function styleFunction(name, value, priority) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| if (v == null) this.style.removeProperty(name); | |
| else this.style.setProperty(name, v, priority); | |
| }; | |
| } | |
| var selection_style = function(name, value, priority) { | |
| var node; | |
| return arguments.length > 1 | |
| ? this.each((value == null | |
| ? styleRemove : typeof value === "function" | |
| ? styleFunction | |
| : styleConstant)(name, value, priority == null ? "" : priority)) | |
| : window$1(node = this.node()) | |
| .getComputedStyle(node, null) | |
| .getPropertyValue(name); | |
| }; | |
| function propertyRemove(name) { | |
| return function() { | |
| delete this[name]; | |
| }; | |
| } | |
| function propertyConstant(name, value) { | |
| return function() { | |
| this[name] = value; | |
| }; | |
| } | |
| function propertyFunction(name, value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| if (v == null) delete this[name]; | |
| else this[name] = v; | |
| }; | |
| } | |
| var selection_property = function(name, value) { | |
| return arguments.length > 1 | |
| ? this.each((value == null | |
| ? propertyRemove : typeof value === "function" | |
| ? propertyFunction | |
| : propertyConstant)(name, value)) | |
| : this.node()[name]; | |
| }; | |
| function classArray(string) { | |
| return string.trim().split(/^|\s+/); | |
| } | |
| function classList(node) { | |
| return node.classList || new ClassList(node); | |
| } | |
| function ClassList(node) { | |
| this._node = node; | |
| this._names = classArray(node.getAttribute("class") || ""); | |
| } | |
| ClassList.prototype = { | |
| add: function(name) { | |
| var i = this._names.indexOf(name); | |
| if (i < 0) { | |
| this._names.push(name); | |
| this._node.setAttribute("class", this._names.join(" ")); | |
| } | |
| }, | |
| remove: function(name) { | |
| var i = this._names.indexOf(name); | |
| if (i >= 0) { | |
| this._names.splice(i, 1); | |
| this._node.setAttribute("class", this._names.join(" ")); | |
| } | |
| }, | |
| contains: function(name) { | |
| return this._names.indexOf(name) >= 0; | |
| } | |
| }; | |
| function classedAdd(node, names) { | |
| var list = classList(node), i = -1, n = names.length; | |
| while (++i < n) list.add(names[i]); | |
| } | |
| function classedRemove(node, names) { | |
| var list = classList(node), i = -1, n = names.length; | |
| while (++i < n) list.remove(names[i]); | |
| } | |
| function classedTrue(names) { | |
| return function() { | |
| classedAdd(this, names); | |
| }; | |
| } | |
| function classedFalse(names) { | |
| return function() { | |
| classedRemove(this, names); | |
| }; | |
| } | |
| function classedFunction(names, value) { | |
| return function() { | |
| (value.apply(this, arguments) ? classedAdd : classedRemove)(this, names); | |
| }; | |
| } | |
| var selection_classed = function(name, value) { | |
| var names = classArray(name + ""); | |
| if (arguments.length < 2) { | |
| var list = classList(this.node()), i = -1, n = names.length; | |
| while (++i < n) if (!list.contains(names[i])) return false; | |
| return true; | |
| } | |
| return this.each((typeof value === "function" | |
| ? classedFunction : value | |
| ? classedTrue | |
| : classedFalse)(names, value)); | |
| }; | |
| function textRemove() { | |
| this.textContent = ""; | |
| } | |
| function textConstant(value) { | |
| return function() { | |
| this.textContent = value; | |
| }; | |
| } | |
| function textFunction(value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| this.textContent = v == null ? "" : v; | |
| }; | |
| } | |
| var selection_text = function(value) { | |
| return arguments.length | |
| ? this.each(value == null | |
| ? textRemove : (typeof value === "function" | |
| ? textFunction | |
| : textConstant)(value)) | |
| : this.node().textContent; | |
| }; | |
| function htmlRemove() { | |
| this.innerHTML = ""; | |
| } | |
| function htmlConstant(value) { | |
| return function() { | |
| this.innerHTML = value; | |
| }; | |
| } | |
| function htmlFunction(value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| this.innerHTML = v == null ? "" : v; | |
| }; | |
| } | |
| var selection_html = function(value) { | |
| return arguments.length | |
| ? this.each(value == null | |
| ? htmlRemove : (typeof value === "function" | |
| ? htmlFunction | |
| : htmlConstant)(value)) | |
| : this.node().innerHTML; | |
| }; | |
| function raise() { | |
| if (this.nextSibling) this.parentNode.appendChild(this); | |
| } | |
| var selection_raise = function() { | |
| return this.each(raise); | |
| }; | |
| function lower() { | |
| if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild); | |
| } | |
| var selection_lower = function() { | |
| return this.each(lower); | |
| }; | |
| var selection_append = function(name) { | |
| var create = typeof name === "function" ? name : creator(name); | |
| return this.select(function() { | |
| return this.appendChild(create.apply(this, arguments)); | |
| }); | |
| }; | |
| function constantNull() { | |
| return null; | |
| } | |
| var selection_insert = function(name, before) { | |
| var create = typeof name === "function" ? name : creator(name), | |
| select = before == null ? constantNull : typeof before === "function" ? before : selector(before); | |
| return this.select(function() { | |
| return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null); | |
| }); | |
| }; | |
| function remove() { | |
| var parent = this.parentNode; | |
| if (parent) parent.removeChild(this); | |
| } | |
| var selection_remove = function() { | |
| return this.each(remove); | |
| }; | |
| var selection_datum = function(value) { | |
| return arguments.length | |
| ? this.property("__data__", value) | |
| : this.node().__data__; | |
| }; | |
| function dispatchEvent(node, type, params) { | |
| var window = window$1(node), | |
| event = window.CustomEvent; | |
| if (event) { | |
| event = new event(type, params); | |
| } else { | |
| event = window.document.createEvent("Event"); | |
| if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail; | |
| else event.initEvent(type, false, false); | |
| } | |
| node.dispatchEvent(event); | |
| } | |
| function dispatchConstant(type, params) { | |
| return function() { | |
| return dispatchEvent(this, type, params); | |
| }; | |
| } | |
| function dispatchFunction(type, params) { | |
| return function() { | |
| return dispatchEvent(this, type, params.apply(this, arguments)); | |
| }; | |
| } | |
| var selection_dispatch = function(type, params) { | |
| return this.each((typeof params === "function" | |
| ? dispatchFunction | |
| : dispatchConstant)(type, params)); | |
| }; | |
| var root = [null]; | |
| function Selection(groups, parents) { | |
| this._groups = groups; | |
| this._parents = parents; | |
| } | |
| function selection() { | |
| return new Selection([[document.documentElement]], root); | |
| } | |
| Selection.prototype = selection.prototype = { | |
| constructor: Selection, | |
| select: selection_select, | |
| selectAll: selection_selectAll, | |
| filter: selection_filter, | |
| data: selection_data, | |
| enter: selection_enter, | |
| exit: selection_exit, | |
| merge: selection_merge, | |
| order: selection_order, | |
| sort: selection_sort, | |
| call: selection_call, | |
| nodes: selection_nodes, | |
| node: selection_node, | |
| size: selection_size, | |
| empty: selection_empty, | |
| each: selection_each, | |
| attr: selection_attr, | |
| style: selection_style, | |
| property: selection_property, | |
| classed: selection_classed, | |
| text: selection_text, | |
| html: selection_html, | |
| raise: selection_raise, | |
| lower: selection_lower, | |
| append: selection_append, | |
| insert: selection_insert, | |
| remove: selection_remove, | |
| datum: selection_datum, | |
| on: selection_on, | |
| dispatch: selection_dispatch | |
| }; | |
| var select = function(selector) { | |
| return typeof selector === "string" | |
| ? new Selection([[document.querySelector(selector)]], [document.documentElement]) | |
| : new Selection([[selector]], root); | |
| }; | |
| // Computes the decimal coefficient and exponent of the specified number x with | |
| // significant digits p, where x is positive and p is in [1, 21] or undefined. | |
| // For example, formatDecimal(1.23) returns ["123", 0]. | |
| var formatDecimal = function(x, p) { | |
| if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf("e")) < 0) return null; // NaN, ±Infinity | |
| var i, coefficient = x.slice(0, i); | |
| // The string returned by toExponential either has the form \d\.\d+e[-+]\d+ | |
| // (e.g., 1.2e+3) or the form \de[-+]\d+ (e.g., 1e+3). | |
| return [ | |
| coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient, | |
| +x.slice(i + 1) | |
| ]; | |
| }; | |
| var exponent = function(x) { | |
| return x = formatDecimal(Math.abs(x)), x ? x[1] : NaN; | |
| }; | |
| var formatGroup = function(grouping, thousands) { | |
| return function(value, width) { | |
| var i = value.length, | |
| t = [], | |
| j = 0, | |
| g = grouping[0], | |
| length = 0; | |
| while (i > 0 && g > 0) { | |
| if (length + g + 1 > width) g = Math.max(1, width - length); | |
| t.push(value.substring(i -= g, i + g)); | |
| if ((length += g + 1) > width) break; | |
| g = grouping[j = (j + 1) % grouping.length]; | |
| } | |
| return t.reverse().join(thousands); | |
| }; | |
| }; | |
| var formatNumerals = function(numerals) { | |
| return function(value) { | |
| return value.replace(/[0-9]/g, function(i) { | |
| return numerals[+i]; | |
| }); | |
| }; | |
| }; | |
| var formatDefault = function(x, p) { | |
| x = x.toPrecision(p); | |
| out: for (var n = x.length, i = 1, i0 = -1, i1; i < n; ++i) { | |
| switch (x[i]) { | |
| case ".": i0 = i1 = i; break; | |
| case "0": if (i0 === 0) i0 = i; i1 = i; break; | |
| case "e": break out; | |
| default: if (i0 > 0) i0 = 0; break; | |
| } | |
| } | |
| return i0 > 0 ? x.slice(0, i0) + x.slice(i1 + 1) : x; | |
| }; | |
| var prefixExponent; | |
| var formatPrefixAuto = function(x, p) { | |
| var d = formatDecimal(x, p); | |
| if (!d) return x + ""; | |
| var coefficient = d[0], | |
| exponent = d[1], | |
| i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1, | |
| n = coefficient.length; | |
| return i === n ? coefficient | |
| : i > n ? coefficient + new Array(i - n + 1).join("0") | |
| : i > 0 ? coefficient.slice(0, i) + "." + coefficient.slice(i) | |
| : "0." + new Array(1 - i).join("0") + formatDecimal(x, Math.max(0, p + i - 1))[0]; // less than 1y! | |
| }; | |
| var formatRounded = function(x, p) { | |
| var d = formatDecimal(x, p); | |
| if (!d) return x + ""; | |
| var coefficient = d[0], | |
| exponent = d[1]; | |
| return exponent < 0 ? "0." + new Array(-exponent).join("0") + coefficient | |
| : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + "." + coefficient.slice(exponent + 1) | |
| : coefficient + new Array(exponent - coefficient.length + 2).join("0"); | |
| }; | |
| var formatTypes = { | |
| "": formatDefault, | |
| "%": function(x, p) { return (x * 100).toFixed(p); }, | |
| "b": function(x) { return Math.round(x).toString(2); }, | |
| "c": function(x) { return x + ""; }, | |
| "d": function(x) { return Math.round(x).toString(10); }, | |
| "e": function(x, p) { return x.toExponential(p); }, | |
| "f": function(x, p) { return x.toFixed(p); }, | |
| "g": function(x, p) { return x.toPrecision(p); }, | |
| "o": function(x) { return Math.round(x).toString(8); }, | |
| "p": function(x, p) { return formatRounded(x * 100, p); }, | |
| "r": formatRounded, | |
| "s": formatPrefixAuto, | |
| "X": function(x) { return Math.round(x).toString(16).toUpperCase(); }, | |
| "x": function(x) { return Math.round(x).toString(16); } | |
| }; | |
| // [[fill]align][sign][symbol][0][width][,][.precision][type] | |
| var re = /^(?:(.)?([<>=^]))?([+\-\( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?([a-z%])?$/i; | |
| function formatSpecifier(specifier) { | |
| return new FormatSpecifier(specifier); | |
| } | |
| formatSpecifier.prototype = FormatSpecifier.prototype; // instanceof | |
| function FormatSpecifier(specifier) { | |
| if (!(match = re.exec(specifier))) throw new Error("invalid format: " + specifier); | |
| var match, | |
| fill = match[1] || " ", | |
| align = match[2] || ">", | |
| sign = match[3] || "-", | |
| symbol = match[4] || "", | |
| zero = !!match[5], | |
| width = match[6] && +match[6], | |
| comma = !!match[7], | |
| precision = match[8] && +match[8].slice(1), | |
| type = match[9] || ""; | |
| // The "n" type is an alias for ",g". | |
| if (type === "n") comma = true, type = "g"; | |
| // Map invalid types to the default format. | |
| else if (!formatTypes[type]) type = ""; | |
| // If zero fill is specified, padding goes after sign and before digits. | |
| if (zero || (fill === "0" && align === "=")) zero = true, fill = "0", align = "="; | |
| this.fill = fill; | |
| this.align = align; | |
| this.sign = sign; | |
| this.symbol = symbol; | |
| this.zero = zero; | |
| this.width = width; | |
| this.comma = comma; | |
| this.precision = precision; | |
| this.type = type; | |
| } | |
| FormatSpecifier.prototype.toString = function() { | |
| return this.fill | |
| + this.align | |
| + this.sign | |
| + this.symbol | |
| + (this.zero ? "0" : "") | |
| + (this.width == null ? "" : Math.max(1, this.width | 0)) | |
| + (this.comma ? "," : "") | |
| + (this.precision == null ? "" : "." + Math.max(0, this.precision | 0)) | |
| + this.type; | |
| }; | |
| var identity = function(x) { | |
| return x; | |
| }; | |
| var prefixes = ["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"]; | |
| var formatLocale = function(locale) { | |
| var group = locale.grouping && locale.thousands ? formatGroup(locale.grouping, locale.thousands) : identity, | |
| currency = locale.currency, | |
| decimal = locale.decimal, | |
| numerals = locale.numerals ? formatNumerals(locale.numerals) : identity; | |
| function newFormat(specifier) { | |
| specifier = formatSpecifier(specifier); | |
| var fill = specifier.fill, | |
| align = specifier.align, | |
| sign = specifier.sign, | |
| symbol = specifier.symbol, | |
| zero = specifier.zero, | |
| width = specifier.width, | |
| comma = specifier.comma, | |
| precision = specifier.precision, | |
| type = specifier.type; | |
| // Compute the prefix and suffix. | |
| // For SI-prefix, the suffix is lazily computed. | |
| var prefix = symbol === "$" ? currency[0] : symbol === "#" && /[boxX]/.test(type) ? "0" + type.toLowerCase() : "", | |
| suffix = symbol === "$" ? currency[1] : /[%p]/.test(type) ? "%" : ""; | |
| // What format function should we use? | |
| // Is this an integer type? | |
| // Can this type generate exponential notation? | |
| var formatType = formatTypes[type], | |
| maybeSuffix = !type || /[defgprs%]/.test(type); | |
| // Set the default precision if not specified, | |
| // or clamp the specified precision to the supported range. | |
| // For significant precision, it must be in [1, 21]. | |
| // For fixed precision, it must be in [0, 20]. | |
| precision = precision == null ? (type ? 6 : 12) | |
| : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision)) | |
| : Math.max(0, Math.min(20, precision)); | |
| function format(value) { | |
| var valuePrefix = prefix, | |
| valueSuffix = suffix, | |
| i, n, c; | |
| if (type === "c") { | |
| valueSuffix = formatType(value) + valueSuffix; | |
| value = ""; | |
| } else { | |
| value = +value; | |
| // Perform the initial formatting. | |
| var valueNegative = value < 0; | |
| value = formatType(Math.abs(value), precision); | |
| // If a negative value rounds to zero during formatting, treat as positive. | |
| if (valueNegative && +value === 0) valueNegative = false; | |
| // Compute the prefix and suffix. | |
| valuePrefix = (valueNegative ? (sign === "(" ? sign : "-") : sign === "-" || sign === "(" ? "" : sign) + valuePrefix; | |
| valueSuffix = valueSuffix + (type === "s" ? prefixes[8 + prefixExponent / 3] : "") + (valueNegative && sign === "(" ? ")" : ""); | |
| // Break the formatted value into the integer “value” part that can be | |
| // grouped, and fractional or exponential “suffix” part that is not. | |
| if (maybeSuffix) { | |
| i = -1, n = value.length; | |
| while (++i < n) { | |
| if (c = value.charCodeAt(i), 48 > c || c > 57) { | |
| valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix; | |
| value = value.slice(0, i); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| // If the fill character is not "0", grouping is applied before padding. | |
| if (comma && !zero) value = group(value, Infinity); | |
| // Compute the padding. | |
| var length = valuePrefix.length + value.length + valueSuffix.length, | |
| padding = length < width ? new Array(width - length + 1).join(fill) : ""; | |
| // If the fill character is "0", grouping is applied after padding. | |
| if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = ""; | |
| // Reconstruct the final output based on the desired alignment. | |
| switch (align) { | |
| case "<": value = valuePrefix + value + valueSuffix + padding; break; | |
| case "=": value = valuePrefix + padding + value + valueSuffix; break; | |
| case "^": value = padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length); break; | |
| default: value = padding + valuePrefix + value + valueSuffix; break; | |
| } | |
| return numerals(value); | |
| } | |
| format.toString = function() { | |
| return specifier + ""; | |
| }; | |
| return format; | |
| } | |
| function formatPrefix(specifier, value) { | |
| var f = newFormat((specifier = formatSpecifier(specifier), specifier.type = "f", specifier)), | |
| e = Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3, | |
| k = Math.pow(10, -e), | |
| prefix = prefixes[8 + e / 3]; | |
| return function(value) { | |
| return f(k * value) + prefix; | |
| }; | |
| } | |
| return { | |
| format: newFormat, | |
| formatPrefix: formatPrefix | |
| }; | |
| }; | |
| var locale$1; | |
| var format; | |
| var formatPrefix; | |
| defaultLocale({ | |
| decimal: ".", | |
| thousands: ",", | |
| grouping: [3], | |
| currency: ["$", ""] | |
| }); | |
| function defaultLocale(definition) { | |
| locale$1 = formatLocale(definition); | |
| format = locale$1.format; | |
| formatPrefix = locale$1.formatPrefix; | |
| return locale$1; | |
| } | |
| var precisionFixed = function(step) { | |
| return Math.max(0, -exponent(Math.abs(step))); | |
| }; | |
| var precisionPrefix = function(step, value) { | |
| return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3 - exponent(Math.abs(step))); | |
| }; | |
| var precisionRound = function(step, max) { | |
| step = Math.abs(step), max = Math.abs(max) - step; | |
| return Math.max(0, exponent(max) - exponent(step)) + 1; | |
| }; | |
| var noop = {value: function() {}}; | |
| function dispatch() { | |
| for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) { | |
| if (!(t = arguments[i] + "") || (t in _)) throw new Error("illegal type: " + t); | |
| _[t] = []; | |
| } | |
| return new Dispatch(_); | |
| } | |
| function Dispatch(_) { | |
| this._ = _; | |
| } | |
| function parseTypenames$1(typenames, types) { | |
| return typenames.trim().split(/^|\s+/).map(function(t) { | |
| var name = "", i = t.indexOf("."); | |
| if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i); | |
| if (t && !types.hasOwnProperty(t)) throw new Error("unknown type: " + t); | |
| return {type: t, name: name}; | |
| }); | |
| } | |
| Dispatch.prototype = dispatch.prototype = { | |
| constructor: Dispatch, | |
| on: function(typename, callback) { | |
| var _ = this._, | |
| T = parseTypenames$1(typename + "", _), | |
| t, | |
| i = -1, | |
| n = T.length; | |
| // If no callback was specified, return the callback of the given type and name. | |
| if (arguments.length < 2) { | |
| while (++i < n) if ((t = (typename = T[i]).type) && (t = get$1(_[t], typename.name))) return t; | |
| return; | |
| } | |
| // If a type was specified, set the callback for the given type and name. | |
| // Otherwise, if a null callback was specified, remove callbacks of the given name. | |
| if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback); | |
| while (++i < n) { | |
| if (t = (typename = T[i]).type) _[t] = set$1(_[t], typename.name, callback); | |
| else if (callback == null) for (t in _) _[t] = set$1(_[t], typename.name, null); | |
| } | |
| return this; | |
| }, | |
| copy: function() { | |
| var copy = {}, _ = this._; | |
| for (var t in _) copy[t] = _[t].slice(); | |
| return new Dispatch(copy); | |
| }, | |
| call: function(type, that) { | |
| if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2]; | |
| if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type); | |
| for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args); | |
| }, | |
| apply: function(type, that, args) { | |
| if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type); | |
| for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args); | |
| } | |
| }; | |
| function get$1(type, name) { | |
| for (var i = 0, n = type.length, c; i < n; ++i) { | |
| if ((c = type[i]).name === name) { | |
| return c.value; | |
| } | |
| } | |
| } | |
| function set$1(type, name, callback) { | |
| for (var i = 0, n = type.length; i < n; ++i) { | |
| if (type[i].name === name) { | |
| type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1)); | |
| break; | |
| } | |
| } | |
| if (callback != null) type.push({name: name, value: callback}); | |
| return type; | |
| } | |
| var frame = 0; | |
| var timeout = 0; | |
| var interval = 0; | |
| var pokeDelay = 1000; | |
| var taskHead; | |
| var taskTail; | |
| var clockLast = 0; | |
| var clockNow = 0; | |
| var clockSkew = 0; | |
| var clock = typeof performance === "object" && performance.now ? performance : Date; | |
| var setFrame = typeof requestAnimationFrame === "function" ? requestAnimationFrame : function(f) { setTimeout(f, 17); }; | |
| function now() { | |
| return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew); | |
| } | |
| function clearNow() { | |
| clockNow = 0; | |
| } | |
| function Timer() { | |
| this._call = | |
| this._time = | |
| this._next = null; | |
| } | |
| Timer.prototype = timer.prototype = { | |
| constructor: Timer, | |
| restart: function(callback, delay, time) { | |
| if (typeof callback !== "function") throw new TypeError("callback is not a function"); | |
| time = (time == null ? now() : +time) + (delay == null ? 0 : +delay); | |
| if (!this._next && taskTail !== this) { | |
| if (taskTail) taskTail._next = this; | |
| else taskHead = this; | |
| taskTail = this; | |
| } | |
| this._call = callback; | |
| this._time = time; | |
| sleep(); | |
| }, | |
| stop: function() { | |
| if (this._call) { | |
| this._call = null; | |
| this._time = Infinity; | |
| sleep(); | |
| } | |
| } | |
| }; | |
| function timer(callback, delay, time) { | |
| var t = new Timer; | |
| t.restart(callback, delay, time); | |
| return t; | |
| } | |
| function timerFlush() { | |
| now(); // Get the current time, if not already set. | |
| ++frame; // Pretend we’ve set an alarm, if we haven’t already. | |
| var t = taskHead, e; | |
| while (t) { | |
| if ((e = clockNow - t._time) >= 0) t._call.call(null, e); | |
| t = t._next; | |
| } | |
| --frame; | |
| } | |
| function wake() { | |
| clockNow = (clockLast = clock.now()) + clockSkew; | |
| frame = timeout = 0; | |
| try { | |
| timerFlush(); | |
| } finally { | |
| frame = 0; | |
| nap(); | |
| clockNow = 0; | |
| } | |
| } | |
| function poke() { | |
| var now = clock.now(), delay = now - clockLast; | |
| if (delay > pokeDelay) clockSkew -= delay, clockLast = now; | |
| } | |
| function nap() { | |
| var t0, t1 = taskHead, t2, time = Infinity; | |
| while (t1) { | |
| if (t1._call) { | |
| if (time > t1._time) time = t1._time; | |
| t0 = t1, t1 = t1._next; | |
| } else { | |
| t2 = t1._next, t1._next = null; | |
| t1 = t0 ? t0._next = t2 : taskHead = t2; | |
| } | |
| } | |
| taskTail = t0; | |
| sleep(time); | |
| } | |
| function sleep(time) { | |
| if (frame) return; // Soonest alarm already set, or will be. | |
| if (timeout) timeout = clearTimeout(timeout); | |
| var delay = time - clockNow; | |
| if (delay > 24) { | |
| if (time < Infinity) timeout = setTimeout(wake, delay); | |
| if (interval) interval = clearInterval(interval); | |
| } else { | |
| if (!interval) clockLast = clockNow, interval = setInterval(poke, pokeDelay); | |
| frame = 1, setFrame(wake); | |
| } | |
| } | |
| var timeout$1 = function(callback, delay, time) { | |
| var t = new Timer; | |
| delay = delay == null ? 0 : +delay; | |
| t.restart(function(elapsed) { | |
| t.stop(); | |
| callback(elapsed + delay); | |
| }, delay, time); | |
| return t; | |
| }; | |
| var emptyOn = dispatch("start", "end", "interrupt"); | |
| var emptyTween = []; | |
| var CREATED = 0; | |
| var SCHEDULED = 1; | |
| var STARTING = 2; | |
| var STARTED = 3; | |
| var RUNNING = 4; | |
| var ENDING = 5; | |
| var ENDED = 6; | |
| var schedule = function(node, name, id, index, group, timing) { | |
| var schedules = node.__transition; | |
| if (!schedules) node.__transition = {}; | |
| else if (id in schedules) return; | |
| create(node, id, { | |
| name: name, | |
| index: index, // For context during callback. | |
| group: group, // For context during callback. | |
| on: emptyOn, | |
| tween: emptyTween, | |
| time: timing.time, | |
| delay: timing.delay, | |
| duration: timing.duration, | |
| ease: timing.ease, | |
| timer: null, | |
| state: CREATED | |
| }); | |
| }; | |
| function init(node, id) { | |
| var schedule = node.__transition; | |
| if (!schedule || !(schedule = schedule[id]) || schedule.state > CREATED) throw new Error("too late"); | |
| return schedule; | |
| } | |
| function set(node, id) { | |
| var schedule = node.__transition; | |
| if (!schedule || !(schedule = schedule[id]) || schedule.state > STARTING) throw new Error("too late"); | |
| return schedule; | |
| } | |
| function get(node, id) { | |
| var schedule = node.__transition; | |
| if (!schedule || !(schedule = schedule[id])) throw new Error("too late"); | |
| return schedule; | |
| } | |
| function create(node, id, self) { | |
| var schedules = node.__transition, | |
| tween; | |
| // Initialize the self timer when the transition is created. | |
| // Note the actual delay is not known until the first callback! | |
| schedules[id] = self; | |
| self.timer = timer(schedule, 0, self.time); | |
| function schedule(elapsed) { | |
| self.state = SCHEDULED; | |
| self.timer.restart(start, self.delay, self.time); | |
| // If the elapsed delay is less than our first sleep, start immediately. | |
| if (self.delay <= elapsed) start(elapsed - self.delay); | |
| } | |
| function start(elapsed) { | |
| var i, j, n, o; | |
| // If the state is not SCHEDULED, then we previously errored on start. | |
| if (self.state !== SCHEDULED) return stop(); | |
| for (i in schedules) { | |
| o = schedules[i]; | |
| if (o.name !== self.name) continue; | |
| // While this element already has a starting transition during this frame, | |
| // defer starting an interrupting transition until that transition has a | |
| // chance to tick (and possibly end); see d3/d3-transition#54! | |
| if (o.state === STARTED) return timeout$1(start); | |
| // Interrupt the active transition, if any. | |
| // Dispatch the interrupt event. | |
| if (o.state === RUNNING) { | |
| o.state = ENDED; | |
| o.timer.stop(); | |
| o.on.call("interrupt", node, node.__data__, o.index, o.group); | |
| delete schedules[i]; | |
| } | |
| // Cancel any pre-empted transitions. No interrupt event is dispatched | |
| // because the cancelled transitions never started. Note that this also | |
| // removes this transition from the pending list! | |
| else if (+i < id) { | |
| o.state = ENDED; | |
| o.timer.stop(); | |
| delete schedules[i]; | |
| } | |
| } | |
| // Defer the first tick to end of the current frame; see d3/d3#1576. | |
| // Note the transition may be canceled after start and before the first tick! | |
| // Note this must be scheduled before the start event; see d3/d3-transition#16! | |
| // Assuming this is successful, subsequent callbacks go straight to tick. | |
| timeout$1(function() { | |
| if (self.state === STARTED) { | |
| self.state = RUNNING; | |
| self.timer.restart(tick, self.delay, self.time); | |
| tick(elapsed); | |
| } | |
| }); | |
| // Dispatch the start event. | |
| // Note this must be done before the tween are initialized. | |
| self.state = STARTING; | |
| self.on.call("start", node, node.__data__, self.index, self.group); | |
| if (self.state !== STARTING) return; // interrupted | |
| self.state = STARTED; | |
| // Initialize the tween, deleting null tween. | |
| tween = new Array(n = self.tween.length); | |
| for (i = 0, j = -1; i < n; ++i) { | |
| if (o = self.tween[i].value.call(node, node.__data__, self.index, self.group)) { | |
| tween[++j] = o; | |
| } | |
| } | |
| tween.length = j + 1; | |
| } | |
| function tick(elapsed) { | |
| var t = elapsed < self.duration ? self.ease.call(null, elapsed / self.duration) : (self.timer.restart(stop), self.state = ENDING, 1), | |
| i = -1, | |
| n = tween.length; | |
| while (++i < n) { | |
| tween[i].call(null, t); | |
| } | |
| // Dispatch the end event. | |
| if (self.state === ENDING) { | |
| self.on.call("end", node, node.__data__, self.index, self.group); | |
| stop(); | |
| } | |
| } | |
| function stop() { | |
| self.state = ENDED; | |
| self.timer.stop(); | |
| delete schedules[id]; | |
| for (var i in schedules) return; // eslint-disable-line no-unused-vars | |
| delete node.__transition; | |
| } | |
| } | |
| var interrupt = function(node, name) { | |
| var schedules = node.__transition, | |
| schedule, | |
| active, | |
| empty = true, | |
| i; | |
| if (!schedules) return; | |
| name = name == null ? null : name + ""; | |
| for (i in schedules) { | |
| if ((schedule = schedules[i]).name !== name) { empty = false; continue; } | |
| active = schedule.state > STARTING && schedule.state < ENDING; | |
| schedule.state = ENDED; | |
| schedule.timer.stop(); | |
| if (active) schedule.on.call("interrupt", node, node.__data__, schedule.index, schedule.group); | |
| delete schedules[i]; | |
| } | |
| if (empty) delete node.__transition; | |
| }; | |
| var selection_interrupt = function(name) { | |
| return this.each(function() { | |
| interrupt(this, name); | |
| }); | |
| }; | |
| var define = function(constructor, factory, prototype) { | |
| constructor.prototype = factory.prototype = prototype; | |
| prototype.constructor = constructor; | |
| }; | |
| function extend(parent, definition) { | |
| var prototype = Object.create(parent.prototype); | |
| for (var key in definition) prototype[key] = definition[key]; | |
| return prototype; | |
| } | |
| function Color() {} | |
| var darker = 0.7; | |
| var brighter = 1 / darker; | |
| var reI = "\\s*([+-]?\\d+)\\s*"; | |
| var reN = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*"; | |
| var reP = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*"; | |
| var reHex3 = /^#([0-9a-f]{3})$/; | |
| var reHex6 = /^#([0-9a-f]{6})$/; | |
| var reRgbInteger = new RegExp("^rgb\\(" + [reI, reI, reI] + "\\)$"); | |
| var reRgbPercent = new RegExp("^rgb\\(" + [reP, reP, reP] + "\\)$"); | |
| var reRgbaInteger = new RegExp("^rgba\\(" + [reI, reI, reI, reN] + "\\)$"); | |
| var reRgbaPercent = new RegExp("^rgba\\(" + [reP, reP, reP, reN] + "\\)$"); | |
| var reHslPercent = new RegExp("^hsl\\(" + [reN, reP, reP] + "\\)$"); | |
| var reHslaPercent = new RegExp("^hsla\\(" + [reN, reP, reP, reN] + "\\)$"); | |
| var named = { | |
| aliceblue: 0xf0f8ff, | |
| antiquewhite: 0xfaebd7, | |
| aqua: 0x00ffff, | |
| aquamarine: 0x7fffd4, | |
| azure: 0xf0ffff, | |
| beige: 0xf5f5dc, | |
| bisque: 0xffe4c4, | |
| black: 0x000000, | |
| blanchedalmond: 0xffebcd, | |
| blue: 0x0000ff, | |
| blueviolet: 0x8a2be2, | |
| brown: 0xa52a2a, | |
| burlywood: 0xdeb887, | |
| cadetblue: 0x5f9ea0, | |
| chartreuse: 0x7fff00, | |
| chocolate: 0xd2691e, | |
| coral: 0xff7f50, | |
| cornflowerblue: 0x6495ed, | |
| cornsilk: 0xfff8dc, | |
| crimson: 0xdc143c, | |
| cyan: 0x00ffff, | |
| darkblue: 0x00008b, | |
| darkcyan: 0x008b8b, | |
| darkgoldenrod: 0xb8860b, | |
| darkgray: 0xa9a9a9, | |
| darkgreen: 0x006400, | |
| darkgrey: 0xa9a9a9, | |
| darkkhaki: 0xbdb76b, | |
| darkmagenta: 0x8b008b, | |
| darkolivegreen: 0x556b2f, | |
| darkorange: 0xff8c00, | |
| darkorchid: 0x9932cc, | |
| darkred: 0x8b0000, | |
| darksalmon: 0xe9967a, | |
| darkseagreen: 0x8fbc8f, | |
| darkslateblue: 0x483d8b, | |
| darkslategray: 0x2f4f4f, | |
| darkslategrey: 0x2f4f4f, | |
| darkturquoise: 0x00ced1, | |
| darkviolet: 0x9400d3, | |
| deeppink: 0xff1493, | |
| deepskyblue: 0x00bfff, | |
| dimgray: 0x696969, | |
| dimgrey: 0x696969, | |
| dodgerblue: 0x1e90ff, | |
| firebrick: 0xb22222, | |
| floralwhite: 0xfffaf0, | |
| forestgreen: 0x228b22, | |
| fuchsia: 0xff00ff, | |
| gainsboro: 0xdcdcdc, | |
| ghostwhite: 0xf8f8ff, | |
| gold: 0xffd700, | |
| goldenrod: 0xdaa520, | |
| gray: 0x808080, | |
| green: 0x008000, | |
| greenyellow: 0xadff2f, | |
| grey: 0x808080, | |
| honeydew: 0xf0fff0, | |
| hotpink: 0xff69b4, | |
| indianred: 0xcd5c5c, | |
| indigo: 0x4b0082, | |
| ivory: 0xfffff0, | |
| khaki: 0xf0e68c, | |
| lavender: 0xe6e6fa, | |
| lavenderblush: 0xfff0f5, | |
| lawngreen: 0x7cfc00, | |
| lemonchiffon: 0xfffacd, | |
| lightblue: 0xadd8e6, | |
| lightcoral: 0xf08080, | |
| lightcyan: 0xe0ffff, | |
| lightgoldenrodyellow: 0xfafad2, | |
| lightgray: 0xd3d3d3, | |
| lightgreen: 0x90ee90, | |
| lightgrey: 0xd3d3d3, | |
| lightpink: 0xffb6c1, | |
| lightsalmon: 0xffa07a, | |
| lightseagreen: 0x20b2aa, | |
| lightskyblue: 0x87cefa, | |
| lightslategray: 0x778899, | |
| lightslategrey: 0x778899, | |
| lightsteelblue: 0xb0c4de, | |
| lightyellow: 0xffffe0, | |
| lime: 0x00ff00, | |
| limegreen: 0x32cd32, | |
| linen: 0xfaf0e6, | |
| magenta: 0xff00ff, | |
| maroon: 0x800000, | |
| mediumaquamarine: 0x66cdaa, | |
| mediumblue: 0x0000cd, | |
| mediumorchid: 0xba55d3, | |
| mediumpurple: 0x9370db, | |
| mediumseagreen: 0x3cb371, | |
| mediumslateblue: 0x7b68ee, | |
| mediumspringgreen: 0x00fa9a, | |
| mediumturquoise: 0x48d1cc, | |
| mediumvioletred: 0xc71585, | |
| midnightblue: 0x191970, | |
| mintcream: 0xf5fffa, | |
| mistyrose: 0xffe4e1, | |
| moccasin: 0xffe4b5, | |
| navajowhite: 0xffdead, | |
| navy: 0x000080, | |
| oldlace: 0xfdf5e6, | |
| olive: 0x808000, | |
| olivedrab: 0x6b8e23, | |
| orange: 0xffa500, | |
| orangered: 0xff4500, | |
| orchid: 0xda70d6, | |
| palegoldenrod: 0xeee8aa, | |
| palegreen: 0x98fb98, | |
| paleturquoise: 0xafeeee, | |
| palevioletred: 0xdb7093, | |
| papayawhip: 0xffefd5, | |
| peachpuff: 0xffdab9, | |
| peru: 0xcd853f, | |
| pink: 0xffc0cb, | |
| plum: 0xdda0dd, | |
| powderblue: 0xb0e0e6, | |
| purple: 0x800080, | |
| rebeccapurple: 0x663399, | |
| red: 0xff0000, | |
| rosybrown: 0xbc8f8f, | |
| royalblue: 0x4169e1, | |
| saddlebrown: 0x8b4513, | |
| salmon: 0xfa8072, | |
| sandybrown: 0xf4a460, | |
| seagreen: 0x2e8b57, | |
| seashell: 0xfff5ee, | |
| sienna: 0xa0522d, | |
| silver: 0xc0c0c0, | |
| skyblue: 0x87ceeb, | |
| slateblue: 0x6a5acd, | |
| slategray: 0x708090, | |
| slategrey: 0x708090, | |
| snow: 0xfffafa, | |
| springgreen: 0x00ff7f, | |
| steelblue: 0x4682b4, | |
| tan: 0xd2b48c, | |
| teal: 0x008080, | |
| thistle: 0xd8bfd8, | |
| tomato: 0xff6347, | |
| turquoise: 0x40e0d0, | |
| violet: 0xee82ee, | |
| wheat: 0xf5deb3, | |
| white: 0xffffff, | |
| whitesmoke: 0xf5f5f5, | |
| yellow: 0xffff00, | |
| yellowgreen: 0x9acd32 | |
| }; | |
| define(Color, color, { | |
| displayable: function() { | |
| return this.rgb().displayable(); | |
| }, | |
| toString: function() { | |
| return this.rgb() + ""; | |
| } | |
| }); | |
| function color(format) { | |
| var m; | |
| format = (format + "").trim().toLowerCase(); | |
| return (m = reHex3.exec(format)) ? (m = parseInt(m[1], 16), new Rgb((m >> 8 & 0xf) | (m >> 4 & 0x0f0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1)) // #f00 | |
| : (m = reHex6.exec(format)) ? rgbn(parseInt(m[1], 16)) // #ff0000 | |
| : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0) | |
| : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%) | |
| : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1) | |
| : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1) | |
| : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%) | |
| : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1) | |
| : named.hasOwnProperty(format) ? rgbn(named[format]) | |
| : format === "transparent" ? new Rgb(NaN, NaN, NaN, 0) | |
| : null; | |
| } | |
| function rgbn(n) { | |
| return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1); | |
| } | |
| function rgba(r, g, b, a) { | |
| if (a <= 0) r = g = b = NaN; | |
| return new Rgb(r, g, b, a); | |
| } | |
| function rgbConvert(o) { | |
| if (!(o instanceof Color)) o = color(o); | |
| if (!o) return new Rgb; | |
| o = o.rgb(); | |
| return new Rgb(o.r, o.g, o.b, o.opacity); | |
| } | |
| function rgb(r, g, b, opacity) { | |
| return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity); | |
| } | |
| function Rgb(r, g, b, opacity) { | |
| this.r = +r; | |
| this.g = +g; | |
| this.b = +b; | |
| this.opacity = +opacity; | |
| } | |
| define(Rgb, rgb, extend(Color, { | |
| brighter: function(k) { | |
| k = k == null ? brighter : Math.pow(brighter, k); | |
| return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity); | |
| }, | |
| darker: function(k) { | |
| k = k == null ? darker : Math.pow(darker, k); | |
| return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity); | |
| }, | |
| rgb: function() { | |
| return this; | |
| }, | |
| displayable: function() { | |
| return (0 <= this.r && this.r <= 255) | |
| && (0 <= this.g && this.g <= 255) | |
| && (0 <= this.b && this.b <= 255) | |
| && (0 <= this.opacity && this.opacity <= 1); | |
| }, | |
| toString: function() { | |
| var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a)); | |
| return (a === 1 ? "rgb(" : "rgba(") | |
| + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", " | |
| + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", " | |
| + Math.max(0, Math.min(255, Math.round(this.b) || 0)) | |
| + (a === 1 ? ")" : ", " + a + ")"); | |
| } | |
| })); | |
| function hsla(h, s, l, a) { | |
| if (a <= 0) h = s = l = NaN; | |
| else if (l <= 0 || l >= 1) h = s = NaN; | |
| else if (s <= 0) h = NaN; | |
| return new Hsl(h, s, l, a); | |
| } | |
| function hslConvert(o) { | |
| if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity); | |
| if (!(o instanceof Color)) o = color(o); | |
| if (!o) return new Hsl; | |
| if (o instanceof Hsl) return o; | |
| o = o.rgb(); | |
| var r = o.r / 255, | |
| g = o.g / 255, | |
| b = o.b / 255, | |
| min = Math.min(r, g, b), | |
| max = Math.max(r, g, b), | |
| h = NaN, | |
| s = max - min, | |
| l = (max + min) / 2; | |
| if (s) { | |
| if (r === max) h = (g - b) / s + (g < b) * 6; | |
| else if (g === max) h = (b - r) / s + 2; | |
| else h = (r - g) / s + 4; | |
| s /= l < 0.5 ? max + min : 2 - max - min; | |
| h *= 60; | |
| } else { | |
| s = l > 0 && l < 1 ? 0 : h; | |
| } | |
| return new Hsl(h, s, l, o.opacity); | |
| } | |
| function hsl(h, s, l, opacity) { | |
| return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity); | |
| } | |
| function Hsl(h, s, l, opacity) { | |
| this.h = +h; | |
| this.s = +s; | |
| this.l = +l; | |
| this.opacity = +opacity; | |
| } | |
| define(Hsl, hsl, extend(Color, { | |
| brighter: function(k) { | |
| k = k == null ? brighter : Math.pow(brighter, k); | |
| return new Hsl(this.h, this.s, this.l * k, this.opacity); | |
| }, | |
| darker: function(k) { | |
| k = k == null ? darker : Math.pow(darker, k); | |
| return new Hsl(this.h, this.s, this.l * k, this.opacity); | |
| }, | |
| rgb: function() { | |
| var h = this.h % 360 + (this.h < 0) * 360, | |
| s = isNaN(h) || isNaN(this.s) ? 0 : this.s, | |
| l = this.l, | |
| m2 = l + (l < 0.5 ? l : 1 - l) * s, | |
| m1 = 2 * l - m2; | |
| return new Rgb( | |
| hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2), | |
| hsl2rgb(h, m1, m2), | |
| hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2), | |
| this.opacity | |
| ); | |
| }, | |
| displayable: function() { | |
| return (0 <= this.s && this.s <= 1 || isNaN(this.s)) | |
| && (0 <= this.l && this.l <= 1) | |
| && (0 <= this.opacity && this.opacity <= 1); | |
| } | |
| })); | |
| /* From FvD 13.37, CSS Color Module Level 3 */ | |
| function hsl2rgb(h, m1, m2) { | |
| return (h < 60 ? m1 + (m2 - m1) * h / 60 | |
| : h < 180 ? m2 | |
| : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60 | |
| : m1) * 255; | |
| } | |
| var deg2rad = Math.PI / 180; | |
| var rad2deg = 180 / Math.PI; | |
| var Kn = 18; | |
| var Xn = 0.950470; | |
| var Yn = 1; | |
| var Zn = 1.088830; | |
| var t0 = 4 / 29; | |
| var t1 = 6 / 29; | |
| var t2 = 3 * t1 * t1; | |
| var t3 = t1 * t1 * t1; | |
| function labConvert(o) { | |
| if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity); | |
| if (o instanceof Hcl) { | |
| var h = o.h * deg2rad; | |
| return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity); | |
| } | |
| if (!(o instanceof Rgb)) o = rgbConvert(o); | |
| var b = rgb2xyz(o.r), | |
| a = rgb2xyz(o.g), | |
| l = rgb2xyz(o.b), | |
| x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn), | |
| y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.0721750 * l) / Yn), | |
| z = xyz2lab((0.0193339 * b + 0.1191920 * a + 0.9503041 * l) / Zn); | |
| return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity); | |
| } | |
| function lab(l, a, b, opacity) { | |
| return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity); | |
| } | |
| function Lab(l, a, b, opacity) { | |
| this.l = +l; | |
| this.a = +a; | |
| this.b = +b; | |
| this.opacity = +opacity; | |
| } | |
| define(Lab, lab, extend(Color, { | |
| brighter: function(k) { | |
| return new Lab(this.l + Kn * (k == null ? 1 : k), this.a, this.b, this.opacity); | |
| }, | |
| darker: function(k) { | |
| return new Lab(this.l - Kn * (k == null ? 1 : k), this.a, this.b, this.opacity); | |
| }, | |
| rgb: function() { | |
| var y = (this.l + 16) / 116, | |
| x = isNaN(this.a) ? y : y + this.a / 500, | |
| z = isNaN(this.b) ? y : y - this.b / 200; | |
| y = Yn * lab2xyz(y); | |
| x = Xn * lab2xyz(x); | |
| z = Zn * lab2xyz(z); | |
| return new Rgb( | |
| xyz2rgb( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB | |
| xyz2rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z), | |
| xyz2rgb( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z), | |
| this.opacity | |
| ); | |
| } | |
| })); | |
| function xyz2lab(t) { | |
| return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0; | |
| } | |
| function lab2xyz(t) { | |
| return t > t1 ? t * t * t : t2 * (t - t0); | |
| } | |
| function xyz2rgb(x) { | |
| return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055); | |
| } | |
| function rgb2xyz(x) { | |
| return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4); | |
| } | |
| function hclConvert(o) { | |
| if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity); | |
| if (!(o instanceof Lab)) o = labConvert(o); | |
| var h = Math.atan2(o.b, o.a) * rad2deg; | |
| return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity); | |
| } | |
| function hcl(h, c, l, opacity) { | |
| return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity); | |
| } | |
| function Hcl(h, c, l, opacity) { | |
| this.h = +h; | |
| this.c = +c; | |
| this.l = +l; | |
| this.opacity = +opacity; | |
| } | |
| define(Hcl, hcl, extend(Color, { | |
| brighter: function(k) { | |
| return new Hcl(this.h, this.c, this.l + Kn * (k == null ? 1 : k), this.opacity); | |
| }, | |
| darker: function(k) { | |
| return new Hcl(this.h, this.c, this.l - Kn * (k == null ? 1 : k), this.opacity); | |
| }, | |
| rgb: function() { | |
| return labConvert(this).rgb(); | |
| } | |
| })); | |
| var A = -0.14861; | |
| var B = +1.78277; | |
| var C = -0.29227; | |
| var D = -0.90649; | |
| var E = +1.97294; | |
| var ED = E * D; | |
| var EB = E * B; | |
| var BC_DA = B * C - D * A; | |
| function cubehelixConvert(o) { | |
| if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity); | |
| if (!(o instanceof Rgb)) o = rgbConvert(o); | |
| var r = o.r / 255, | |
| g = o.g / 255, | |
| b = o.b / 255, | |
| l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB), | |
| bl = b - l, | |
| k = (E * (g - l) - C * bl) / D, | |
| s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1 | |
| h = s ? Math.atan2(k, bl) * rad2deg - 120 : NaN; | |
| return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity); | |
| } | |
| function cubehelix(h, s, l, opacity) { | |
| return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity); | |
| } | |
| function Cubehelix(h, s, l, opacity) { | |
| this.h = +h; | |
| this.s = +s; | |
| this.l = +l; | |
| this.opacity = +opacity; | |
| } | |
| define(Cubehelix, cubehelix, extend(Color, { | |
| brighter: function(k) { | |
| k = k == null ? brighter : Math.pow(brighter, k); | |
| return new Cubehelix(this.h, this.s, this.l * k, this.opacity); | |
| }, | |
| darker: function(k) { | |
| k = k == null ? darker : Math.pow(darker, k); | |
| return new Cubehelix(this.h, this.s, this.l * k, this.opacity); | |
| }, | |
| rgb: function() { | |
| var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad, | |
| l = +this.l, | |
| a = isNaN(this.s) ? 0 : this.s * l * (1 - l), | |
| cosh = Math.cos(h), | |
| sinh = Math.sin(h); | |
| return new Rgb( | |
| 255 * (l + a * (A * cosh + B * sinh)), | |
| 255 * (l + a * (C * cosh + D * sinh)), | |
| 255 * (l + a * (E * cosh)), | |
| this.opacity | |
| ); | |
| } | |
| })); | |
| function basis(t1, v0, v1, v2, v3) { | |
| var t2 = t1 * t1, t3 = t2 * t1; | |
| return ((1 - 3 * t1 + 3 * t2 - t3) * v0 | |
| + (4 - 6 * t2 + 3 * t3) * v1 | |
| + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2 | |
| + t3 * v3) / 6; | |
| } | |
| var constant$1 = function(x) { | |
| return function() { | |
| return x; | |
| }; | |
| }; | |
| function linear(a, d) { | |
| return function(t) { | |
| return a + t * d; | |
| }; | |
| } | |
| function exponential(a, b, y) { | |
| return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) { | |
| return Math.pow(a + t * b, y); | |
| }; | |
| } | |
| function hue(a, b) { | |
| var d = b - a; | |
| return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant$1(isNaN(a) ? b : a); | |
| } | |
| function gamma(y) { | |
| return (y = +y) === 1 ? nogamma : function(a, b) { | |
| return b - a ? exponential(a, b, y) : constant$1(isNaN(a) ? b : a); | |
| }; | |
| } | |
| function nogamma(a, b) { | |
| var d = b - a; | |
| return d ? linear(a, d) : constant$1(isNaN(a) ? b : a); | |
| } | |
| var interpolateRgb = ((function rgbGamma(y) { | |
| var color$$1 = gamma(y); | |
| function rgb$$1(start, end) { | |
| var r = color$$1((start = rgb(start)).r, (end = rgb(end)).r), | |
| g = color$$1(start.g, end.g), | |
| b = color$$1(start.b, end.b), | |
| opacity = nogamma(start.opacity, end.opacity); | |
| return function(t) { | |
| start.r = r(t); | |
| start.g = g(t); | |
| start.b = b(t); | |
| start.opacity = opacity(t); | |
| return start + ""; | |
| }; | |
| } | |
| rgb$$1.gamma = rgbGamma; | |
| return rgb$$1; | |
| }))(1); | |
| var array = function(a, b) { | |
| var nb = b ? b.length : 0, | |
| na = a ? Math.min(nb, a.length) : 0, | |
| x = new Array(nb), | |
| c = new Array(nb), | |
| i; | |
| for (i = 0; i < na; ++i) x[i] = interpolateValue(a[i], b[i]); | |
| for (; i < nb; ++i) c[i] = b[i]; | |
| return function(t) { | |
| for (i = 0; i < na; ++i) c[i] = x[i](t); | |
| return c; | |
| }; | |
| }; | |
| var date = function(a, b) { | |
| var d = new Date; | |
| return a = +a, b -= a, function(t) { | |
| return d.setTime(a + b * t), d; | |
| }; | |
| }; | |
| var reinterpolate = function(a, b) { | |
| return a = +a, b -= a, function(t) { | |
| return a + b * t; | |
| }; | |
| }; | |
| var object = function(a, b) { | |
| var i = {}, | |
| c = {}, | |
| k; | |
| if (a === null || typeof a !== "object") a = {}; | |
| if (b === null || typeof b !== "object") b = {}; | |
| for (k in b) { | |
| if (k in a) { | |
| i[k] = interpolateValue(a[k], b[k]); | |
| } else { | |
| c[k] = b[k]; | |
| } | |
| } | |
| return function(t) { | |
| for (k in i) c[k] = i[k](t); | |
| return c; | |
| }; | |
| }; | |
| var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g; | |
| var reB = new RegExp(reA.source, "g"); | |
| function zero(b) { | |
| return function() { | |
| return b; | |
| }; | |
| } | |
| function one(b) { | |
| return function(t) { | |
| return b(t) + ""; | |
| }; | |
| } | |
| var interpolateString = function(a, b) { | |
| var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b | |
| am, // current match in a | |
| bm, // current match in b | |
| bs, // string preceding current number in b, if any | |
| i = -1, // index in s | |
| s = [], // string constants and placeholders | |
| q = []; // number interpolators | |
| // Coerce inputs to strings. | |
| a = a + "", b = b + ""; | |
| // Interpolate pairs of numbers in a & b. | |
| while ((am = reA.exec(a)) | |
| && (bm = reB.exec(b))) { | |
| if ((bs = bm.index) > bi) { // a string precedes the next number in b | |
| bs = b.slice(bi, bs); | |
| if (s[i]) s[i] += bs; // coalesce with previous string | |
| else s[++i] = bs; | |
| } | |
| if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match | |
| if (s[i]) s[i] += bm; // coalesce with previous string | |
| else s[++i] = bm; | |
| } else { // interpolate non-matching numbers | |
| s[++i] = null; | |
| q.push({i: i, x: reinterpolate(am, bm)}); | |
| } | |
| bi = reB.lastIndex; | |
| } | |
| // Add remains of b. | |
| if (bi < b.length) { | |
| bs = b.slice(bi); | |
| if (s[i]) s[i] += bs; // coalesce with previous string | |
| else s[++i] = bs; | |
| } | |
| // Special optimization for only a single match. | |
| // Otherwise, interpolate each of the numbers and rejoin the string. | |
| return s.length < 2 ? (q[0] | |
| ? one(q[0].x) | |
| : zero(b)) | |
| : (b = q.length, function(t) { | |
| for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t); | |
| return s.join(""); | |
| }); | |
| }; | |
| var interpolateValue = function(a, b) { | |
| var t = typeof b, c; | |
| return b == null || t === "boolean" ? constant$1(b) | |
| : (t === "number" ? reinterpolate | |
| : t === "string" ? ((c = color(b)) ? (b = c, interpolateRgb) : interpolateString) | |
| : b instanceof color ? interpolateRgb | |
| : b instanceof Date ? date | |
| : Array.isArray(b) ? array | |
| : isNaN(b) ? object | |
| : reinterpolate)(a, b); | |
| }; | |
| var interpolateRound = function(a, b) { | |
| return a = +a, b -= a, function(t) { | |
| return Math.round(a + b * t); | |
| }; | |
| }; | |
| var degrees = 180 / Math.PI; | |
| var identity$1 = { | |
| translateX: 0, | |
| translateY: 0, | |
| rotate: 0, | |
| skewX: 0, | |
| scaleX: 1, | |
| scaleY: 1 | |
| }; | |
| var decompose = function(a, b, c, d, e, f) { | |
| var scaleX, scaleY, skewX; | |
| if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX; | |
| if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX; | |
| if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY; | |
| if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX; | |
| return { | |
| translateX: e, | |
| translateY: f, | |
| rotate: Math.atan2(b, a) * degrees, | |
| skewX: Math.atan(skewX) * degrees, | |
| scaleX: scaleX, | |
| scaleY: scaleY | |
| }; | |
| }; | |
| var cssNode; | |
| var cssRoot; | |
| var cssView; | |
| var svgNode; | |
| function parseCss(value) { | |
| if (value === "none") return identity$1; | |
| if (!cssNode) cssNode = document.createElement("DIV"), cssRoot = document.documentElement, cssView = document.defaultView; | |
| cssNode.style.transform = value; | |
| value = cssView.getComputedStyle(cssRoot.appendChild(cssNode), null).getPropertyValue("transform"); | |
| cssRoot.removeChild(cssNode); | |
| value = value.slice(7, -1).split(","); | |
| return decompose(+value[0], +value[1], +value[2], +value[3], +value[4], +value[5]); | |
| } | |
| function parseSvg(value) { | |
| if (value == null) return identity$1; | |
| if (!svgNode) svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g"); | |
| svgNode.setAttribute("transform", value); | |
| if (!(value = svgNode.transform.baseVal.consolidate())) return identity$1; | |
| value = value.matrix; | |
| return decompose(value.a, value.b, value.c, value.d, value.e, value.f); | |
| } | |
| function interpolateTransform(parse, pxComma, pxParen, degParen) { | |
| function pop(s) { | |
| return s.length ? s.pop() + " " : ""; | |
| } | |
| function translate(xa, ya, xb, yb, s, q) { | |
| if (xa !== xb || ya !== yb) { | |
| var i = s.push("translate(", null, pxComma, null, pxParen); | |
| q.push({i: i - 4, x: reinterpolate(xa, xb)}, {i: i - 2, x: reinterpolate(ya, yb)}); | |
| } else if (xb || yb) { | |
| s.push("translate(" + xb + pxComma + yb + pxParen); | |
| } | |
| } | |
| function rotate(a, b, s, q) { | |
| if (a !== b) { | |
| if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path | |
| q.push({i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: reinterpolate(a, b)}); | |
| } else if (b) { | |
| s.push(pop(s) + "rotate(" + b + degParen); | |
| } | |
| } | |
| function skewX(a, b, s, q) { | |
| if (a !== b) { | |
| q.push({i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: reinterpolate(a, b)}); | |
| } else if (b) { | |
| s.push(pop(s) + "skewX(" + b + degParen); | |
| } | |
| } | |
| function scale(xa, ya, xb, yb, s, q) { | |
| if (xa !== xb || ya !== yb) { | |
| var i = s.push(pop(s) + "scale(", null, ",", null, ")"); | |
| q.push({i: i - 4, x: reinterpolate(xa, xb)}, {i: i - 2, x: reinterpolate(ya, yb)}); | |
| } else if (xb !== 1 || yb !== 1) { | |
| s.push(pop(s) + "scale(" + xb + "," + yb + ")"); | |
| } | |
| } | |
| return function(a, b) { | |
| var s = [], // string constants and placeholders | |
| q = []; // number interpolators | |
| a = parse(a), b = parse(b); | |
| translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q); | |
| rotate(a.rotate, b.rotate, s, q); | |
| skewX(a.skewX, b.skewX, s, q); | |
| scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q); | |
| a = b = null; // gc | |
| return function(t) { | |
| var i = -1, n = q.length, o; | |
| while (++i < n) s[(o = q[i]).i] = o.x(t); | |
| return s.join(""); | |
| }; | |
| }; | |
| } | |
| var interpolateTransformCss = interpolateTransform(parseCss, "px, ", "px)", "deg)"); | |
| var interpolateTransformSvg = interpolateTransform(parseSvg, ", ", ")", ")"); | |
| // p0 = [ux0, uy0, w0] | |
| // p1 = [ux1, uy1, w1] | |
| function cubehelix$1(hue$$1) { | |
| return (function cubehelixGamma(y) { | |
| y = +y; | |
| function cubehelix$$1(start, end) { | |
| var h = hue$$1((start = cubehelix(start)).h, (end = cubehelix(end)).h), | |
| s = nogamma(start.s, end.s), | |
| l = nogamma(start.l, end.l), | |
| opacity = nogamma(start.opacity, end.opacity); | |
| return function(t) { | |
| start.h = h(t); | |
| start.s = s(t); | |
| start.l = l(Math.pow(t, y)); | |
| start.opacity = opacity(t); | |
| return start + ""; | |
| }; | |
| } | |
| cubehelix$$1.gamma = cubehelixGamma; | |
| return cubehelix$$1; | |
| })(1); | |
| } | |
| cubehelix$1(hue); | |
| var cubehelixLong = cubehelix$1(nogamma); | |
| function tweenRemove(id, name) { | |
| var tween0, tween1; | |
| return function() { | |
| var schedule = set(this, id), | |
| tween = schedule.tween; | |
| // If this node shared tween with the previous node, | |
| // just assign the updated shared tween and we’re done! | |
| // Otherwise, copy-on-write. | |
| if (tween !== tween0) { | |
| tween1 = tween0 = tween; | |
| for (var i = 0, n = tween1.length; i < n; ++i) { | |
| if (tween1[i].name === name) { | |
| tween1 = tween1.slice(); | |
| tween1.splice(i, 1); | |
| break; | |
| } | |
| } | |
| } | |
| schedule.tween = tween1; | |
| }; | |
| } | |
| function tweenFunction(id, name, value) { | |
| var tween0, tween1; | |
| if (typeof value !== "function") throw new Error; | |
| return function() { | |
| var schedule = set(this, id), | |
| tween = schedule.tween; | |
| // If this node shared tween with the previous node, | |
| // just assign the updated shared tween and we’re done! | |
| // Otherwise, copy-on-write. | |
| if (tween !== tween0) { | |
| tween1 = (tween0 = tween).slice(); | |
| for (var t = {name: name, value: value}, i = 0, n = tween1.length; i < n; ++i) { | |
| if (tween1[i].name === name) { | |
| tween1[i] = t; | |
| break; | |
| } | |
| } | |
| if (i === n) tween1.push(t); | |
| } | |
| schedule.tween = tween1; | |
| }; | |
| } | |
| var transition_tween = function(name, value) { | |
| var id = this._id; | |
| name += ""; | |
| if (arguments.length < 2) { | |
| var tween = get(this.node(), id).tween; | |
| for (var i = 0, n = tween.length, t; i < n; ++i) { | |
| if ((t = tween[i]).name === name) { | |
| return t.value; | |
| } | |
| } | |
| return null; | |
| } | |
| return this.each((value == null ? tweenRemove : tweenFunction)(id, name, value)); | |
| }; | |
| function tweenValue(transition, name, value) { | |
| var id = transition._id; | |
| transition.each(function() { | |
| var schedule = set(this, id); | |
| (schedule.value || (schedule.value = {}))[name] = value.apply(this, arguments); | |
| }); | |
| return function(node) { | |
| return get(node, id).value[name]; | |
| }; | |
| } | |
| var interpolate$$1 = function(a, b) { | |
| var c; | |
| return (typeof b === "number" ? reinterpolate | |
| : b instanceof color ? interpolateRgb | |
| : (c = color(b)) ? (b = c, interpolateRgb) | |
| : interpolateString)(a, b); | |
| }; | |
| function attrRemove$1(name) { | |
| return function() { | |
| this.removeAttribute(name); | |
| }; | |
| } | |
| function attrRemoveNS$1(fullname) { | |
| return function() { | |
| this.removeAttributeNS(fullname.space, fullname.local); | |
| }; | |
| } | |
| function attrConstant$1(name, interpolate$$1, value1) { | |
| var value00, | |
| interpolate0; | |
| return function() { | |
| var value0 = this.getAttribute(name); | |
| return value0 === value1 ? null | |
| : value0 === value00 ? interpolate0 | |
| : interpolate0 = interpolate$$1(value00 = value0, value1); | |
| }; | |
| } | |
| function attrConstantNS$1(fullname, interpolate$$1, value1) { | |
| var value00, | |
| interpolate0; | |
| return function() { | |
| var value0 = this.getAttributeNS(fullname.space, fullname.local); | |
| return value0 === value1 ? null | |
| : value0 === value00 ? interpolate0 | |
| : interpolate0 = interpolate$$1(value00 = value0, value1); | |
| }; | |
| } | |
| function attrFunction$1(name, interpolate$$1, value) { | |
| var value00, | |
| value10, | |
| interpolate0; | |
| return function() { | |
| var value0, value1 = value(this); | |
| if (value1 == null) return void this.removeAttribute(name); | |
| value0 = this.getAttribute(name); | |
| return value0 === value1 ? null | |
| : value0 === value00 && value1 === value10 ? interpolate0 | |
| : interpolate0 = interpolate$$1(value00 = value0, value10 = value1); | |
| }; | |
| } | |
| function attrFunctionNS$1(fullname, interpolate$$1, value) { | |
| var value00, | |
| value10, | |
| interpolate0; | |
| return function() { | |
| var value0, value1 = value(this); | |
| if (value1 == null) return void this.removeAttributeNS(fullname.space, fullname.local); | |
| value0 = this.getAttributeNS(fullname.space, fullname.local); | |
| return value0 === value1 ? null | |
| : value0 === value00 && value1 === value10 ? interpolate0 | |
| : interpolate0 = interpolate$$1(value00 = value0, value10 = value1); | |
| }; | |
| } | |
| var transition_attr = function(name, value) { | |
| var fullname = namespace(name), i = fullname === "transform" ? interpolateTransformSvg : interpolate$$1; | |
| return this.attrTween(name, typeof value === "function" | |
| ? (fullname.local ? attrFunctionNS$1 : attrFunction$1)(fullname, i, tweenValue(this, "attr." + name, value)) | |
| : value == null ? (fullname.local ? attrRemoveNS$1 : attrRemove$1)(fullname) | |
| : (fullname.local ? attrConstantNS$1 : attrConstant$1)(fullname, i, value + "")); | |
| }; | |
| function attrTweenNS(fullname, value) { | |
| function tween() { | |
| var node = this, i = value.apply(node, arguments); | |
| return i && function(t) { | |
| node.setAttributeNS(fullname.space, fullname.local, i(t)); | |
| }; | |
| } | |
| tween._value = value; | |
| return tween; | |
| } | |
| function attrTween(name, value) { | |
| function tween() { | |
| var node = this, i = value.apply(node, arguments); | |
| return i && function(t) { | |
| node.setAttribute(name, i(t)); | |
| }; | |
| } | |
| tween._value = value; | |
| return tween; | |
| } | |
| var transition_attrTween = function(name, value) { | |
| var key = "attr." + name; | |
| if (arguments.length < 2) return (key = this.tween(key)) && key._value; | |
| if (value == null) return this.tween(key, null); | |
| if (typeof value !== "function") throw new Error; | |
| var fullname = namespace(name); | |
| return this.tween(key, (fullname.local ? attrTweenNS : attrTween)(fullname, value)); | |
| }; | |
| function delayFunction(id, value) { | |
| return function() { | |
| init(this, id).delay = +value.apply(this, arguments); | |
| }; | |
| } | |
| function delayConstant(id, value) { | |
| return value = +value, function() { | |
| init(this, id).delay = value; | |
| }; | |
| } | |
| var transition_delay = function(value) { | |
| var id = this._id; | |
| return arguments.length | |
| ? this.each((typeof value === "function" | |
| ? delayFunction | |
| : delayConstant)(id, value)) | |
| : get(this.node(), id).delay; | |
| }; | |
| function durationFunction(id, value) { | |
| return function() { | |
| set(this, id).duration = +value.apply(this, arguments); | |
| }; | |
| } | |
| function durationConstant(id, value) { | |
| return value = +value, function() { | |
| set(this, id).duration = value; | |
| }; | |
| } | |
| var transition_duration = function(value) { | |
| var id = this._id; | |
| return arguments.length | |
| ? this.each((typeof value === "function" | |
| ? durationFunction | |
| : durationConstant)(id, value)) | |
| : get(this.node(), id).duration; | |
| }; | |
| function easeConstant(id, value) { | |
| if (typeof value !== "function") throw new Error; | |
| return function() { | |
| set(this, id).ease = value; | |
| }; | |
| } | |
| var transition_ease = function(value) { | |
| var id = this._id; | |
| return arguments.length | |
| ? this.each(easeConstant(id, value)) | |
| : get(this.node(), id).ease; | |
| }; | |
| var transition_filter = function(match) { | |
| if (typeof match !== "function") match = matcher$1(match); | |
| for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) { | |
| if ((node = group[i]) && match.call(node, node.__data__, i, group)) { | |
| subgroup.push(node); | |
| } | |
| } | |
| } | |
| return new Transition(subgroups, this._parents, this._name, this._id); | |
| }; | |
| var transition_merge = function(transition) { | |
| if (transition._id !== this._id) throw new Error; | |
| for (var groups0 = this._groups, groups1 = transition._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) { | |
| for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) { | |
| if (node = group0[i] || group1[i]) { | |
| merge[i] = node; | |
| } | |
| } | |
| } | |
| for (; j < m0; ++j) { | |
| merges[j] = groups0[j]; | |
| } | |
| return new Transition(merges, this._parents, this._name, this._id); | |
| }; | |
| function start(name) { | |
| return (name + "").trim().split(/^|\s+/).every(function(t) { | |
| var i = t.indexOf("."); | |
| if (i >= 0) t = t.slice(0, i); | |
| return !t || t === "start"; | |
| }); | |
| } | |
| function onFunction(id, name, listener) { | |
| var on0, on1, sit = start(name) ? init : set; | |
| return function() { | |
| var schedule = sit(this, id), | |
| on = schedule.on; | |
| // If this node shared a dispatch with the previous node, | |
| // just assign the updated shared dispatch and we’re done! | |
| // Otherwise, copy-on-write. | |
| if (on !== on0) (on1 = (on0 = on).copy()).on(name, listener); | |
| schedule.on = on1; | |
| }; | |
| } | |
| var transition_on = function(name, listener) { | |
| var id = this._id; | |
| return arguments.length < 2 | |
| ? get(this.node(), id).on.on(name) | |
| : this.each(onFunction(id, name, listener)); | |
| }; | |
| function removeFunction(id) { | |
| return function() { | |
| var parent = this.parentNode; | |
| for (var i in this.__transition) if (+i !== id) return; | |
| if (parent) parent.removeChild(this); | |
| }; | |
| } | |
| var transition_remove = function() { | |
| return this.on("end.remove", removeFunction(this._id)); | |
| }; | |
| var transition_select = function(select$$1) { | |
| var name = this._name, | |
| id = this._id; | |
| if (typeof select$$1 !== "function") select$$1 = selector(select$$1); | |
| for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) { | |
| if ((node = group[i]) && (subnode = select$$1.call(node, node.__data__, i, group))) { | |
| if ("__data__" in node) subnode.__data__ = node.__data__; | |
| subgroup[i] = subnode; | |
| schedule(subgroup[i], name, id, i, subgroup, get(node, id)); | |
| } | |
| } | |
| } | |
| return new Transition(subgroups, this._parents, name, id); | |
| }; | |
| var transition_selectAll = function(select$$1) { | |
| var name = this._name, | |
| id = this._id; | |
| if (typeof select$$1 !== "function") select$$1 = selectorAll(select$$1); | |
| for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { | |
| if (node = group[i]) { | |
| for (var children = select$$1.call(node, node.__data__, i, group), child, inherit = get(node, id), k = 0, l = children.length; k < l; ++k) { | |
| if (child = children[k]) { | |
| schedule(child, name, id, k, children, inherit); | |
| } | |
| } | |
| subgroups.push(children); | |
| parents.push(node); | |
| } | |
| } | |
| } | |
| return new Transition(subgroups, parents, name, id); | |
| }; | |
| var Selection$1 = selection.prototype.constructor; | |
| var transition_selection = function() { | |
| return new Selection$1(this._groups, this._parents); | |
| }; | |
| function styleRemove$1(name, interpolate$$2) { | |
| var value00, | |
| value10, | |
| interpolate0; | |
| return function() { | |
| var style = window$1(this).getComputedStyle(this, null), | |
| value0 = style.getPropertyValue(name), | |
| value1 = (this.style.removeProperty(name), style.getPropertyValue(name)); | |
| return value0 === value1 ? null | |
| : value0 === value00 && value1 === value10 ? interpolate0 | |
| : interpolate0 = interpolate$$2(value00 = value0, value10 = value1); | |
| }; | |
| } | |
| function styleRemoveEnd(name) { | |
| return function() { | |
| this.style.removeProperty(name); | |
| }; | |
| } | |
| function styleConstant$1(name, interpolate$$2, value1) { | |
| var value00, | |
| interpolate0; | |
| return function() { | |
| var value0 = window$1(this).getComputedStyle(this, null).getPropertyValue(name); | |
| return value0 === value1 ? null | |
| : value0 === value00 ? interpolate0 | |
| : interpolate0 = interpolate$$2(value00 = value0, value1); | |
| }; | |
| } | |
| function styleFunction$1(name, interpolate$$2, value) { | |
| var value00, | |
| value10, | |
| interpolate0; | |
| return function() { | |
| var style = window$1(this).getComputedStyle(this, null), | |
| value0 = style.getPropertyValue(name), | |
| value1 = value(this); | |
| if (value1 == null) value1 = (this.style.removeProperty(name), style.getPropertyValue(name)); | |
| return value0 === value1 ? null | |
| : value0 === value00 && value1 === value10 ? interpolate0 | |
| : interpolate0 = interpolate$$2(value00 = value0, value10 = value1); | |
| }; | |
| } | |
| var transition_style = function(name, value, priority) { | |
| var i = (name += "") === "transform" ? interpolateTransformCss : interpolate$$1; | |
| return value == null ? this | |
| .styleTween(name, styleRemove$1(name, i)) | |
| .on("end.style." + name, styleRemoveEnd(name)) | |
| : this.styleTween(name, typeof value === "function" | |
| ? styleFunction$1(name, i, tweenValue(this, "style." + name, value)) | |
| : styleConstant$1(name, i, value + ""), priority); | |
| }; | |
| function styleTween(name, value, priority) { | |
| function tween() { | |
| var node = this, i = value.apply(node, arguments); | |
| return i && function(t) { | |
| node.style.setProperty(name, i(t), priority); | |
| }; | |
| } | |
| tween._value = value; | |
| return tween; | |
| } | |
| var transition_styleTween = function(name, value, priority) { | |
| var key = "style." + (name += ""); | |
| if (arguments.length < 2) return (key = this.tween(key)) && key._value; | |
| if (value == null) return this.tween(key, null); | |
| if (typeof value !== "function") throw new Error; | |
| return this.tween(key, styleTween(name, value, priority == null ? "" : priority)); | |
| }; | |
| function textConstant$1(value) { | |
| return function() { | |
| this.textContent = value; | |
| }; | |
| } | |
| function textFunction$1(value) { | |
| return function() { | |
| var value1 = value(this); | |
| this.textContent = value1 == null ? "" : value1; | |
| }; | |
| } | |
| var transition_text = function(value) { | |
| return this.tween("text", typeof value === "function" | |
| ? textFunction$1(tweenValue(this, "text", value)) | |
| : textConstant$1(value == null ? "" : value + "")); | |
| }; | |
| var transition_transition = function() { | |
| var name = this._name, | |
| id0 = this._id, | |
| id1 = newId(); | |
| for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { | |
| if (node = group[i]) { | |
| var inherit = get(node, id0); | |
| schedule(node, name, id1, i, group, { | |
| time: inherit.time + inherit.delay + inherit.duration, | |
| delay: 0, | |
| duration: inherit.duration, | |
| ease: inherit.ease | |
| }); | |
| } | |
| } | |
| } | |
| return new Transition(groups, this._parents, name, id1); | |
| }; | |
| var id = 0; | |
| function Transition(groups, parents, name, id) { | |
| this._groups = groups; | |
| this._parents = parents; | |
| this._name = name; | |
| this._id = id; | |
| } | |
| function transition(name) { | |
| return selection().transition(name); | |
| } | |
| function newId() { | |
| return ++id; | |
| } | |
| var selection_prototype = selection.prototype; | |
| Transition.prototype = transition.prototype = { | |
| constructor: Transition, | |
| select: transition_select, | |
| selectAll: transition_selectAll, | |
| filter: transition_filter, | |
| merge: transition_merge, | |
| selection: transition_selection, | |
| transition: transition_transition, | |
| call: selection_prototype.call, | |
| nodes: selection_prototype.nodes, | |
| node: selection_prototype.node, | |
| size: selection_prototype.size, | |
| empty: selection_prototype.empty, | |
| each: selection_prototype.each, | |
| on: transition_on, | |
| attr: transition_attr, | |
| attrTween: transition_attrTween, | |
| style: transition_style, | |
| styleTween: transition_styleTween, | |
| text: transition_text, | |
| remove: transition_remove, | |
| tween: transition_tween, | |
| delay: transition_delay, | |
| duration: transition_duration, | |
| ease: transition_ease | |
| }; | |
| function cubicInOut(t) { | |
| return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2; | |
| } | |
| var exponent$1 = 3; | |
| var polyIn = (function custom(e) { | |
| e = +e; | |
| function polyIn(t) { | |
| return Math.pow(t, e); | |
| } | |
| polyIn.exponent = custom; | |
| return polyIn; | |
| })(exponent$1); | |
| var polyOut = (function custom(e) { | |
| e = +e; | |
| function polyOut(t) { | |
| return 1 - Math.pow(1 - t, e); | |
| } | |
| polyOut.exponent = custom; | |
| return polyOut; | |
| })(exponent$1); | |
| var polyInOut = (function custom(e) { | |
| e = +e; | |
| function polyInOut(t) { | |
| return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2; | |
| } | |
| polyInOut.exponent = custom; | |
| return polyInOut; | |
| })(exponent$1); | |
| var overshoot = 1.70158; | |
| var backIn = (function custom(s) { | |
| s = +s; | |
| function backIn(t) { | |
| return t * t * ((s + 1) * t - s); | |
| } | |
| backIn.overshoot = custom; | |
| return backIn; | |
| })(overshoot); | |
| var backOut = (function custom(s) { | |
| s = +s; | |
| function backOut(t) { | |
| return --t * t * ((s + 1) * t + s) + 1; | |
| } | |
| backOut.overshoot = custom; | |
| return backOut; | |
| })(overshoot); | |
| var backInOut = (function custom(s) { | |
| s = +s; | |
| function backInOut(t) { | |
| return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2; | |
| } | |
| backInOut.overshoot = custom; | |
| return backInOut; | |
| })(overshoot); | |
| var tau = 2 * Math.PI; | |
| var amplitude = 1; | |
| var period = 0.3; | |
| var elasticIn = (function custom(a, p) { | |
| var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); | |
| function elasticIn(t) { | |
| return a * Math.pow(2, 10 * --t) * Math.sin((s - t) / p); | |
| } | |
| elasticIn.amplitude = function(a) { return custom(a, p * tau); }; | |
| elasticIn.period = function(p) { return custom(a, p); }; | |
| return elasticIn; | |
| })(amplitude, period); | |
| var elasticOut = (function custom(a, p) { | |
| var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); | |
| function elasticOut(t) { | |
| return 1 - a * Math.pow(2, -10 * (t = +t)) * Math.sin((t + s) / p); | |
| } | |
| elasticOut.amplitude = function(a) { return custom(a, p * tau); }; | |
| elasticOut.period = function(p) { return custom(a, p); }; | |
| return elasticOut; | |
| })(amplitude, period); | |
| var elasticInOut = (function custom(a, p) { | |
| var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); | |
| function elasticInOut(t) { | |
| return ((t = t * 2 - 1) < 0 | |
| ? a * Math.pow(2, 10 * t) * Math.sin((s - t) / p) | |
| : 2 - a * Math.pow(2, -10 * t) * Math.sin((s + t) / p)) / 2; | |
| } | |
| elasticInOut.amplitude = function(a) { return custom(a, p * tau); }; | |
| elasticInOut.period = function(p) { return custom(a, p); }; | |
| return elasticInOut; | |
| })(amplitude, period); | |
| var defaultTiming = { | |
| time: null, // Set on use. | |
| delay: 0, | |
| duration: 250, | |
| ease: cubicInOut | |
| }; | |
| function inherit(node, id) { | |
| var timing; | |
| while (!(timing = node.__transition) || !(timing = timing[id])) { | |
| if (!(node = node.parentNode)) { | |
| return defaultTiming.time = now(), defaultTiming; | |
| } | |
| } | |
| return timing; | |
| } | |
| var selection_transition = function(name) { | |
| var id, | |
| timing; | |
| if (name instanceof Transition) { | |
| id = name._id, name = name._name; | |
| } else { | |
| id = newId(), (timing = defaultTiming).time = now(), name = name == null ? null : name + ""; | |
| } | |
| for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { | |
| if (node = group[i]) { | |
| schedule(node, name, id, i, group, timing || inherit(node, id)); | |
| } | |
| } | |
| } | |
| return new Transition(groups, this._parents, name, id); | |
| }; | |
| selection.prototype.interrupt = selection_interrupt; | |
| selection.prototype.transition = selection_transition; | |
| function attrsFunction(selection$$1, map) { | |
| return selection$$1.each(function() { | |
| var x = map.apply(this, arguments), s = select(this); | |
| for (var name in x) s.attr(name, x[name]); | |
| }); | |
| } | |
| function attrsObject(selection$$1, map) { | |
| for (var name in map) selection$$1.attr(name, map[name]); | |
| return selection$$1; | |
| } | |
| var selection_attrs = function(map) { | |
| return (typeof map === "function" ? attrsFunction : attrsObject)(this, map); | |
| }; | |
| function stylesFunction(selection$$1, map, priority) { | |
| return selection$$1.each(function() { | |
| var x = map.apply(this, arguments), s = select(this); | |
| for (var name in x) s.style(name, x[name], priority); | |
| }); | |
| } | |
| function stylesObject(selection$$1, map, priority) { | |
| for (var name in map) selection$$1.style(name, map[name], priority); | |
| return selection$$1; | |
| } | |
| var selection_styles = function(map, priority) { | |
| return (typeof map === "function" ? stylesFunction : stylesObject)(this, map, priority == null ? "" : priority); | |
| }; | |
| function propertiesFunction(selection$$1, map) { | |
| return selection$$1.each(function() { | |
| var x = map.apply(this, arguments), s = select(this); | |
| for (var name in x) s.property(name, x[name]); | |
| }); | |
| } | |
| function propertiesObject(selection$$1, map) { | |
| for (var name in map) selection$$1.property(name, map[name]); | |
| return selection$$1; | |
| } | |
| var selection_properties = function(map) { | |
| return (typeof map === "function" ? propertiesFunction : propertiesObject)(this, map); | |
| }; | |
| selection.prototype.attrs = selection_attrs; | |
| selection.prototype.styles = selection_styles; | |
| selection.prototype.properties = selection_properties; | |
| // <script src="https://gitcdn.xyz/repo/cool-Blue/d3-lib/master/elapsedTime/elapsedTime/elapsed%20time%201.0.js"></script> | |
| (function() { | |
| //polly-fill for safari | |
| if("performance" in window == false) { | |
| window.performance = {}; | |
| } | |
| Date.now = (Date.now || function() { // thanks IE8 | |
| return new Date().getTime(); | |
| }); | |
| if("now" in window.performance == false) { | |
| let nowOffset = Date.now(); | |
| if(performance.timing && performance.timing.navigationStart) { | |
| nowOffset = performance.timing.navigationStart; | |
| } | |
| window.performance.now = function now() { | |
| return Date.now() - nowOffset; | |
| }; | |
| } | |
| })(); | |
| function OutputDiv() { | |
| //constructor | |
| function _OutputDiv(on, style, before) { | |
| //private instance state | |
| let _sel = select(on), id = ~~(Math.random() * 1000), | |
| _style = merge({ | |
| margin: '10px 10px 10px 0', | |
| padding: '3px 3px 3px 3px', | |
| 'white-space': 'pre' | |
| }, style || {}), | |
| _message = function (value) { | |
| return value | |
| }; | |
| if (before) { | |
| _sel = _sel.insert('div', before); | |
| } else { | |
| _sel = _sel.append('div'); | |
| } | |
| _sel = _sel.styles(_style) | |
| .attr("id", "ouputDiv_" + id) | |
| .attr("class", "ouputDiv"); | |
| //public instance state | |
| this.selection = _sel; | |
| this.update = function () { | |
| var context = this; | |
| var i = arguments.length; | |
| var args = []; | |
| while (i--) args[i] = arguments[i]; | |
| Promise.resolve(_message.apply(context, args)) | |
| .then(m => | |
| window.requestAnimationFrame(() => context.selection.text(m)) | |
| ).catch(e => {throw e}); | |
| return this | |
| }; | |
| this.message = function (f) { | |
| _message = f; | |
| return this | |
| }; | |
| function merge(source, target) { | |
| for (let p in source) if (target && !target.hasOwnProperty(p)) target[p] = source[p]; | |
| return target; | |
| } | |
| } | |
| _OutputDiv.prototype.window = function(aveWindow){ | |
| this.aveLap = _AveLap.call(this, aveWindow || 1000); | |
| return this; | |
| }; | |
| _OutputDiv.prototype.start = function () { | |
| this.startTime = window.performance.now(); | |
| this.lapTime = this.startTime; | |
| this.ticks = 0; | |
| this.update(0); | |
| this.running = true; | |
| return this | |
| }; | |
| _OutputDiv.prototype.lap = function () { | |
| if (this.running) { | |
| this.lastLap = (-this.lapTime + (this.lapTime = window.performance.now()) ) / 1000; | |
| } | |
| return this | |
| }; | |
| _OutputDiv.prototype.tick = function () { | |
| return format(" >8,.3f")((window.performance.now() - this.startTime) / 1000) | |
| }; | |
| _OutputDiv.prototype.mark = function (f) { | |
| if (this.running) { | |
| let _tMark = (window.performance.now() - this.startTime); | |
| this.ticks += 1; | |
| if (!f) { | |
| this.update(_tMark / 1000); | |
| } else if (f.call) { | |
| f.call(this, _tMark); | |
| } else this.update(f); | |
| } else { | |
| let _tMark = 0; | |
| //this.start() | |
| } | |
| return this | |
| }; | |
| _OutputDiv.prototype.message = function (value) { | |
| return 'time elapsed : ' + format(",.3f")(value) | |
| + ' sec\t' + format(",d")(this.ticks) | |
| }; | |
| _OutputDiv.prototype.stop = function () { | |
| this.running = false; | |
| return this | |
| }; | |
| _OutputDiv.prototype.stop = function () { | |
| this.running = false; | |
| return this | |
| }; | |
| _OutputDiv.prototype.timestamp = function (caller, message) { | |
| if (this.consoleOn) { | |
| let _caller = (caller && caller.callee) ? /function\s+(\w*)\(/.exec(caller.callee)[1] : caller; | |
| this.mark(function (t) { | |
| console.log(format(" >8,.6f")(t / 1000) + (_caller ? "\t" + _caller + (message ? "\t" | |
| + message : "") : "")); | |
| }); | |
| } | |
| }; | |
| //create and initialise new instance | |
| return function (on, style, before) { | |
| return new _OutputDiv(on, style, before) | |
| }; | |
| function _AveLap(aveWindow) { | |
| var _i = 0, _aveP = 0, _history = [], _aveWindow = aveWindow || 1000; | |
| function f(this_lap) { | |
| var T = 0, l; | |
| this_lap = this_lap || this.lap().lastLap; | |
| if (!_aveWindow) return _aveP = _i++ ? (_aveP + this_lap / (_i - 1)) * (_i - 1) | |
| / _i : this.lap().lastLap; | |
| if (this_lap) _history.push(this_lap); | |
| for (; (l = _history.length) > _aveWindow;) { | |
| _history.shift(); | |
| } | |
| for (var i = 0; i < l; i++) | |
| T = T + _history[i]; | |
| return l ? T / l : 0; | |
| } | |
| Object.defineProperties(f, { | |
| history: { | |
| get: function () { | |
| return _history | |
| } | |
| }, | |
| aveWindow: { | |
| get: function () { | |
| return _aveWindow | |
| }, set: function (w) { | |
| _aveWindow = w; | |
| } | |
| } | |
| }); | |
| return f | |
| } | |
| } | |
| function ElapsedTime(on, style, before) { | |
| let elapsedTime = OutputDiv()(on, style, before).update("loading..."); | |
| elapsedTime.consoleOn = false; | |
| return elapsedTime; | |
| } | |
| var ascending$1 = function(a, b) { | |
| return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; | |
| }; | |
| var bisector = function(compare) { | |
| if (compare.length === 1) compare = ascendingComparator(compare); | |
| return { | |
| left: function(a, x, lo, hi) { | |
| if (lo == null) lo = 0; | |
| if (hi == null) hi = a.length; | |
| while (lo < hi) { | |
| var mid = lo + hi >>> 1; | |
| if (compare(a[mid], x) < 0) lo = mid + 1; | |
| else hi = mid; | |
| } | |
| return lo; | |
| }, | |
| right: function(a, x, lo, hi) { | |
| if (lo == null) lo = 0; | |
| if (hi == null) hi = a.length; | |
| while (lo < hi) { | |
| var mid = lo + hi >>> 1; | |
| if (compare(a[mid], x) > 0) hi = mid; | |
| else lo = mid + 1; | |
| } | |
| return lo; | |
| } | |
| }; | |
| }; | |
| function ascendingComparator(f) { | |
| return function(d, x) { | |
| return ascending$1(f(d), x); | |
| }; | |
| } | |
| var ascendingBisect = bisector(ascending$1); | |
| var bisectRight = ascendingBisect.right; | |
| function pair(a, b) { | |
| return [a, b]; | |
| } | |
| var number = function(x) { | |
| return x === null ? NaN : +x; | |
| }; | |
| var extent = function(array, f) { | |
| var i = -1, | |
| n = array.length, | |
| a, | |
| b, | |
| c; | |
| if (f == null) { | |
| while (++i < n) if ((b = array[i]) != null && b >= b) { a = c = b; break; } | |
| while (++i < n) if ((b = array[i]) != null) { | |
| if (a > b) a = b; | |
| if (c < b) c = b; | |
| } | |
| } | |
| else { | |
| while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = c = b; break; } | |
| while (++i < n) if ((b = f(array[i], i, array)) != null) { | |
| if (a > b) a = b; | |
| if (c < b) c = b; | |
| } | |
| } | |
| return [a, c]; | |
| }; | |
| var array$1 = Array.prototype; | |
| var slice = array$1.slice; | |
| var constant$2 = function(x) { | |
| return function() { | |
| return x; | |
| }; | |
| }; | |
| var identity$2 = function(x) { | |
| return x; | |
| }; | |
| var sequence = function(start, stop, step) { | |
| start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step; | |
| var i = -1, | |
| n = Math.max(0, Math.ceil((stop - start) / step)) | 0, | |
| range = new Array(n); | |
| while (++i < n) { | |
| range[i] = start + i * step; | |
| } | |
| return range; | |
| }; | |
| var e10 = Math.sqrt(50); | |
| var e5 = Math.sqrt(10); | |
| var e2 = Math.sqrt(2); | |
| var ticks = function(start, stop, count) { | |
| var step = tickStep(start, stop, count); | |
| return sequence( | |
| Math.ceil(start / step) * step, | |
| Math.floor(stop / step) * step + step / 2, // inclusive | |
| step | |
| ); | |
| }; | |
| function tickStep(start, stop, count) { | |
| var step0 = Math.abs(stop - start) / Math.max(0, count), | |
| step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)), | |
| error = step0 / step1; | |
| if (error >= e10) step1 *= 10; | |
| else if (error >= e5) step1 *= 5; | |
| else if (error >= e2) step1 *= 2; | |
| return stop < start ? -step1 : step1; | |
| } | |
| var sturges = function(values) { | |
| return Math.ceil(Math.log(values.length) / Math.LN2) + 1; | |
| }; | |
| var histogram = function() { | |
| var value = identity$2, | |
| domain = extent, | |
| threshold = sturges; | |
| function histogram(data) { | |
| var i, | |
| n = data.length, | |
| x, | |
| values = new Array(n); | |
| for (i = 0; i < n; ++i) { | |
| values[i] = value(data[i], i, data); | |
| } | |
| var xz = domain(values), | |
| x0 = xz[0], | |
| x1 = xz[1], | |
| tz = threshold(values, x0, x1); | |
| // Convert number of thresholds into uniform thresholds. | |
| if (!Array.isArray(tz)) tz = ticks(x0, x1, tz); | |
| // Remove any thresholds outside the domain. | |
| var m = tz.length; | |
| while (tz[0] <= x0) tz.shift(), --m; | |
| while (tz[m - 1] >= x1) tz.pop(), --m; | |
| var bins = new Array(m + 1), | |
| bin; | |
| // Initialize bins. | |
| for (i = 0; i <= m; ++i) { | |
| bin = bins[i] = []; | |
| bin.x0 = i > 0 ? tz[i - 1] : x0; | |
| bin.x1 = i < m ? tz[i] : x1; | |
| } | |
| // Assign data to bins by value, ignoring any outside the domain. | |
| for (i = 0; i < n; ++i) { | |
| x = values[i]; | |
| if (x0 <= x && x <= x1) { | |
| bins[bisectRight(tz, x, 0, m)].push(data[i]); | |
| } | |
| } | |
| return bins; | |
| } | |
| histogram.value = function(_) { | |
| return arguments.length ? (value = typeof _ === "function" ? _ : constant$2(_), histogram) : value; | |
| }; | |
| histogram.domain = function(_) { | |
| return arguments.length ? (domain = typeof _ === "function" ? _ : constant$2([_[0], _[1]]), histogram) : domain; | |
| }; | |
| histogram.thresholds = function(_) { | |
| return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant$2(slice.call(_)) : constant$2(_), histogram) : threshold; | |
| }; | |
| return histogram; | |
| }; | |
| var threshold = function(array, p, f) { | |
| if (f == null) f = number; | |
| if (!(n = array.length)) return; | |
| if ((p = +p) <= 0 || n < 2) return +f(array[0], 0, array); | |
| if (p >= 1) return +f(array[n - 1], n - 1, array); | |
| var n, | |
| h = (n - 1) * p, | |
| i = Math.floor(h), | |
| a = +f(array[i], i, array), | |
| b = +f(array[i + 1], i + 1, array); | |
| return a + (b - a) * (h - i); | |
| }; | |
| var max = function(array, f) { | |
| var i = -1, | |
| n = array.length, | |
| a, | |
| b; | |
| if (f == null) { | |
| while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; } | |
| while (++i < n) if ((b = array[i]) != null && b > a) a = b; | |
| } | |
| else { | |
| while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; } | |
| while (++i < n) if ((b = f(array[i], i, array)) != null && b > a) a = b; | |
| } | |
| return a; | |
| }; | |
| var min = function(array, f) { | |
| var i = -1, | |
| n = array.length, | |
| a, | |
| b; | |
| if (f == null) { | |
| while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; } | |
| while (++i < n) if ((b = array[i]) != null && a > b) a = b; | |
| } | |
| else { | |
| while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; } | |
| while (++i < n) if ((b = f(array[i], i, array)) != null && a > b) a = b; | |
| } | |
| return a; | |
| }; | |
| function length(d) { | |
| return d.length; | |
| } | |
| var prefix = "$"; | |
| function Map() {} | |
| Map.prototype = map$1.prototype = { | |
| constructor: Map, | |
| has: function(key) { | |
| return (prefix + key) in this; | |
| }, | |
| get: function(key) { | |
| return this[prefix + key]; | |
| }, | |
| set: function(key, value) { | |
| this[prefix + key] = value; | |
| return this; | |
| }, | |
| remove: function(key) { | |
| var property = prefix + key; | |
| return property in this && delete this[property]; | |
| }, | |
| clear: function() { | |
| for (var property in this) if (property[0] === prefix) delete this[property]; | |
| }, | |
| keys: function() { | |
| var keys = []; | |
| for (var property in this) if (property[0] === prefix) keys.push(property.slice(1)); | |
| return keys; | |
| }, | |
| values: function() { | |
| var values = []; | |
| for (var property in this) if (property[0] === prefix) values.push(this[property]); | |
| return values; | |
| }, | |
| entries: function() { | |
| var entries = []; | |
| for (var property in this) if (property[0] === prefix) entries.push({key: property.slice(1), value: this[property]}); | |
| return entries; | |
| }, | |
| size: function() { | |
| var size = 0; | |
| for (var property in this) if (property[0] === prefix) ++size; | |
| return size; | |
| }, | |
| empty: function() { | |
| for (var property in this) if (property[0] === prefix) return false; | |
| return true; | |
| }, | |
| each: function(f) { | |
| for (var property in this) if (property[0] === prefix) f(this[property], property.slice(1), this); | |
| } | |
| }; | |
| function map$1(object, f) { | |
| var map = new Map; | |
| // Copy constructor. | |
| if (object instanceof Map) object.each(function(value, key) { map.set(key, value); }); | |
| // Index array by numeric index or specified key function. | |
| else if (Array.isArray(object)) { | |
| var i = -1, | |
| n = object.length, | |
| o; | |
| if (f == null) while (++i < n) map.set(i, object[i]); | |
| else while (++i < n) map.set(f(o = object[i], i, object), o); | |
| } | |
| // Convert object to map. | |
| else if (object) for (var key in object) map.set(key, object[key]); | |
| return map; | |
| } | |
| function Set() {} | |
| var proto = map$1.prototype; | |
| Set.prototype = set$2.prototype = { | |
| constructor: Set, | |
| has: proto.has, | |
| add: function(value) { | |
| value += ""; | |
| this[prefix + value] = value; | |
| return this; | |
| }, | |
| remove: proto.remove, | |
| clear: proto.clear, | |
| values: proto.keys, | |
| size: proto.size, | |
| empty: proto.empty, | |
| each: proto.each | |
| }; | |
| function set$2(object, f) { | |
| var set = new Set; | |
| // Copy constructor. | |
| if (object instanceof Set) object.each(function(value) { set.add(value); }); | |
| // Otherwise, assume it’s an array. | |
| else if (object) { | |
| var i = -1, n = object.length; | |
| if (f == null) while (++i < n) set.add(object[i]); | |
| else while (++i < n) set.add(f(object[i], i, object)); | |
| } | |
| return set; | |
| } | |
| var array$2 = Array.prototype; | |
| var map$3 = array$2.map; | |
| var slice$1 = array$2.slice; | |
| var implicit = {name: "implicit"}; | |
| var constant$3 = function(x) { | |
| return function() { | |
| return x; | |
| }; | |
| }; | |
| var number$1 = function(x) { | |
| return +x; | |
| }; | |
| var unit = [0, 1]; | |
| function deinterpolateLinear(a, b) { | |
| return (b -= (a = +a)) | |
| ? function(x) { return (x - a) / b; } | |
| : constant$3(b); | |
| } | |
| function deinterpolateClamp(deinterpolate) { | |
| return function(a, b) { | |
| var d = deinterpolate(a = +a, b = +b); | |
| return function(x) { return x <= a ? 0 : x >= b ? 1 : d(x); }; | |
| }; | |
| } | |
| function reinterpolateClamp(reinterpolate) { | |
| return function(a, b) { | |
| var r = reinterpolate(a = +a, b = +b); | |
| return function(t) { return t <= 0 ? a : t >= 1 ? b : r(t); }; | |
| }; | |
| } | |
| function bimap(domain, range$$1, deinterpolate, reinterpolate) { | |
| var d0 = domain[0], d1 = domain[1], r0 = range$$1[0], r1 = range$$1[1]; | |
| if (d1 < d0) d0 = deinterpolate(d1, d0), r0 = reinterpolate(r1, r0); | |
| else d0 = deinterpolate(d0, d1), r0 = reinterpolate(r0, r1); | |
| return function(x) { return r0(d0(x)); }; | |
| } | |
| function polymap(domain, range$$1, deinterpolate, reinterpolate) { | |
| var j = Math.min(domain.length, range$$1.length) - 1, | |
| d = new Array(j), | |
| r = new Array(j), | |
| i = -1; | |
| // Reverse descending domains. | |
| if (domain[j] < domain[0]) { | |
| domain = domain.slice().reverse(); | |
| range$$1 = range$$1.slice().reverse(); | |
| } | |
| while (++i < j) { | |
| d[i] = deinterpolate(domain[i], domain[i + 1]); | |
| r[i] = reinterpolate(range$$1[i], range$$1[i + 1]); | |
| } | |
| return function(x) { | |
| var i = bisectRight(domain, x, 1, j) - 1; | |
| return r[i](d[i](x)); | |
| }; | |
| } | |
| function copy(source, target) { | |
| return target | |
| .domain(source.domain()) | |
| .range(source.range()) | |
| .interpolate(source.interpolate()) | |
| .clamp(source.clamp()); | |
| } | |
| // deinterpolate(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1]. | |
| // reinterpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding domain value x in [a,b]. | |
| function continuous(deinterpolate, reinterpolate) { | |
| var domain = unit, | |
| range$$1 = unit, | |
| interpolate$$1 = interpolateValue, | |
| clamp = false, | |
| piecewise, | |
| output, | |
| input; | |
| function rescale() { | |
| piecewise = Math.min(domain.length, range$$1.length) > 2 ? polymap : bimap; | |
| output = input = null; | |
| return scale; | |
| } | |
| function scale(x) { | |
| return (output || (output = piecewise(domain, range$$1, clamp ? deinterpolateClamp(deinterpolate) : deinterpolate, interpolate$$1)))(+x); | |
| } | |
| scale.invert = function(y) { | |
| return (input || (input = piecewise(range$$1, domain, deinterpolateLinear, clamp ? reinterpolateClamp(reinterpolate) : reinterpolate)))(+y); | |
| }; | |
| scale.domain = function(_) { | |
| return arguments.length ? (domain = map$3.call(_, number$1), rescale()) : domain.slice(); | |
| }; | |
| scale.range = function(_) { | |
| return arguments.length ? (range$$1 = slice$1.call(_), rescale()) : range$$1.slice(); | |
| }; | |
| scale.rangeRound = function(_) { | |
| return range$$1 = slice$1.call(_), interpolate$$1 = interpolateRound, rescale(); | |
| }; | |
| scale.clamp = function(_) { | |
| return arguments.length ? (clamp = !!_, rescale()) : clamp; | |
| }; | |
| scale.interpolate = function(_) { | |
| return arguments.length ? (interpolate$$1 = _, rescale()) : interpolate$$1; | |
| }; | |
| return rescale(); | |
| } | |
| var tickFormat = function(domain, count, specifier) { | |
| var start = domain[0], | |
| stop = domain[domain.length - 1], | |
| step = tickStep(start, stop, count == null ? 10 : count), | |
| precision; | |
| specifier = formatSpecifier(specifier == null ? ",f" : specifier); | |
| switch (specifier.type) { | |
| case "s": { | |
| var value = Math.max(Math.abs(start), Math.abs(stop)); | |
| if (specifier.precision == null && !isNaN(precision = precisionPrefix(step, value))) specifier.precision = precision; | |
| return formatPrefix(specifier, value); | |
| } | |
| case "": | |
| case "e": | |
| case "g": | |
| case "p": | |
| case "r": { | |
| if (specifier.precision == null && !isNaN(precision = precisionRound(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e"); | |
| break; | |
| } | |
| case "f": | |
| case "%": { | |
| if (specifier.precision == null && !isNaN(precision = precisionFixed(step))) specifier.precision = precision - (specifier.type === "%") * 2; | |
| break; | |
| } | |
| } | |
| return format(specifier); | |
| }; | |
| function linearish(scale) { | |
| var domain = scale.domain; | |
| scale.ticks = function(count) { | |
| var d = domain(); | |
| return ticks(d[0], d[d.length - 1], count == null ? 10 : count); | |
| }; | |
| scale.tickFormat = function(count, specifier) { | |
| return tickFormat(domain(), count, specifier); | |
| }; | |
| scale.nice = function(count) { | |
| var d = domain(), | |
| i = d.length - 1, | |
| n = count == null ? 10 : count, | |
| start = d[0], | |
| stop = d[i], | |
| step = tickStep(start, stop, n); | |
| if (step) { | |
| step = tickStep(Math.floor(start / step) * step, Math.ceil(stop / step) * step, n); | |
| d[0] = Math.floor(start / step) * step; | |
| d[i] = Math.ceil(stop / step) * step; | |
| domain(d); | |
| } | |
| return scale; | |
| }; | |
| return scale; | |
| } | |
| function linear$2() { | |
| var scale = continuous(deinterpolateLinear, reinterpolate); | |
| scale.copy = function() { | |
| return copy(scale, linear$2()); | |
| }; | |
| return linearish(scale); | |
| } | |
| function deinterpolate(a, b) { | |
| return (b = Math.log(b / a)) | |
| ? function(x) { return Math.log(x / a) / b; } | |
| : constant$3(b); | |
| } | |
| function reinterpolate$1(a, b) { | |
| return a < 0 | |
| ? function(t) { return -Math.pow(-b, t) * Math.pow(-a, 1 - t); } | |
| : function(t) { return Math.pow(b, t) * Math.pow(a, 1 - t); }; | |
| } | |
| function pow10(x) { | |
| return isFinite(x) ? +("1e" + x) : x < 0 ? 0 : x; | |
| } | |
| function powp(base) { | |
| return base === 10 ? pow10 | |
| : base === Math.E ? Math.exp | |
| : function(x) { return Math.pow(base, x); }; | |
| } | |
| function logp(base) { | |
| return base === Math.E ? Math.log | |
| : base === 10 && Math.log10 | |
| || base === 2 && Math.log2 | |
| || (base = Math.log(base), function(x) { return Math.log(x) / base; }); | |
| } | |
| var t0$1 = new Date; | |
| var t1$1 = new Date; | |
| function newInterval(floori, offseti, count, field) { | |
| function interval(date) { | |
| return floori(date = new Date(+date)), date; | |
| } | |
| interval.floor = interval; | |
| interval.ceil = function(date) { | |
| return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date; | |
| }; | |
| interval.round = function(date) { | |
| var d0 = interval(date), | |
| d1 = interval.ceil(date); | |
| return date - d0 < d1 - date ? d0 : d1; | |
| }; | |
| interval.offset = function(date, step) { | |
| return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date; | |
| }; | |
| interval.range = function(start, stop, step) { | |
| var range = []; | |
| start = interval.ceil(start); | |
| step = step == null ? 1 : Math.floor(step); | |
| if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date | |
| do range.push(new Date(+start)); while (offseti(start, step), floori(start), start < stop) | |
| return range; | |
| }; | |
| interval.filter = function(test) { | |
| return newInterval(function(date) { | |
| if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1); | |
| }, function(date, step) { | |
| if (date >= date) while (--step >= 0) while (offseti(date, 1), !test(date)) {} // eslint-disable-line no-empty | |
| }); | |
| }; | |
| if (count) { | |
| interval.count = function(start, end) { | |
| t0$1.setTime(+start), t1$1.setTime(+end); | |
| floori(t0$1), floori(t1$1); | |
| return Math.floor(count(t0$1, t1$1)); | |
| }; | |
| interval.every = function(step) { | |
| step = Math.floor(step); | |
| return !isFinite(step) || !(step > 0) ? null | |
| : !(step > 1) ? interval | |
| : interval.filter(field | |
| ? function(d) { return field(d) % step === 0; } | |
| : function(d) { return interval.count(0, d) % step === 0; }); | |
| }; | |
| } | |
| return interval; | |
| } | |
| var millisecond = newInterval(function() { | |
| // noop | |
| }, function(date, step) { | |
| date.setTime(+date + step); | |
| }, function(start, end) { | |
| return end - start; | |
| }); | |
| // An optimized implementation for this simple case. | |
| millisecond.every = function(k) { | |
| k = Math.floor(k); | |
| if (!isFinite(k) || !(k > 0)) return null; | |
| if (!(k > 1)) return millisecond; | |
| return newInterval(function(date) { | |
| date.setTime(Math.floor(date / k) * k); | |
| }, function(date, step) { | |
| date.setTime(+date + step * k); | |
| }, function(start, end) { | |
| return (end - start) / k; | |
| }); | |
| }; | |
| var durationSecond$1 = 1e3; | |
| var durationMinute$1 = 6e4; | |
| var durationHour$1 = 36e5; | |
| var durationDay$1 = 864e5; | |
| var durationWeek$1 = 6048e5; | |
| var second = newInterval(function(date) { | |
| date.setTime(Math.floor(date / durationSecond$1) * durationSecond$1); | |
| }, function(date, step) { | |
| date.setTime(+date + step * durationSecond$1); | |
| }, function(start, end) { | |
| return (end - start) / durationSecond$1; | |
| }, function(date) { | |
| return date.getUTCSeconds(); | |
| }); | |
| var minute = newInterval(function(date) { | |
| date.setTime(Math.floor(date / durationMinute$1) * durationMinute$1); | |
| }, function(date, step) { | |
| date.setTime(+date + step * durationMinute$1); | |
| }, function(start, end) { | |
| return (end - start) / durationMinute$1; | |
| }, function(date) { | |
| return date.getMinutes(); | |
| }); | |
| var hour = newInterval(function(date) { | |
| var offset = date.getTimezoneOffset() * durationMinute$1 % durationHour$1; | |
| if (offset < 0) offset += durationHour$1; | |
| date.setTime(Math.floor((+date - offset) / durationHour$1) * durationHour$1 + offset); | |
| }, function(date, step) { | |
| date.setTime(+date + step * durationHour$1); | |
| }, function(start, end) { | |
| return (end - start) / durationHour$1; | |
| }, function(date) { | |
| return date.getHours(); | |
| }); | |
| var day = newInterval(function(date) { | |
| date.setHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setDate(date.getDate() + step); | |
| }, function(start, end) { | |
| return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute$1) / durationDay$1; | |
| }, function(date) { | |
| return date.getDate() - 1; | |
| }); | |
| function weekday(i) { | |
| return newInterval(function(date) { | |
| date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7); | |
| date.setHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setDate(date.getDate() + step * 7); | |
| }, function(start, end) { | |
| return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute$1) / durationWeek$1; | |
| }); | |
| } | |
| var sunday = weekday(0); | |
| var monday = weekday(1); | |
| var tuesday = weekday(2); | |
| var wednesday = weekday(3); | |
| var thursday = weekday(4); | |
| var friday = weekday(5); | |
| var saturday = weekday(6); | |
| var month = newInterval(function(date) { | |
| date.setDate(1); | |
| date.setHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setMonth(date.getMonth() + step); | |
| }, function(start, end) { | |
| return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12; | |
| }, function(date) { | |
| return date.getMonth(); | |
| }); | |
| var year = newInterval(function(date) { | |
| date.setMonth(0, 1); | |
| date.setHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setFullYear(date.getFullYear() + step); | |
| }, function(start, end) { | |
| return end.getFullYear() - start.getFullYear(); | |
| }, function(date) { | |
| return date.getFullYear(); | |
| }); | |
| // An optimized implementation for this simple case. | |
| year.every = function(k) { | |
| return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) { | |
| date.setFullYear(Math.floor(date.getFullYear() / k) * k); | |
| date.setMonth(0, 1); | |
| date.setHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setFullYear(date.getFullYear() + step * k); | |
| }); | |
| }; | |
| var utcMinute = newInterval(function(date) { | |
| date.setUTCSeconds(0, 0); | |
| }, function(date, step) { | |
| date.setTime(+date + step * durationMinute$1); | |
| }, function(start, end) { | |
| return (end - start) / durationMinute$1; | |
| }, function(date) { | |
| return date.getUTCMinutes(); | |
| }); | |
| var utcHour = newInterval(function(date) { | |
| date.setUTCMinutes(0, 0, 0); | |
| }, function(date, step) { | |
| date.setTime(+date + step * durationHour$1); | |
| }, function(start, end) { | |
| return (end - start) / durationHour$1; | |
| }, function(date) { | |
| return date.getUTCHours(); | |
| }); | |
| var utcDay = newInterval(function(date) { | |
| date.setUTCHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setUTCDate(date.getUTCDate() + step); | |
| }, function(start, end) { | |
| return (end - start) / durationDay$1; | |
| }, function(date) { | |
| return date.getUTCDate() - 1; | |
| }); | |
| function utcWeekday(i) { | |
| return newInterval(function(date) { | |
| date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7); | |
| date.setUTCHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setUTCDate(date.getUTCDate() + step * 7); | |
| }, function(start, end) { | |
| return (end - start) / durationWeek$1; | |
| }); | |
| } | |
| var utcSunday = utcWeekday(0); | |
| var utcMonday = utcWeekday(1); | |
| var utcTuesday = utcWeekday(2); | |
| var utcWednesday = utcWeekday(3); | |
| var utcThursday = utcWeekday(4); | |
| var utcFriday = utcWeekday(5); | |
| var utcSaturday = utcWeekday(6); | |
| var utcMonth = newInterval(function(date) { | |
| date.setUTCDate(1); | |
| date.setUTCHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setUTCMonth(date.getUTCMonth() + step); | |
| }, function(start, end) { | |
| return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12; | |
| }, function(date) { | |
| return date.getUTCMonth(); | |
| }); | |
| var utcYear = newInterval(function(date) { | |
| date.setUTCMonth(0, 1); | |
| date.setUTCHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setUTCFullYear(date.getUTCFullYear() + step); | |
| }, function(start, end) { | |
| return end.getUTCFullYear() - start.getUTCFullYear(); | |
| }, function(date) { | |
| return date.getUTCFullYear(); | |
| }); | |
| // An optimized implementation for this simple case. | |
| utcYear.every = function(k) { | |
| return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) { | |
| date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k); | |
| date.setUTCMonth(0, 1); | |
| date.setUTCHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setUTCFullYear(date.getUTCFullYear() + step * k); | |
| }); | |
| }; | |
| function localDate(d) { | |
| if (0 <= d.y && d.y < 100) { | |
| var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L); | |
| date.setFullYear(d.y); | |
| return date; | |
| } | |
| return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L); | |
| } | |
| function utcDate(d) { | |
| if (0 <= d.y && d.y < 100) { | |
| var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L)); | |
| date.setUTCFullYear(d.y); | |
| return date; | |
| } | |
| return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L)); | |
| } | |
| function newYear(y) { | |
| return {y: y, m: 0, d: 1, H: 0, M: 0, S: 0, L: 0}; | |
| } | |
| function formatLocale$1(locale) { | |
| var locale_dateTime = locale.dateTime, | |
| locale_date = locale.date, | |
| locale_time = locale.time, | |
| locale_periods = locale.periods, | |
| locale_weekdays = locale.days, | |
| locale_shortWeekdays = locale.shortDays, | |
| locale_months = locale.months, | |
| locale_shortMonths = locale.shortMonths; | |
| var periodRe = formatRe(locale_periods), | |
| periodLookup = formatLookup(locale_periods), | |
| weekdayRe = formatRe(locale_weekdays), | |
| weekdayLookup = formatLookup(locale_weekdays), | |
| shortWeekdayRe = formatRe(locale_shortWeekdays), | |
| shortWeekdayLookup = formatLookup(locale_shortWeekdays), | |
| monthRe = formatRe(locale_months), | |
| monthLookup = formatLookup(locale_months), | |
| shortMonthRe = formatRe(locale_shortMonths), | |
| shortMonthLookup = formatLookup(locale_shortMonths); | |
| var formats = { | |
| "a": formatShortWeekday, | |
| "A": formatWeekday, | |
| "b": formatShortMonth, | |
| "B": formatMonth, | |
| "c": null, | |
| "d": formatDayOfMonth, | |
| "e": formatDayOfMonth, | |
| "H": formatHour24, | |
| "I": formatHour12, | |
| "j": formatDayOfYear, | |
| "L": formatMilliseconds, | |
| "m": formatMonthNumber, | |
| "M": formatMinutes, | |
| "p": formatPeriod, | |
| "S": formatSeconds, | |
| "U": formatWeekNumberSunday, | |
| "w": formatWeekdayNumber, | |
| "W": formatWeekNumberMonday, | |
| "x": null, | |
| "X": null, | |
| "y": formatYear, | |
| "Y": formatFullYear, | |
| "Z": formatZone, | |
| "%": formatLiteralPercent | |
| }; | |
| var utcFormats = { | |
| "a": formatUTCShortWeekday, | |
| "A": formatUTCWeekday, | |
| "b": formatUTCShortMonth, | |
| "B": formatUTCMonth, | |
| "c": null, | |
| "d": formatUTCDayOfMonth, | |
| "e": formatUTCDayOfMonth, | |
| "H": formatUTCHour24, | |
| "I": formatUTCHour12, | |
| "j": formatUTCDayOfYear, | |
| "L": formatUTCMilliseconds, | |
| "m": formatUTCMonthNumber, | |
| "M": formatUTCMinutes, | |
| "p": formatUTCPeriod, | |
| "S": formatUTCSeconds, | |
| "U": formatUTCWeekNumberSunday, | |
| "w": formatUTCWeekdayNumber, | |
| "W": formatUTCWeekNumberMonday, | |
| "x": null, | |
| "X": null, | |
| "y": formatUTCYear, | |
| "Y": formatUTCFullYear, | |
| "Z": formatUTCZone, | |
| "%": formatLiteralPercent | |
| }; | |
| var parses = { | |
| "a": parseShortWeekday, | |
| "A": parseWeekday, | |
| "b": parseShortMonth, | |
| "B": parseMonth, | |
| "c": parseLocaleDateTime, | |
| "d": parseDayOfMonth, | |
| "e": parseDayOfMonth, | |
| "H": parseHour24, | |
| "I": parseHour24, | |
| "j": parseDayOfYear, | |
| "L": parseMilliseconds, | |
| "m": parseMonthNumber, | |
| "M": parseMinutes, | |
| "p": parsePeriod, | |
| "S": parseSeconds, | |
| "U": parseWeekNumberSunday, | |
| "w": parseWeekdayNumber, | |
| "W": parseWeekNumberMonday, | |
| "x": parseLocaleDate, | |
| "X": parseLocaleTime, | |
| "y": parseYear, | |
| "Y": parseFullYear, | |
| "Z": parseZone, | |
| "%": parseLiteralPercent | |
| }; | |
| // These recursive directive definitions must be deferred. | |
| formats.x = newFormat(locale_date, formats); | |
| formats.X = newFormat(locale_time, formats); | |
| formats.c = newFormat(locale_dateTime, formats); | |
| utcFormats.x = newFormat(locale_date, utcFormats); | |
| utcFormats.X = newFormat(locale_time, utcFormats); | |
| utcFormats.c = newFormat(locale_dateTime, utcFormats); | |
| function newFormat(specifier, formats) { | |
| return function(date) { | |
| var string = [], | |
| i = -1, | |
| j = 0, | |
| n = specifier.length, | |
| c, | |
| pad, | |
| format; | |
| if (!(date instanceof Date)) date = new Date(+date); | |
| while (++i < n) { | |
| if (specifier.charCodeAt(i) === 37) { | |
| string.push(specifier.slice(j, i)); | |
| if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i); | |
| else pad = c === "e" ? " " : "0"; | |
| if (format = formats[c]) c = format(date, pad); | |
| string.push(c); | |
| j = i + 1; | |
| } | |
| } | |
| string.push(specifier.slice(j, i)); | |
| return string.join(""); | |
| }; | |
| } | |
| function newParse(specifier, newDate) { | |
| return function(string) { | |
| var d = newYear(1900), | |
| i = parseSpecifier(d, specifier, string += "", 0); | |
| if (i != string.length) return null; | |
| // The am-pm flag is 0 for AM, and 1 for PM. | |
| if ("p" in d) d.H = d.H % 12 + d.p * 12; | |
| // Convert day-of-week and week-of-year to day-of-year. | |
| if ("W" in d || "U" in d) { | |
| if (!("w" in d)) d.w = "W" in d ? 1 : 0; | |
| var day$$1 = "Z" in d ? utcDate(newYear(d.y)).getUTCDay() : newDate(newYear(d.y)).getDay(); | |
| d.m = 0; | |
| d.d = "W" in d ? (d.w + 6) % 7 + d.W * 7 - (day$$1 + 5) % 7 : d.w + d.U * 7 - (day$$1 + 6) % 7; | |
| } | |
| // If a time zone is specified, all fields are interpreted as UTC and then | |
| // offset according to the specified time zone. | |
| if ("Z" in d) { | |
| d.H += d.Z / 100 | 0; | |
| d.M += d.Z % 100; | |
| return utcDate(d); | |
| } | |
| // Otherwise, all fields are in local time. | |
| return newDate(d); | |
| }; | |
| } | |
| function parseSpecifier(d, specifier, string, j) { | |
| var i = 0, | |
| n = specifier.length, | |
| m = string.length, | |
| c, | |
| parse; | |
| while (i < n) { | |
| if (j >= m) return -1; | |
| c = specifier.charCodeAt(i++); | |
| if (c === 37) { | |
| c = specifier.charAt(i++); | |
| parse = parses[c in pads ? specifier.charAt(i++) : c]; | |
| if (!parse || ((j = parse(d, string, j)) < 0)) return -1; | |
| } else if (c != string.charCodeAt(j++)) { | |
| return -1; | |
| } | |
| } | |
| return j; | |
| } | |
| function parsePeriod(d, string, i) { | |
| var n = periodRe.exec(string.slice(i)); | |
| return n ? (d.p = periodLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
| } | |
| function parseShortWeekday(d, string, i) { | |
| var n = shortWeekdayRe.exec(string.slice(i)); | |
| return n ? (d.w = shortWeekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
| } | |
| function parseWeekday(d, string, i) { | |
| var n = weekdayRe.exec(string.slice(i)); | |
| return n ? (d.w = weekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
| } | |
| function parseShortMonth(d, string, i) { | |
| var n = shortMonthRe.exec(string.slice(i)); | |
| return n ? (d.m = shortMonthLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
| } | |
| function parseMonth(d, string, i) { | |
| var n = monthRe.exec(string.slice(i)); | |
| return n ? (d.m = monthLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
| } | |
| function parseLocaleDateTime(d, string, i) { | |
| return parseSpecifier(d, locale_dateTime, string, i); | |
| } | |
| function parseLocaleDate(d, string, i) { | |
| return parseSpecifier(d, locale_date, string, i); | |
| } | |
| function parseLocaleTime(d, string, i) { | |
| return parseSpecifier(d, locale_time, string, i); | |
| } | |
| function formatShortWeekday(d) { | |
| return locale_shortWeekdays[d.getDay()]; | |
| } | |
| function formatWeekday(d) { | |
| return locale_weekdays[d.getDay()]; | |
| } | |
| function formatShortMonth(d) { | |
| return locale_shortMonths[d.getMonth()]; | |
| } | |
| function formatMonth(d) { | |
| return locale_months[d.getMonth()]; | |
| } | |
| function formatPeriod(d) { | |
| return locale_periods[+(d.getHours() >= 12)]; | |
| } | |
| function formatUTCShortWeekday(d) { | |
| return locale_shortWeekdays[d.getUTCDay()]; | |
| } | |
| function formatUTCWeekday(d) { | |
| return locale_weekdays[d.getUTCDay()]; | |
| } | |
| function formatUTCShortMonth(d) { | |
| return locale_shortMonths[d.getUTCMonth()]; | |
| } | |
| function formatUTCMonth(d) { | |
| return locale_months[d.getUTCMonth()]; | |
| } | |
| function formatUTCPeriod(d) { | |
| return locale_periods[+(d.getUTCHours() >= 12)]; | |
| } | |
| return { | |
| format: function(specifier) { | |
| var f = newFormat(specifier += "", formats); | |
| f.toString = function() { return specifier; }; | |
| return f; | |
| }, | |
| parse: function(specifier) { | |
| var p = newParse(specifier += "", localDate); | |
| p.toString = function() { return specifier; }; | |
| return p; | |
| }, | |
| utcFormat: function(specifier) { | |
| var f = newFormat(specifier += "", utcFormats); | |
| f.toString = function() { return specifier; }; | |
| return f; | |
| }, | |
| utcParse: function(specifier) { | |
| var p = newParse(specifier, utcDate); | |
| p.toString = function() { return specifier; }; | |
| return p; | |
| } | |
| }; | |
| } | |
| var pads = {"-": "", "_": " ", "0": "0"}; | |
| var numberRe = /^\s*\d+/; | |
| var percentRe = /^%/; | |
| var requoteRe = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g; | |
| function pad(value, fill, width) { | |
| var sign = value < 0 ? "-" : "", | |
| string = (sign ? -value : value) + "", | |
| length = string.length; | |
| return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string); | |
| } | |
| function requote(s) { | |
| return s.replace(requoteRe, "\\$&"); | |
| } | |
| function formatRe(names) { | |
| return new RegExp("^(?:" + names.map(requote).join("|") + ")", "i"); | |
| } | |
| function formatLookup(names) { | |
| var map = {}, i = -1, n = names.length; | |
| while (++i < n) map[names[i].toLowerCase()] = i; | |
| return map; | |
| } | |
| function parseWeekdayNumber(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 1)); | |
| return n ? (d.w = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseWeekNumberSunday(d, string, i) { | |
| var n = numberRe.exec(string.slice(i)); | |
| return n ? (d.U = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseWeekNumberMonday(d, string, i) { | |
| var n = numberRe.exec(string.slice(i)); | |
| return n ? (d.W = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseFullYear(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 4)); | |
| return n ? (d.y = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseYear(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1; | |
| } | |
| function parseZone(d, string, i) { | |
| var n = /^(Z)|([+-]\d\d)(?:\:?(\d\d))?/.exec(string.slice(i, i + 6)); | |
| return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || "00")), i + n[0].length) : -1; | |
| } | |
| function parseMonthNumber(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.m = n[0] - 1, i + n[0].length) : -1; | |
| } | |
| function parseDayOfMonth(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.d = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseDayOfYear(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 3)); | |
| return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseHour24(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.H = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseMinutes(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.M = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseSeconds(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.S = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseMilliseconds(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 3)); | |
| return n ? (d.L = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseLiteralPercent(d, string, i) { | |
| var n = percentRe.exec(string.slice(i, i + 1)); | |
| return n ? i + n[0].length : -1; | |
| } | |
| function formatDayOfMonth(d, p) { | |
| return pad(d.getDate(), p, 2); | |
| } | |
| function formatHour24(d, p) { | |
| return pad(d.getHours(), p, 2); | |
| } | |
| function formatHour12(d, p) { | |
| return pad(d.getHours() % 12 || 12, p, 2); | |
| } | |
| function formatDayOfYear(d, p) { | |
| return pad(1 + day.count(year(d), d), p, 3); | |
| } | |
| function formatMilliseconds(d, p) { | |
| return pad(d.getMilliseconds(), p, 3); | |
| } | |
| function formatMonthNumber(d, p) { | |
| return pad(d.getMonth() + 1, p, 2); | |
| } | |
| function formatMinutes(d, p) { | |
| return pad(d.getMinutes(), p, 2); | |
| } | |
| function formatSeconds(d, p) { | |
| return pad(d.getSeconds(), p, 2); | |
| } | |
| function formatWeekNumberSunday(d, p) { | |
| return pad(sunday.count(year(d), d), p, 2); | |
| } | |
| function formatWeekdayNumber(d) { | |
| return d.getDay(); | |
| } | |
| function formatWeekNumberMonday(d, p) { | |
| return pad(monday.count(year(d), d), p, 2); | |
| } | |
| function formatYear(d, p) { | |
| return pad(d.getFullYear() % 100, p, 2); | |
| } | |
| function formatFullYear(d, p) { | |
| return pad(d.getFullYear() % 10000, p, 4); | |
| } | |
| function formatZone(d) { | |
| var z = d.getTimezoneOffset(); | |
| return (z > 0 ? "-" : (z *= -1, "+")) | |
| + pad(z / 60 | 0, "0", 2) | |
| + pad(z % 60, "0", 2); | |
| } | |
| function formatUTCDayOfMonth(d, p) { | |
| return pad(d.getUTCDate(), p, 2); | |
| } | |
| function formatUTCHour24(d, p) { | |
| return pad(d.getUTCHours(), p, 2); | |
| } | |
| function formatUTCHour12(d, p) { | |
| return pad(d.getUTCHours() % 12 || 12, p, 2); | |
| } | |
| function formatUTCDayOfYear(d, p) { | |
| return pad(1 + utcDay.count(utcYear(d), d), p, 3); | |
| } | |
| function formatUTCMilliseconds(d, p) { | |
| return pad(d.getUTCMilliseconds(), p, 3); | |
| } | |
| function formatUTCMonthNumber(d, p) { | |
| return pad(d.getUTCMonth() + 1, p, 2); | |
| } | |
| function formatUTCMinutes(d, p) { | |
| return pad(d.getUTCMinutes(), p, 2); | |
| } | |
| function formatUTCSeconds(d, p) { | |
| return pad(d.getUTCSeconds(), p, 2); | |
| } | |
| function formatUTCWeekNumberSunday(d, p) { | |
| return pad(utcSunday.count(utcYear(d), d), p, 2); | |
| } | |
| function formatUTCWeekdayNumber(d) { | |
| return d.getUTCDay(); | |
| } | |
| function formatUTCWeekNumberMonday(d, p) { | |
| return pad(utcMonday.count(utcYear(d), d), p, 2); | |
| } | |
| function formatUTCYear(d, p) { | |
| return pad(d.getUTCFullYear() % 100, p, 2); | |
| } | |
| function formatUTCFullYear(d, p) { | |
| return pad(d.getUTCFullYear() % 10000, p, 4); | |
| } | |
| function formatUTCZone() { | |
| return "+0000"; | |
| } | |
| function formatLiteralPercent() { | |
| return "%"; | |
| } | |
| var locale$2; | |
| var timeFormat; | |
| var timeParse; | |
| var utcFormat; | |
| var utcParse; | |
| defaultLocale$1({ | |
| dateTime: "%x, %X", | |
| date: "%-m/%-d/%Y", | |
| time: "%-I:%M:%S %p", | |
| periods: ["AM", "PM"], | |
| days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], | |
| shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], | |
| months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], | |
| shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] | |
| }); | |
| function defaultLocale$1(definition) { | |
| locale$2 = formatLocale$1(definition); | |
| timeFormat = locale$2.format; | |
| timeParse = locale$2.parse; | |
| utcFormat = locale$2.utcFormat; | |
| utcParse = locale$2.utcParse; | |
| return locale$2; | |
| } | |
| var isoSpecifier = "%Y-%m-%dT%H:%M:%S.%LZ"; | |
| function formatIsoNative(date) { | |
| return date.toISOString(); | |
| } | |
| var formatIso = Date.prototype.toISOString | |
| ? formatIsoNative | |
| : utcFormat(isoSpecifier); | |
| function parseIsoNative(string) { | |
| var date = new Date(string); | |
| return isNaN(date) ? null : date; | |
| } | |
| var parseIso = +new Date("2000-01-01T00:00:00.000Z") | |
| ? parseIsoNative | |
| : utcParse(isoSpecifier); | |
| var colors$1 = function(s) { | |
| return s.match(/.{6}/g).map(function(x) { | |
| return "#" + x; | |
| }); | |
| }; | |
| colors$1("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf"); | |
| colors$1("393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6"); | |
| colors$1("3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9"); | |
| colors$1("1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5"); | |
| cubehelixLong(cubehelix(300, 0.5, 0.0), cubehelix(-240, 0.5, 1.0)); | |
| var warm = cubehelixLong(cubehelix(-100, 0.75, 0.35), cubehelix(80, 1.50, 0.8)); | |
| var cool = cubehelixLong(cubehelix(260, 0.75, 0.35), cubehelix(80, 1.50, 0.8)); | |
| var rainbow = cubehelix(); | |
| var slice$2 = Array.prototype.slice; | |
| var identity$4 = function(x) { | |
| return x; | |
| }; | |
| var top = 1; | |
| var right = 2; | |
| var bottom = 3; | |
| var left = 4; | |
| var epsilon = 1e-6; | |
| function translateX(x) { | |
| return "translate(" + x + ",0)"; | |
| } | |
| function translateY(y) { | |
| return "translate(0," + y + ")"; | |
| } | |
| function center(scale) { | |
| var offset = scale.bandwidth() / 2; | |
| if (scale.round()) offset = Math.round(offset); | |
| return function(d) { | |
| return scale(d) + offset; | |
| }; | |
| } | |
| function entering() { | |
| return !this.__axis; | |
| } | |
| function axis(orient, scale) { | |
| var tickArguments = [], | |
| tickValues = null, | |
| tickFormat = null, | |
| tickSizeInner = 6, | |
| tickSizeOuter = 6, | |
| tickPadding = 3, | |
| k = orient === top || orient === left ? -1 : 1, | |
| x, y = orient === left || orient === right ? (x = "x", "y") : (x = "y", "x"), | |
| transform = orient === top || orient === bottom ? translateX : translateY; | |
| function axis(context) { | |
| var values = tickValues == null ? (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) : tickValues, | |
| format = tickFormat == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : identity$4) : tickFormat, | |
| spacing = Math.max(tickSizeInner, 0) + tickPadding, | |
| range = scale.range(), | |
| range0 = range[0] + 0.5, | |
| range1 = range[range.length - 1] + 0.5, | |
| position = (scale.bandwidth ? center : identity$4)(scale.copy()), | |
| selection = context.selection ? context.selection() : context, | |
| path = selection.selectAll(".domain").data([null]), | |
| tick = selection.selectAll(".tick").data(values, scale).order(), | |
| tickExit = tick.exit(), | |
| tickEnter = tick.enter().append("g").attr("class", "tick"), | |
| line = tick.select("line"), | |
| text = tick.select("text"); | |
| path = path.merge(path.enter().insert("path", ".tick") | |
| .attr("class", "domain") | |
| .attr("stroke", "#000")); | |
| tick = tick.merge(tickEnter); | |
| line = line.merge(tickEnter.append("line") | |
| .attr("stroke", "#000") | |
| .attr(x + "2", k * tickSizeInner) | |
| .attr(y + "1", 0.5) | |
| .attr(y + "2", 0.5)); | |
| text = text.merge(tickEnter.append("text") | |
| .attr("fill", "#000") | |
| .attr(x, k * spacing) | |
| .attr(y, 0.5) | |
| .attr("dy", orient === top ? "0em" : orient === bottom ? "0.71em" : "0.32em")); | |
| if (context !== selection) { | |
| path = path.transition(context); | |
| tick = tick.transition(context); | |
| line = line.transition(context); | |
| text = text.transition(context); | |
| tickExit = tickExit.transition(context) | |
| .attr("opacity", epsilon) | |
| .attr("transform", function(d) { return isFinite(d = position(d)) ? transform(d) : this.getAttribute("transform"); }); | |
| tickEnter | |
| .attr("opacity", epsilon) | |
| .attr("transform", function(d) { var p = this.parentNode.__axis; return transform(p && isFinite(p = p(d)) ? p : position(d)); }); | |
| } | |
| tickExit.remove(); | |
| path | |
| .attr("d", orient === left || orient == right | |
| ? "M" + k * tickSizeOuter + "," + range0 + "H0.5V" + range1 + "H" + k * tickSizeOuter | |
| : "M" + range0 + "," + k * tickSizeOuter + "V0.5H" + range1 + "V" + k * tickSizeOuter); | |
| tick | |
| .attr("opacity", 1) | |
| .attr("transform", function(d) { return transform(position(d)); }); | |
| line | |
| .attr(x + "2", k * tickSizeInner); | |
| text | |
| .attr(x, k * spacing) | |
| .text(format); | |
| selection.filter(entering) | |
| .attr("fill", "none") | |
| .attr("font-size", 10) | |
| .attr("font-family", "sans-serif") | |
| .attr("text-anchor", orient === right ? "start" : orient === left ? "end" : "middle"); | |
| selection | |
| .each(function() { this.__axis = position; }); | |
| } | |
| axis.scale = function(_) { | |
| return arguments.length ? (scale = _, axis) : scale; | |
| }; | |
| axis.ticks = function() { | |
| return tickArguments = slice$2.call(arguments), axis; | |
| }; | |
| axis.tickArguments = function(_) { | |
| return arguments.length ? (tickArguments = _ == null ? [] : slice$2.call(_), axis) : tickArguments.slice(); | |
| }; | |
| axis.tickValues = function(_) { | |
| return arguments.length ? (tickValues = _ == null ? null : slice$2.call(_), axis) : tickValues && tickValues.slice(); | |
| }; | |
| axis.tickFormat = function(_) { | |
| return arguments.length ? (tickFormat = _, axis) : tickFormat; | |
| }; | |
| axis.tickSize = function(_) { | |
| return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis) : tickSizeInner; | |
| }; | |
| axis.tickSizeInner = function(_) { | |
| return arguments.length ? (tickSizeInner = +_, axis) : tickSizeInner; | |
| }; | |
| axis.tickSizeOuter = function(_) { | |
| return arguments.length ? (tickSizeOuter = +_, axis) : tickSizeOuter; | |
| }; | |
| axis.tickPadding = function(_) { | |
| return arguments.length ? (tickPadding = +_, axis) : tickPadding; | |
| }; | |
| return axis; | |
| } | |
| function axisBottom(scale) { | |
| return axis(bottom, scale); | |
| } | |
| /** | |
| * plot-transform | |
| * Created by [email protected] on 22/08/2015. | |
| * Returns an afine transform that maps from top left to bottom left origin | |
| * the transform is wrapped in an object that will be accepted by .attr() in d3 | |
| * @param height | |
| * - height of the plot area in pixels | |
| * @returns | |
| * - attr object | |
| */ | |
| function transplot(yRange){ | |
| return {"transform": "matrix(" + [1, 0, 0, -1, 0, yRange] + ")"}; | |
| } | |
| /** | |
| * todo get all this working in d3 v4 | |
| * Reverses the local mirroring of transplot | |
| * @returns {{transform: string}} | |
| */ | |
| /** | |
| * @param tickSize | |
| * @returns {tickSize} | |
| */ | |
| /** | |
| * Axis constructor that returns custom behaviour on d3.svg.axis | |
| * | |
| */ | |
| /** | |
| * d3-fps-histogram | |
| */ | |
| // import HistWorker from 'worker!./histogramWorker.js' | |
| function Histogram(on, style, config) { | |
| let BINS = 30; | |
| let messageStyle = { | |
| border: 0, margin: 0, "box-sizing": "border-box", | |
| padding: "0 0 0 6px", background: "black", "color": "orange", | |
| position: "absolute", left: config.width + "px" | |
| }; | |
| let _message = () => "", | |
| posnContext = select(on).append("div") | |
| .attr("id", "positioning-context") | |
| .styles({ | |
| "white-space": "pre", | |
| position: "relative" | |
| }), | |
| wrapper = posnContext | |
| .attr("id", "wrapper") | |
| .styles({position: "absolute"}), | |
| hist = wrapper.append("div") | |
| .styles(style) | |
| .attr("id", "histogram") | |
| .append("svg") | |
| .styles({overflow: "visible", margin: 0}) | |
| .attrs(config), | |
| elapsedTime = ElapsedTime(on, messageStyle) | |
| .message(function (value) { | |
| return new Promise((resolve, reject) => { | |
| let this_lap = elapsedTime.lap().lastLap, aveLap = elapsedTime.aveLap(this_lap); | |
| resolve((aveLap ? format(" >5,.1f")(1 / aveLap) : format(" >5c")(" ")) + " fps\t" + | |
| _message.call(elapsedTime, value, this_lap, aveLap)); | |
| }) | |
| }) | |
| .window(config.window), | |
| plot = hist.append("g") | |
| .attrs(transplot(config.height)) | |
| .classed("plot", true) | |
| .attrs({"fill": "url(#xColor)"}), | |
| _xAxis = axisBottom() | |
| .tickFormat("") | |
| .ticks(3) | |
| .tickSize(config.tickSize || 3), | |
| xAxis = (g) => { | |
| g.call(_xAxis) | |
| .attrs({ | |
| "fill": "url(#xColor)", stroke: 'url(#xColor)' | |
| }); | |
| g.select(".domain").attr("stroke", "none"); | |
| let ticks$$1 = g.selectAll(".tick:not(:first-of-type) line").attr("stroke", "black"); | |
| ticks$$1.select("line").attr("stroke-width", "0.5px"); | |
| }, | |
| xG = hist.append("g") | |
| .attrs({ | |
| "transform": "translate(0," + (config.height) + ")", | |
| "id": "x-axis-fill" | |
| }), | |
| defs = hist.append("defs"), | |
| gradient = defs.append("linearGradient") | |
| .attrs({ | |
| id: "xColor", x1: "0%", y1: "0%", x2: "100%", y2: "0%", | |
| gradientUnits: "userSpaceOnUse" | |
| }); | |
| elapsedTime.start(); | |
| gradient.append("stop") | |
| .attrs({"offset": "0%", "stop-color": "red"}); | |
| gradient.append("stop") | |
| .attrs({"offset": "50%", "stop-color": "orange"}); | |
| gradient.append("stop") | |
| .attrs({"offset": "100%", "stop-color": "green"}); | |
| const getData = () => { | |
| return elapsedTime.aveLap.history; | |
| }; | |
| const update = (function () { | |
| let x = linear$2() | |
| .range([0, config.width]); | |
| if (config.domain) { | |
| x.domain(config.domain); | |
| _xAxis.scale(x); | |
| xG.call(xAxis); | |
| } | |
| let y = linear$2() | |
| .range([0, config.height]); | |
| let h; | |
| // let histWorker = new HistWorker(); | |
| function makeHist(data, values, x, bins) { | |
| return histogram() | |
| .domain(x.domain()) | |
| .thresholds(x.ticks(bins))(data.map(d => values(d))) | |
| } | |
| function values(d) { | |
| return 1 / d | |
| } | |
| function prepare(data, bins) { | |
| let _data = data(); | |
| if(!config.domain) | |
| x.domain([0, max(_data, values)]); | |
| h = makeHist(_data, values, x, bins); | |
| y.domain([0, max(h, function (d) { | |
| return d.length | |
| } | |
| )]); | |
| } | |
| return function _update(data) { | |
| // if (!data || !data.length) return; | |
| window.setTimeout(() => prepare(data, BINS)); | |
| if (!h) return; | |
| let bars = plot.selectAll(".bar").data(h), | |
| enter = bars.enter().append("rect") | |
| .attrs({ | |
| class: "bar", | |
| opacity: 1, | |
| width: function (d) { | |
| return x(d.x1 - d.x0) | |
| }, | |
| }); | |
| enter.merge(bars).attrs({ | |
| x: function (d) { | |
| return x(d.x0) | |
| } | |
| }); | |
| bars.exit().remove(); | |
| bars.attr("height", function (d) { | |
| return y(d.length) | |
| }); | |
| if (!config.domain) { | |
| _xAxis.scale(x); | |
| xG.call(xAxis); | |
| } | |
| } | |
| })(); | |
| // update(range(BINS)); | |
| let done = false; | |
| function render() { | |
| let thisWrapper; | |
| // if(done) return; | |
| // if(currentWrapper) | |
| // window.requestAnimationFrame(currentWrapper.remove.bind(currentWrapper)); | |
| // currentWrapper = posnContext.append(() => wrapper.node()) | |
| } | |
| // function preRender() { | |
| // if (currentWrapper) | |
| // currentWrapper.remove(); | |
| // } | |
| update.svg = hist; | |
| update.message = function (f) { | |
| _message = f; | |
| return this | |
| }; | |
| let data = getData(0); | |
| update.mark = function (a) { | |
| elapsedTime.mark(a); | |
| if (!elapsedTime.aveLap.history.length) return; | |
| // preRender(); | |
| update(() => data = getData(a)); | |
| render(); | |
| // window.setTimeout(() => data = getData(a), 0) | |
| }; | |
| update.start = function (aveWindow) { | |
| elapsedTime.start(aveWindow); | |
| }; | |
| update.selection = select(on); | |
| return update; | |
| } | |
| var xhtml$1 = "http://www.w3.org/1999/xhtml"; | |
| var namespaces$1 = { | |
| svg: "http://www.w3.org/2000/svg", | |
| xhtml: xhtml$1, | |
| xlink: "http://www.w3.org/1999/xlink", | |
| xml: "http://www.w3.org/XML/1998/namespace", | |
| xmlns: "http://www.w3.org/2000/xmlns/" | |
| }; | |
| var namespace$1 = function(name) { | |
| var prefix = name += "", i = prefix.indexOf(":"); | |
| if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1); | |
| return namespaces$1.hasOwnProperty(prefix) ? {space: namespaces$1[prefix], local: name} : name; | |
| }; | |
| function creatorInherit$1(name) { | |
| return function() { | |
| var document = this.ownerDocument, | |
| uri = this.namespaceURI; | |
| return uri === xhtml$1 && document.documentElement.namespaceURI === xhtml$1 | |
| ? document.createElement(name) | |
| : document.createElementNS(uri, name); | |
| }; | |
| } | |
| function creatorFixed$1(fullname) { | |
| return function() { | |
| return this.ownerDocument.createElementNS(fullname.space, fullname.local); | |
| }; | |
| } | |
| var creator$1 = function(name) { | |
| var fullname = namespace$1(name); | |
| return (fullname.local | |
| ? creatorFixed$1 | |
| : creatorInherit$1)(fullname); | |
| }; | |
| var matcher$2 = function(selector) { | |
| return function() { | |
| return this.matches(selector); | |
| }; | |
| }; | |
| if (typeof document !== "undefined") { | |
| var element$2 = document.documentElement; | |
| if (!element$2.matches) { | |
| var vendorMatches$1 = element$2.webkitMatchesSelector | |
| || element$2.msMatchesSelector | |
| || element$2.mozMatchesSelector | |
| || element$2.oMatchesSelector; | |
| matcher$2 = function(selector) { | |
| return function() { | |
| return vendorMatches$1.call(this, selector); | |
| }; | |
| }; | |
| } | |
| } | |
| var matcher$3 = matcher$2; | |
| var filterEvents$1 = {}; | |
| var event$1 = null; | |
| if (typeof document !== "undefined") { | |
| var element$3 = document.documentElement; | |
| if (!("onmouseenter" in element$3)) { | |
| filterEvents$1 = {mouseenter: "mouseover", mouseleave: "mouseout"}; | |
| } | |
| } | |
| function filterContextListener$1(listener, index, group) { | |
| listener = contextListener$1(listener, index, group); | |
| return function(event) { | |
| var related = event.relatedTarget; | |
| if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) { | |
| listener.call(this, event); | |
| } | |
| }; | |
| } | |
| function contextListener$1(listener, index, group) { | |
| return function(event1) { | |
| var event0 = event$1; // Events can be reentrant (e.g., focus). | |
| event$1 = event1; | |
| try { | |
| listener.call(this, this.__data__, index, group); | |
| } finally { | |
| event$1 = event0; | |
| } | |
| }; | |
| } | |
| function parseTypenames$2(typenames) { | |
| return typenames.trim().split(/^|\s+/).map(function(t) { | |
| var name = "", i = t.indexOf("."); | |
| if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i); | |
| return {type: t, name: name}; | |
| }); | |
| } | |
| function onRemove$1(typename) { | |
| return function() { | |
| var on = this.__on; | |
| if (!on) return; | |
| for (var j = 0, i = -1, m = on.length, o; j < m; ++j) { | |
| if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) { | |
| this.removeEventListener(o.type, o.listener, o.capture); | |
| } else { | |
| on[++i] = o; | |
| } | |
| } | |
| if (++i) on.length = i; | |
| else delete this.__on; | |
| }; | |
| } | |
| function onAdd$1(typename, value, capture) { | |
| var wrap = filterEvents$1.hasOwnProperty(typename.type) ? filterContextListener$1 : contextListener$1; | |
| return function(d, i, group) { | |
| var on = this.__on, o, listener = wrap(value, i, group); | |
| if (on) for (var j = 0, m = on.length; j < m; ++j) { | |
| if ((o = on[j]).type === typename.type && o.name === typename.name) { | |
| this.removeEventListener(o.type, o.listener, o.capture); | |
| this.addEventListener(o.type, o.listener = listener, o.capture = capture); | |
| o.value = value; | |
| return; | |
| } | |
| } | |
| this.addEventListener(typename.type, listener, capture); | |
| o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture}; | |
| if (!on) this.__on = [o]; | |
| else on.push(o); | |
| }; | |
| } | |
| var selection_on$1 = function(typename, value, capture) { | |
| var typenames = parseTypenames$2(typename + ""), i, n = typenames.length, t; | |
| if (arguments.length < 2) { | |
| var on = this.node().__on; | |
| if (on) for (var j = 0, m = on.length, o; j < m; ++j) { | |
| for (i = 0, o = on[j]; i < n; ++i) { | |
| if ((t = typenames[i]).type === o.type && t.name === o.name) { | |
| return o.value; | |
| } | |
| } | |
| } | |
| return; | |
| } | |
| on = value ? onAdd$1 : onRemove$1; | |
| if (capture == null) capture = false; | |
| for (i = 0; i < n; ++i) this.each(on(typenames[i], value, capture)); | |
| return this; | |
| }; | |
| function customEvent$1(event1, listener, that, args) { | |
| var event0 = event$1; | |
| event1.sourceEvent = event$1; | |
| event$1 = event1; | |
| try { | |
| return listener.apply(that, args); | |
| } finally { | |
| event$1 = event0; | |
| } | |
| } | |
| var sourceEvent$1 = function() { | |
| var current = event$1, source; | |
| while (source = current.sourceEvent) current = source; | |
| return current; | |
| }; | |
| var point$2 = function(node, event) { | |
| var svg = node.ownerSVGElement || node; | |
| if (svg.createSVGPoint) { | |
| var point = svg.createSVGPoint(); | |
| point.x = event.clientX, point.y = event.clientY; | |
| point = point.matrixTransform(node.getScreenCTM().inverse()); | |
| return [point.x, point.y]; | |
| } | |
| var rect = node.getBoundingClientRect(); | |
| return [event.clientX - rect.left - node.clientLeft, event.clientY - rect.top - node.clientTop]; | |
| }; | |
| var mouse$1 = function(node) { | |
| var event = sourceEvent$1(); | |
| if (event.changedTouches) event = event.changedTouches[0]; | |
| return point$2(node, event); | |
| }; | |
| function none$1() {} | |
| var selector$1 = function(selector) { | |
| return selector == null ? none$1 : function() { | |
| return this.querySelector(selector); | |
| }; | |
| }; | |
| var selection_select$1 = function(select) { | |
| if (typeof select !== "function") select = selector$1(select); | |
| for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) { | |
| if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) { | |
| if ("__data__" in node) subnode.__data__ = node.__data__; | |
| subgroup[i] = subnode; | |
| } | |
| } | |
| } | |
| return new Selection$2(subgroups, this._parents); | |
| }; | |
| function empty$1() { | |
| return []; | |
| } | |
| var selectorAll$1 = function(selector) { | |
| return selector == null ? empty$1 : function() { | |
| return this.querySelectorAll(selector); | |
| }; | |
| }; | |
| var selection_selectAll$1 = function(select) { | |
| if (typeof select !== "function") select = selectorAll$1(select); | |
| for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { | |
| if (node = group[i]) { | |
| subgroups.push(select.call(node, node.__data__, i, group)); | |
| parents.push(node); | |
| } | |
| } | |
| } | |
| return new Selection$2(subgroups, parents); | |
| }; | |
| var selection_filter$1 = function(match) { | |
| if (typeof match !== "function") match = matcher$3(match); | |
| for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) { | |
| if ((node = group[i]) && match.call(node, node.__data__, i, group)) { | |
| subgroup.push(node); | |
| } | |
| } | |
| } | |
| return new Selection$2(subgroups, this._parents); | |
| }; | |
| var sparse$1 = function(update) { | |
| return new Array(update.length); | |
| }; | |
| var selection_enter$1 = function() { | |
| return new Selection$2(this._enter || this._groups.map(sparse$1), this._parents); | |
| }; | |
| function EnterNode$1(parent, datum) { | |
| this.ownerDocument = parent.ownerDocument; | |
| this.namespaceURI = parent.namespaceURI; | |
| this._next = null; | |
| this._parent = parent; | |
| this.__data__ = datum; | |
| } | |
| EnterNode$1.prototype = { | |
| constructor: EnterNode$1, | |
| appendChild: function(child) { return this._parent.insertBefore(child, this._next); }, | |
| insertBefore: function(child, next) { return this._parent.insertBefore(child, next); }, | |
| querySelector: function(selector) { return this._parent.querySelector(selector); }, | |
| querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); } | |
| }; | |
| var constant$4 = function(x) { | |
| return function() { | |
| return x; | |
| }; | |
| }; | |
| var keyPrefix$1 = "$"; // Protect against keys like “__proto__”. | |
| function bindIndex$1(parent, group, enter, update, exit, data) { | |
| var i = 0, | |
| node, | |
| groupLength = group.length, | |
| dataLength = data.length; | |
| // Put any non-null nodes that fit into update. | |
| // Put any null nodes into enter. | |
| // Put any remaining data into enter. | |
| for (; i < dataLength; ++i) { | |
| if (node = group[i]) { | |
| node.__data__ = data[i]; | |
| update[i] = node; | |
| } else { | |
| enter[i] = new EnterNode$1(parent, data[i]); | |
| } | |
| } | |
| // Put any non-null nodes that don’t fit into exit. | |
| for (; i < groupLength; ++i) { | |
| if (node = group[i]) { | |
| exit[i] = node; | |
| } | |
| } | |
| } | |
| function bindKey$1(parent, group, enter, update, exit, data, key) { | |
| var i, | |
| node, | |
| nodeByKeyValue = {}, | |
| groupLength = group.length, | |
| dataLength = data.length, | |
| keyValues = new Array(groupLength), | |
| keyValue; | |
| // Compute the key for each node. | |
| // If multiple nodes have the same key, the duplicates are added to exit. | |
| for (i = 0; i < groupLength; ++i) { | |
| if (node = group[i]) { | |
| keyValues[i] = keyValue = keyPrefix$1 + key.call(node, node.__data__, i, group); | |
| if (keyValue in nodeByKeyValue) { | |
| exit[i] = node; | |
| } else { | |
| nodeByKeyValue[keyValue] = node; | |
| } | |
| } | |
| } | |
| // Compute the key for each datum. | |
| // If there a node associated with this key, join and add it to update. | |
| // If there is not (or the key is a duplicate), add it to enter. | |
| for (i = 0; i < dataLength; ++i) { | |
| keyValue = keyPrefix$1 + key.call(parent, data[i], i, data); | |
| if (node = nodeByKeyValue[keyValue]) { | |
| update[i] = node; | |
| node.__data__ = data[i]; | |
| nodeByKeyValue[keyValue] = null; | |
| } else { | |
| enter[i] = new EnterNode$1(parent, data[i]); | |
| } | |
| } | |
| // Add any remaining nodes that were not bound to data to exit. | |
| for (i = 0; i < groupLength; ++i) { | |
| if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) { | |
| exit[i] = node; | |
| } | |
| } | |
| } | |
| var selection_data$1 = function(value, key) { | |
| if (!value) { | |
| data = new Array(this.size()), j = -1; | |
| this.each(function(d) { data[++j] = d; }); | |
| return data; | |
| } | |
| var bind = key ? bindKey$1 : bindIndex$1, | |
| parents = this._parents, | |
| groups = this._groups; | |
| if (typeof value !== "function") value = constant$4(value); | |
| for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) { | |
| var parent = parents[j], | |
| group = groups[j], | |
| groupLength = group.length, | |
| data = value.call(parent, parent && parent.__data__, j, parents), | |
| dataLength = data.length, | |
| enterGroup = enter[j] = new Array(dataLength), | |
| updateGroup = update[j] = new Array(dataLength), | |
| exitGroup = exit[j] = new Array(groupLength); | |
| bind(parent, group, enterGroup, updateGroup, exitGroup, data, key); | |
| // Now connect the enter nodes to their following update node, such that | |
| // appendChild can insert the materialized enter node before this node, | |
| // rather than at the end of the parent node. | |
| for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) { | |
| if (previous = enterGroup[i0]) { | |
| if (i0 >= i1) i1 = i0 + 1; | |
| while (!(next = updateGroup[i1]) && ++i1 < dataLength); | |
| previous._next = next || null; | |
| } | |
| } | |
| } | |
| update = new Selection$2(update, parents); | |
| update._enter = enter; | |
| update._exit = exit; | |
| return update; | |
| }; | |
| var selection_exit$1 = function() { | |
| return new Selection$2(this._exit || this._groups.map(sparse$1), this._parents); | |
| }; | |
| var selection_merge$1 = function(selection) { | |
| for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) { | |
| for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) { | |
| if (node = group0[i] || group1[i]) { | |
| merge[i] = node; | |
| } | |
| } | |
| } | |
| for (; j < m0; ++j) { | |
| merges[j] = groups0[j]; | |
| } | |
| return new Selection$2(merges, this._parents); | |
| }; | |
| var selection_order$1 = function() { | |
| for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) { | |
| for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) { | |
| if (node = group[i]) { | |
| if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next); | |
| next = node; | |
| } | |
| } | |
| } | |
| return this; | |
| }; | |
| var selection_sort$1 = function(compare) { | |
| if (!compare) compare = ascending$2; | |
| function compareNode(a, b) { | |
| return a && b ? compare(a.__data__, b.__data__) : !a - !b; | |
| } | |
| for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) { | |
| if (node = group[i]) { | |
| sortgroup[i] = node; | |
| } | |
| } | |
| sortgroup.sort(compareNode); | |
| } | |
| return new Selection$2(sortgroups, this._parents).order(); | |
| }; | |
| function ascending$2(a, b) { | |
| return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; | |
| } | |
| var selection_call$1 = function() { | |
| var callback = arguments[0]; | |
| arguments[0] = this; | |
| callback.apply(null, arguments); | |
| return this; | |
| }; | |
| var selection_nodes$1 = function() { | |
| var nodes = new Array(this.size()), i = -1; | |
| this.each(function() { nodes[++i] = this; }); | |
| return nodes; | |
| }; | |
| var selection_node$1 = function() { | |
| for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { | |
| for (var group = groups[j], i = 0, n = group.length; i < n; ++i) { | |
| var node = group[i]; | |
| if (node) return node; | |
| } | |
| } | |
| return null; | |
| }; | |
| var selection_size$1 = function() { | |
| var size = 0; | |
| this.each(function() { ++size; }); | |
| return size; | |
| }; | |
| var selection_empty$1 = function() { | |
| return !this.node(); | |
| }; | |
| var selection_each$1 = function(callback) { | |
| for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { | |
| for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) { | |
| if (node = group[i]) callback.call(node, node.__data__, i, group); | |
| } | |
| } | |
| return this; | |
| }; | |
| function attrRemove$2(name) { | |
| return function() { | |
| this.removeAttribute(name); | |
| }; | |
| } | |
| function attrRemoveNS$2(fullname) { | |
| return function() { | |
| this.removeAttributeNS(fullname.space, fullname.local); | |
| }; | |
| } | |
| function attrConstant$2(name, value) { | |
| return function() { | |
| this.setAttribute(name, value); | |
| }; | |
| } | |
| function attrConstantNS$2(fullname, value) { | |
| return function() { | |
| this.setAttributeNS(fullname.space, fullname.local, value); | |
| }; | |
| } | |
| function attrFunction$2(name, value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| if (v == null) this.removeAttribute(name); | |
| else this.setAttribute(name, v); | |
| }; | |
| } | |
| function attrFunctionNS$2(fullname, value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| if (v == null) this.removeAttributeNS(fullname.space, fullname.local); | |
| else this.setAttributeNS(fullname.space, fullname.local, v); | |
| }; | |
| } | |
| var selection_attr$1 = function(name, value) { | |
| var fullname = namespace$1(name); | |
| if (arguments.length < 2) { | |
| var node = this.node(); | |
| return fullname.local | |
| ? node.getAttributeNS(fullname.space, fullname.local) | |
| : node.getAttribute(fullname); | |
| } | |
| return this.each((value == null | |
| ? (fullname.local ? attrRemoveNS$2 : attrRemove$2) : (typeof value === "function" | |
| ? (fullname.local ? attrFunctionNS$2 : attrFunction$2) | |
| : (fullname.local ? attrConstantNS$2 : attrConstant$2)))(fullname, value)); | |
| }; | |
| var window$2 = function(node) { | |
| return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node | |
| || (node.document && node) // node is a Window | |
| || node.defaultView; // node is a Document | |
| }; | |
| function styleRemove$2(name) { | |
| return function() { | |
| this.style.removeProperty(name); | |
| }; | |
| } | |
| function styleConstant$2(name, value, priority) { | |
| return function() { | |
| this.style.setProperty(name, value, priority); | |
| }; | |
| } | |
| function styleFunction$2(name, value, priority) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| if (v == null) this.style.removeProperty(name); | |
| else this.style.setProperty(name, v, priority); | |
| }; | |
| } | |
| var selection_style$1 = function(name, value, priority) { | |
| var node; | |
| return arguments.length > 1 | |
| ? this.each((value == null | |
| ? styleRemove$2 : typeof value === "function" | |
| ? styleFunction$2 | |
| : styleConstant$2)(name, value, priority == null ? "" : priority)) | |
| : window$2(node = this.node()) | |
| .getComputedStyle(node, null) | |
| .getPropertyValue(name); | |
| }; | |
| function propertyRemove$1(name) { | |
| return function() { | |
| delete this[name]; | |
| }; | |
| } | |
| function propertyConstant$1(name, value) { | |
| return function() { | |
| this[name] = value; | |
| }; | |
| } | |
| function propertyFunction$1(name, value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| if (v == null) delete this[name]; | |
| else this[name] = v; | |
| }; | |
| } | |
| var selection_property$1 = function(name, value) { | |
| return arguments.length > 1 | |
| ? this.each((value == null | |
| ? propertyRemove$1 : typeof value === "function" | |
| ? propertyFunction$1 | |
| : propertyConstant$1)(name, value)) | |
| : this.node()[name]; | |
| }; | |
| function classArray$1(string) { | |
| return string.trim().split(/^|\s+/); | |
| } | |
| function classList$1(node) { | |
| return node.classList || new ClassList$1(node); | |
| } | |
| function ClassList$1(node) { | |
| this._node = node; | |
| this._names = classArray$1(node.getAttribute("class") || ""); | |
| } | |
| ClassList$1.prototype = { | |
| add: function(name) { | |
| var i = this._names.indexOf(name); | |
| if (i < 0) { | |
| this._names.push(name); | |
| this._node.setAttribute("class", this._names.join(" ")); | |
| } | |
| }, | |
| remove: function(name) { | |
| var i = this._names.indexOf(name); | |
| if (i >= 0) { | |
| this._names.splice(i, 1); | |
| this._node.setAttribute("class", this._names.join(" ")); | |
| } | |
| }, | |
| contains: function(name) { | |
| return this._names.indexOf(name) >= 0; | |
| } | |
| }; | |
| function classedAdd$1(node, names) { | |
| var list = classList$1(node), i = -1, n = names.length; | |
| while (++i < n) list.add(names[i]); | |
| } | |
| function classedRemove$1(node, names) { | |
| var list = classList$1(node), i = -1, n = names.length; | |
| while (++i < n) list.remove(names[i]); | |
| } | |
| function classedTrue$1(names) { | |
| return function() { | |
| classedAdd$1(this, names); | |
| }; | |
| } | |
| function classedFalse$1(names) { | |
| return function() { | |
| classedRemove$1(this, names); | |
| }; | |
| } | |
| function classedFunction$1(names, value) { | |
| return function() { | |
| (value.apply(this, arguments) ? classedAdd$1 : classedRemove$1)(this, names); | |
| }; | |
| } | |
| var selection_classed$1 = function(name, value) { | |
| var names = classArray$1(name + ""); | |
| if (arguments.length < 2) { | |
| var list = classList$1(this.node()), i = -1, n = names.length; | |
| while (++i < n) if (!list.contains(names[i])) return false; | |
| return true; | |
| } | |
| return this.each((typeof value === "function" | |
| ? classedFunction$1 : value | |
| ? classedTrue$1 | |
| : classedFalse$1)(names, value)); | |
| }; | |
| function textRemove$1() { | |
| this.textContent = ""; | |
| } | |
| function textConstant$2(value) { | |
| return function() { | |
| this.textContent = value; | |
| }; | |
| } | |
| function textFunction$2(value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| this.textContent = v == null ? "" : v; | |
| }; | |
| } | |
| var selection_text$1 = function(value) { | |
| return arguments.length | |
| ? this.each(value == null | |
| ? textRemove$1 : (typeof value === "function" | |
| ? textFunction$2 | |
| : textConstant$2)(value)) | |
| : this.node().textContent; | |
| }; | |
| function htmlRemove$1() { | |
| this.innerHTML = ""; | |
| } | |
| function htmlConstant$1(value) { | |
| return function() { | |
| this.innerHTML = value; | |
| }; | |
| } | |
| function htmlFunction$1(value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| this.innerHTML = v == null ? "" : v; | |
| }; | |
| } | |
| var selection_html$1 = function(value) { | |
| return arguments.length | |
| ? this.each(value == null | |
| ? htmlRemove$1 : (typeof value === "function" | |
| ? htmlFunction$1 | |
| : htmlConstant$1)(value)) | |
| : this.node().innerHTML; | |
| }; | |
| function raise$2() { | |
| if (this.nextSibling) this.parentNode.appendChild(this); | |
| } | |
| var selection_raise$1 = function() { | |
| return this.each(raise$2); | |
| }; | |
| function lower$1() { | |
| if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild); | |
| } | |
| var selection_lower$1 = function() { | |
| return this.each(lower$1); | |
| }; | |
| var selection_append$1 = function(name) { | |
| var create = typeof name === "function" ? name : creator$1(name); | |
| return this.select(function() { | |
| return this.appendChild(create.apply(this, arguments)); | |
| }); | |
| }; | |
| function constantNull$1() { | |
| return null; | |
| } | |
| var selection_insert$1 = function(name, before) { | |
| var create = typeof name === "function" ? name : creator$1(name), | |
| select = before == null ? constantNull$1 : typeof before === "function" ? before : selector$1(before); | |
| return this.select(function() { | |
| return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null); | |
| }); | |
| }; | |
| function remove$1() { | |
| var parent = this.parentNode; | |
| if (parent) parent.removeChild(this); | |
| } | |
| var selection_remove$1 = function() { | |
| return this.each(remove$1); | |
| }; | |
| var selection_datum$1 = function(value) { | |
| return arguments.length | |
| ? this.property("__data__", value) | |
| : this.node().__data__; | |
| }; | |
| function dispatchEvent$1(node, type, params) { | |
| var window = window$2(node), | |
| event = window.CustomEvent; | |
| if (event) { | |
| event = new event(type, params); | |
| } else { | |
| event = window.document.createEvent("Event"); | |
| if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail; | |
| else event.initEvent(type, false, false); | |
| } | |
| node.dispatchEvent(event); | |
| } | |
| function dispatchConstant$1(type, params) { | |
| return function() { | |
| return dispatchEvent$1(this, type, params); | |
| }; | |
| } | |
| function dispatchFunction$1(type, params) { | |
| return function() { | |
| return dispatchEvent$1(this, type, params.apply(this, arguments)); | |
| }; | |
| } | |
| var selection_dispatch$1 = function(type, params) { | |
| return this.each((typeof params === "function" | |
| ? dispatchFunction$1 | |
| : dispatchConstant$1)(type, params)); | |
| }; | |
| var root$2 = [null]; | |
| function Selection$2(groups, parents) { | |
| this._groups = groups; | |
| this._parents = parents; | |
| } | |
| function selection$2() { | |
| return new Selection$2([[document.documentElement]], root$2); | |
| } | |
| Selection$2.prototype = selection$2.prototype = { | |
| constructor: Selection$2, | |
| select: selection_select$1, | |
| selectAll: selection_selectAll$1, | |
| filter: selection_filter$1, | |
| data: selection_data$1, | |
| enter: selection_enter$1, | |
| exit: selection_exit$1, | |
| merge: selection_merge$1, | |
| order: selection_order$1, | |
| sort: selection_sort$1, | |
| call: selection_call$1, | |
| nodes: selection_nodes$1, | |
| node: selection_node$1, | |
| size: selection_size$1, | |
| empty: selection_empty$1, | |
| each: selection_each$1, | |
| attr: selection_attr$1, | |
| style: selection_style$1, | |
| property: selection_property$1, | |
| classed: selection_classed$1, | |
| text: selection_text$1, | |
| html: selection_html$1, | |
| raise: selection_raise$1, | |
| lower: selection_lower$1, | |
| append: selection_append$1, | |
| insert: selection_insert$1, | |
| remove: selection_remove$1, | |
| datum: selection_datum$1, | |
| on: selection_on$1, | |
| dispatch: selection_dispatch$1 | |
| }; | |
| var select$1 = function(selector) { | |
| return typeof selector === "string" | |
| ? new Selection$2([[document.querySelector(selector)]], [document.documentElement]) | |
| : new Selection$2([[selector]], root$2); | |
| }; | |
| var touch$1 = function(node, touches, identifier) { | |
| if (arguments.length < 3) identifier = touches, touches = sourceEvent$1().changedTouches; | |
| for (var i = 0, n = touches ? touches.length : 0, touch; i < n; ++i) { | |
| if ((touch = touches[i]).identifier === identifier) { | |
| return point$2(node, touch); | |
| } | |
| } | |
| return null; | |
| }; | |
| var noop$1 = {value: function() {}}; | |
| function dispatch$2() { | |
| for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) { | |
| if (!(t = arguments[i] + "") || (t in _)) throw new Error("illegal type: " + t); | |
| _[t] = []; | |
| } | |
| return new Dispatch$1(_); | |
| } | |
| function Dispatch$1(_) { | |
| this._ = _; | |
| } | |
| function parseTypenames$3(typenames, types) { | |
| return typenames.trim().split(/^|\s+/).map(function(t) { | |
| var name = "", i = t.indexOf("."); | |
| if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i); | |
| if (t && !types.hasOwnProperty(t)) throw new Error("unknown type: " + t); | |
| return {type: t, name: name}; | |
| }); | |
| } | |
| Dispatch$1.prototype = dispatch$2.prototype = { | |
| constructor: Dispatch$1, | |
| on: function(typename, callback) { | |
| var _ = this._, | |
| T = parseTypenames$3(typename + "", _), | |
| t, | |
| i = -1, | |
| n = T.length; | |
| // If no callback was specified, return the callback of the given type and name. | |
| if (arguments.length < 2) { | |
| while (++i < n) if ((t = (typename = T[i]).type) && (t = get$3(_[t], typename.name))) return t; | |
| return; | |
| } | |
| // If a type was specified, set the callback for the given type and name. | |
| // Otherwise, if a null callback was specified, remove callbacks of the given name. | |
| if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback); | |
| while (++i < n) { | |
| if (t = (typename = T[i]).type) _[t] = set$5(_[t], typename.name, callback); | |
| else if (callback == null) for (t in _) _[t] = set$5(_[t], typename.name, null); | |
| } | |
| return this; | |
| }, | |
| copy: function() { | |
| var copy = {}, _ = this._; | |
| for (var t in _) copy[t] = _[t].slice(); | |
| return new Dispatch$1(copy); | |
| }, | |
| call: function(type, that) { | |
| if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2]; | |
| if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type); | |
| for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args); | |
| }, | |
| apply: function(type, that, args) { | |
| if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type); | |
| for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args); | |
| } | |
| }; | |
| function get$3(type, name) { | |
| for (var i = 0, n = type.length, c; i < n; ++i) { | |
| if ((c = type[i]).name === name) { | |
| return c.value; | |
| } | |
| } | |
| } | |
| function set$5(type, name, callback) { | |
| for (var i = 0, n = type.length; i < n; ++i) { | |
| if (type[i].name === name) { | |
| type[i] = noop$1, type = type.slice(0, i).concat(type.slice(i + 1)); | |
| break; | |
| } | |
| } | |
| if (callback != null) type.push({name: name, value: callback}); | |
| return type; | |
| } | |
| var frame$1 = 0; | |
| var timeout$2 = 0; | |
| var interval$2 = 0; | |
| var pokeDelay$1 = 1000; | |
| var taskHead$1; | |
| var taskTail$1; | |
| var clockLast$1 = 0; | |
| var clockNow$1 = 0; | |
| var clockSkew$1 = 0; | |
| var clock$1 = typeof performance === "object" && performance.now ? performance : Date; | |
| var setFrame$1 = typeof requestAnimationFrame === "function" ? requestAnimationFrame : function(f) { setTimeout(f, 17); }; | |
| function now$1() { | |
| return clockNow$1 || (setFrame$1(clearNow$1), clockNow$1 = clock$1.now() + clockSkew$1); | |
| } | |
| function clearNow$1() { | |
| clockNow$1 = 0; | |
| } | |
| function Timer$1() { | |
| this._call = | |
| this._time = | |
| this._next = null; | |
| } | |
| Timer$1.prototype = timer$1.prototype = { | |
| constructor: Timer$1, | |
| restart: function(callback, delay, time) { | |
| if (typeof callback !== "function") throw new TypeError("callback is not a function"); | |
| time = (time == null ? now$1() : +time) + (delay == null ? 0 : +delay); | |
| if (!this._next && taskTail$1 !== this) { | |
| if (taskTail$1) taskTail$1._next = this; | |
| else taskHead$1 = this; | |
| taskTail$1 = this; | |
| } | |
| this._call = callback; | |
| this._time = time; | |
| sleep$1(); | |
| }, | |
| stop: function() { | |
| if (this._call) { | |
| this._call = null; | |
| this._time = Infinity; | |
| sleep$1(); | |
| } | |
| } | |
| }; | |
| function timer$1(callback, delay, time) { | |
| var t = new Timer$1; | |
| t.restart(callback, delay, time); | |
| return t; | |
| } | |
| function timerFlush$1() { | |
| now$1(); // Get the current time, if not already set. | |
| ++frame$1; // Pretend we’ve set an alarm, if we haven’t already. | |
| var t = taskHead$1, e; | |
| while (t) { | |
| if ((e = clockNow$1 - t._time) >= 0) t._call.call(null, e); | |
| t = t._next; | |
| } | |
| --frame$1; | |
| } | |
| function wake$1() { | |
| clockNow$1 = (clockLast$1 = clock$1.now()) + clockSkew$1; | |
| frame$1 = timeout$2 = 0; | |
| try { | |
| timerFlush$1(); | |
| } finally { | |
| frame$1 = 0; | |
| nap$1(); | |
| clockNow$1 = 0; | |
| } | |
| } | |
| function poke$1() { | |
| var now = clock$1.now(), delay = now - clockLast$1; | |
| if (delay > pokeDelay$1) clockSkew$1 -= delay, clockLast$1 = now; | |
| } | |
| function nap$1() { | |
| var t0, t1 = taskHead$1, t2, time = Infinity; | |
| while (t1) { | |
| if (t1._call) { | |
| if (time > t1._time) time = t1._time; | |
| t0 = t1, t1 = t1._next; | |
| } else { | |
| t2 = t1._next, t1._next = null; | |
| t1 = t0 ? t0._next = t2 : taskHead$1 = t2; | |
| } | |
| } | |
| taskTail$1 = t0; | |
| sleep$1(time); | |
| } | |
| function sleep$1(time) { | |
| if (frame$1) return; // Soonest alarm already set, or will be. | |
| if (timeout$2) timeout$2 = clearTimeout(timeout$2); | |
| var delay = time - clockNow$1; | |
| if (delay > 24) { | |
| if (time < Infinity) timeout$2 = setTimeout(wake$1, delay); | |
| if (interval$2) interval$2 = clearInterval(interval$2); | |
| } else { | |
| if (!interval$2) clockLast$1 = clockNow$1, interval$2 = setInterval(poke$1, pokeDelay$1); | |
| frame$1 = 1, setFrame$1(wake$1); | |
| } | |
| } | |
| var timeout$3 = function(callback, delay, time) { | |
| var t = new Timer$1; | |
| delay = delay == null ? 0 : +delay; | |
| t.restart(function(elapsed) { | |
| t.stop(); | |
| callback(elapsed + delay); | |
| }, delay, time); | |
| return t; | |
| }; | |
| var emptyOn$1 = dispatch$2("start", "end", "interrupt"); | |
| var emptyTween$1 = []; | |
| var CREATED$1 = 0; | |
| var SCHEDULED$1 = 1; | |
| var STARTING$1 = 2; | |
| var STARTED$1 = 3; | |
| var RUNNING$1 = 4; | |
| var ENDING$1 = 5; | |
| var ENDED$1 = 6; | |
| var schedule$1 = function(node, name, id, index, group, timing) { | |
| var schedules = node.__transition; | |
| if (!schedules) node.__transition = {}; | |
| else if (id in schedules) return; | |
| create$1(node, id, { | |
| name: name, | |
| index: index, // For context during callback. | |
| group: group, // For context during callback. | |
| on: emptyOn$1, | |
| tween: emptyTween$1, | |
| time: timing.time, | |
| delay: timing.delay, | |
| duration: timing.duration, | |
| ease: timing.ease, | |
| timer: null, | |
| state: CREATED$1 | |
| }); | |
| }; | |
| function init$1(node, id) { | |
| var schedule = node.__transition; | |
| if (!schedule || !(schedule = schedule[id]) || schedule.state > CREATED$1) throw new Error("too late"); | |
| return schedule; | |
| } | |
| function set$4(node, id) { | |
| var schedule = node.__transition; | |
| if (!schedule || !(schedule = schedule[id]) || schedule.state > STARTING$1) throw new Error("too late"); | |
| return schedule; | |
| } | |
| function get$2(node, id) { | |
| var schedule = node.__transition; | |
| if (!schedule || !(schedule = schedule[id])) throw new Error("too late"); | |
| return schedule; | |
| } | |
| function create$1(node, id, self) { | |
| var schedules = node.__transition, | |
| tween; | |
| // Initialize the self timer when the transition is created. | |
| // Note the actual delay is not known until the first callback! | |
| schedules[id] = self; | |
| self.timer = timer$1(schedule, 0, self.time); | |
| function schedule(elapsed) { | |
| self.state = SCHEDULED$1; | |
| self.timer.restart(start, self.delay, self.time); | |
| // If the elapsed delay is less than our first sleep, start immediately. | |
| if (self.delay <= elapsed) start(elapsed - self.delay); | |
| } | |
| function start(elapsed) { | |
| var i, j, n, o; | |
| // If the state is not SCHEDULED, then we previously errored on start. | |
| if (self.state !== SCHEDULED$1) return stop(); | |
| for (i in schedules) { | |
| o = schedules[i]; | |
| if (o.name !== self.name) continue; | |
| // While this element already has a starting transition during this frame, | |
| // defer starting an interrupting transition until that transition has a | |
| // chance to tick (and possibly end); see d3/d3-transition#54! | |
| if (o.state === STARTED$1) return timeout$3(start); | |
| // Interrupt the active transition, if any. | |
| // Dispatch the interrupt event. | |
| if (o.state === RUNNING$1) { | |
| o.state = ENDED$1; | |
| o.timer.stop(); | |
| o.on.call("interrupt", node, node.__data__, o.index, o.group); | |
| delete schedules[i]; | |
| } | |
| // Cancel any pre-empted transitions. No interrupt event is dispatched | |
| // because the cancelled transitions never started. Note that this also | |
| // removes this transition from the pending list! | |
| else if (+i < id) { | |
| o.state = ENDED$1; | |
| o.timer.stop(); | |
| delete schedules[i]; | |
| } | |
| } | |
| // Defer the first tick to end of the current frame; see d3/d3#1576. | |
| // Note the transition may be canceled after start and before the first tick! | |
| // Note this must be scheduled before the start event; see d3/d3-transition#16! | |
| // Assuming this is successful, subsequent callbacks go straight to tick. | |
| timeout$3(function() { | |
| if (self.state === STARTED$1) { | |
| self.state = RUNNING$1; | |
| self.timer.restart(tick, self.delay, self.time); | |
| tick(elapsed); | |
| } | |
| }); | |
| // Dispatch the start event. | |
| // Note this must be done before the tween are initialized. | |
| self.state = STARTING$1; | |
| self.on.call("start", node, node.__data__, self.index, self.group); | |
| if (self.state !== STARTING$1) return; // interrupted | |
| self.state = STARTED$1; | |
| // Initialize the tween, deleting null tween. | |
| tween = new Array(n = self.tween.length); | |
| for (i = 0, j = -1; i < n; ++i) { | |
| if (o = self.tween[i].value.call(node, node.__data__, self.index, self.group)) { | |
| tween[++j] = o; | |
| } | |
| } | |
| tween.length = j + 1; | |
| } | |
| function tick(elapsed) { | |
| var t = elapsed < self.duration ? self.ease.call(null, elapsed / self.duration) : (self.timer.restart(stop), self.state = ENDING$1, 1), | |
| i = -1, | |
| n = tween.length; | |
| while (++i < n) { | |
| tween[i].call(null, t); | |
| } | |
| // Dispatch the end event. | |
| if (self.state === ENDING$1) { | |
| self.on.call("end", node, node.__data__, self.index, self.group); | |
| stop(); | |
| } | |
| } | |
| function stop() { | |
| self.state = ENDED$1; | |
| self.timer.stop(); | |
| delete schedules[id]; | |
| for (var i in schedules) return; // eslint-disable-line no-unused-vars | |
| delete node.__transition; | |
| } | |
| } | |
| var interrupt$1 = function(node, name) { | |
| var schedules = node.__transition, | |
| schedule, | |
| active, | |
| empty = true, | |
| i; | |
| if (!schedules) return; | |
| name = name == null ? null : name + ""; | |
| for (i in schedules) { | |
| if ((schedule = schedules[i]).name !== name) { empty = false; continue; } | |
| active = schedule.state > STARTING$1 && schedule.state < ENDING$1; | |
| schedule.state = ENDED$1; | |
| schedule.timer.stop(); | |
| if (active) schedule.on.call("interrupt", node, node.__data__, schedule.index, schedule.group); | |
| delete schedules[i]; | |
| } | |
| if (empty) delete node.__transition; | |
| }; | |
| var selection_interrupt$1 = function(name) { | |
| return this.each(function() { | |
| interrupt$1(this, name); | |
| }); | |
| }; | |
| var define$1 = function(constructor, factory, prototype) { | |
| constructor.prototype = factory.prototype = prototype; | |
| prototype.constructor = constructor; | |
| }; | |
| function extend$1(parent, definition) { | |
| var prototype = Object.create(parent.prototype); | |
| for (var key in definition) prototype[key] = definition[key]; | |
| return prototype; | |
| } | |
| function Color$1() {} | |
| var darker$1 = 0.7; | |
| var brighter$1 = 1 / darker$1; | |
| var reI$1 = "\\s*([+-]?\\d+)\\s*"; | |
| var reN$1 = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*"; | |
| var reP$1 = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*"; | |
| var reHex3$1 = /^#([0-9a-f]{3})$/; | |
| var reHex6$1 = /^#([0-9a-f]{6})$/; | |
| var reRgbInteger$1 = new RegExp("^rgb\\(" + [reI$1, reI$1, reI$1] + "\\)$"); | |
| var reRgbPercent$1 = new RegExp("^rgb\\(" + [reP$1, reP$1, reP$1] + "\\)$"); | |
| var reRgbaInteger$1 = new RegExp("^rgba\\(" + [reI$1, reI$1, reI$1, reN$1] + "\\)$"); | |
| var reRgbaPercent$1 = new RegExp("^rgba\\(" + [reP$1, reP$1, reP$1, reN$1] + "\\)$"); | |
| var reHslPercent$1 = new RegExp("^hsl\\(" + [reN$1, reP$1, reP$1] + "\\)$"); | |
| var reHslaPercent$1 = new RegExp("^hsla\\(" + [reN$1, reP$1, reP$1, reN$1] + "\\)$"); | |
| var named$1 = { | |
| aliceblue: 0xf0f8ff, | |
| antiquewhite: 0xfaebd7, | |
| aqua: 0x00ffff, | |
| aquamarine: 0x7fffd4, | |
| azure: 0xf0ffff, | |
| beige: 0xf5f5dc, | |
| bisque: 0xffe4c4, | |
| black: 0x000000, | |
| blanchedalmond: 0xffebcd, | |
| blue: 0x0000ff, | |
| blueviolet: 0x8a2be2, | |
| brown: 0xa52a2a, | |
| burlywood: 0xdeb887, | |
| cadetblue: 0x5f9ea0, | |
| chartreuse: 0x7fff00, | |
| chocolate: 0xd2691e, | |
| coral: 0xff7f50, | |
| cornflowerblue: 0x6495ed, | |
| cornsilk: 0xfff8dc, | |
| crimson: 0xdc143c, | |
| cyan: 0x00ffff, | |
| darkblue: 0x00008b, | |
| darkcyan: 0x008b8b, | |
| darkgoldenrod: 0xb8860b, | |
| darkgray: 0xa9a9a9, | |
| darkgreen: 0x006400, | |
| darkgrey: 0xa9a9a9, | |
| darkkhaki: 0xbdb76b, | |
| darkmagenta: 0x8b008b, | |
| darkolivegreen: 0x556b2f, | |
| darkorange: 0xff8c00, | |
| darkorchid: 0x9932cc, | |
| darkred: 0x8b0000, | |
| darksalmon: 0xe9967a, | |
| darkseagreen: 0x8fbc8f, | |
| darkslateblue: 0x483d8b, | |
| darkslategray: 0x2f4f4f, | |
| darkslategrey: 0x2f4f4f, | |
| darkturquoise: 0x00ced1, | |
| darkviolet: 0x9400d3, | |
| deeppink: 0xff1493, | |
| deepskyblue: 0x00bfff, | |
| dimgray: 0x696969, | |
| dimgrey: 0x696969, | |
| dodgerblue: 0x1e90ff, | |
| firebrick: 0xb22222, | |
| floralwhite: 0xfffaf0, | |
| forestgreen: 0x228b22, | |
| fuchsia: 0xff00ff, | |
| gainsboro: 0xdcdcdc, | |
| ghostwhite: 0xf8f8ff, | |
| gold: 0xffd700, | |
| goldenrod: 0xdaa520, | |
| gray: 0x808080, | |
| green: 0x008000, | |
| greenyellow: 0xadff2f, | |
| grey: 0x808080, | |
| honeydew: 0xf0fff0, | |
| hotpink: 0xff69b4, | |
| indianred: 0xcd5c5c, | |
| indigo: 0x4b0082, | |
| ivory: 0xfffff0, | |
| khaki: 0xf0e68c, | |
| lavender: 0xe6e6fa, | |
| lavenderblush: 0xfff0f5, | |
| lawngreen: 0x7cfc00, | |
| lemonchiffon: 0xfffacd, | |
| lightblue: 0xadd8e6, | |
| lightcoral: 0xf08080, | |
| lightcyan: 0xe0ffff, | |
| lightgoldenrodyellow: 0xfafad2, | |
| lightgray: 0xd3d3d3, | |
| lightgreen: 0x90ee90, | |
| lightgrey: 0xd3d3d3, | |
| lightpink: 0xffb6c1, | |
| lightsalmon: 0xffa07a, | |
| lightseagreen: 0x20b2aa, | |
| lightskyblue: 0x87cefa, | |
| lightslategray: 0x778899, | |
| lightslategrey: 0x778899, | |
| lightsteelblue: 0xb0c4de, | |
| lightyellow: 0xffffe0, | |
| lime: 0x00ff00, | |
| limegreen: 0x32cd32, | |
| linen: 0xfaf0e6, | |
| magenta: 0xff00ff, | |
| maroon: 0x800000, | |
| mediumaquamarine: 0x66cdaa, | |
| mediumblue: 0x0000cd, | |
| mediumorchid: 0xba55d3, | |
| mediumpurple: 0x9370db, | |
| mediumseagreen: 0x3cb371, | |
| mediumslateblue: 0x7b68ee, | |
| mediumspringgreen: 0x00fa9a, | |
| mediumturquoise: 0x48d1cc, | |
| mediumvioletred: 0xc71585, | |
| midnightblue: 0x191970, | |
| mintcream: 0xf5fffa, | |
| mistyrose: 0xffe4e1, | |
| moccasin: 0xffe4b5, | |
| navajowhite: 0xffdead, | |
| navy: 0x000080, | |
| oldlace: 0xfdf5e6, | |
| olive: 0x808000, | |
| olivedrab: 0x6b8e23, | |
| orange: 0xffa500, | |
| orangered: 0xff4500, | |
| orchid: 0xda70d6, | |
| palegoldenrod: 0xeee8aa, | |
| palegreen: 0x98fb98, | |
| paleturquoise: 0xafeeee, | |
| palevioletred: 0xdb7093, | |
| papayawhip: 0xffefd5, | |
| peachpuff: 0xffdab9, | |
| peru: 0xcd853f, | |
| pink: 0xffc0cb, | |
| plum: 0xdda0dd, | |
| powderblue: 0xb0e0e6, | |
| purple: 0x800080, | |
| rebeccapurple: 0x663399, | |
| red: 0xff0000, | |
| rosybrown: 0xbc8f8f, | |
| royalblue: 0x4169e1, | |
| saddlebrown: 0x8b4513, | |
| salmon: 0xfa8072, | |
| sandybrown: 0xf4a460, | |
| seagreen: 0x2e8b57, | |
| seashell: 0xfff5ee, | |
| sienna: 0xa0522d, | |
| silver: 0xc0c0c0, | |
| skyblue: 0x87ceeb, | |
| slateblue: 0x6a5acd, | |
| slategray: 0x708090, | |
| slategrey: 0x708090, | |
| snow: 0xfffafa, | |
| springgreen: 0x00ff7f, | |
| steelblue: 0x4682b4, | |
| tan: 0xd2b48c, | |
| teal: 0x008080, | |
| thistle: 0xd8bfd8, | |
| tomato: 0xff6347, | |
| turquoise: 0x40e0d0, | |
| violet: 0xee82ee, | |
| wheat: 0xf5deb3, | |
| white: 0xffffff, | |
| whitesmoke: 0xf5f5f5, | |
| yellow: 0xffff00, | |
| yellowgreen: 0x9acd32 | |
| }; | |
| define$1(Color$1, color$1, { | |
| displayable: function() { | |
| return this.rgb().displayable(); | |
| }, | |
| toString: function() { | |
| return this.rgb() + ""; | |
| } | |
| }); | |
| function color$1(format) { | |
| var m; | |
| format = (format + "").trim().toLowerCase(); | |
| return (m = reHex3$1.exec(format)) ? (m = parseInt(m[1], 16), new Rgb$1((m >> 8 & 0xf) | (m >> 4 & 0x0f0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1)) // #f00 | |
| : (m = reHex6$1.exec(format)) ? rgbn$1(parseInt(m[1], 16)) // #ff0000 | |
| : (m = reRgbInteger$1.exec(format)) ? new Rgb$1(m[1], m[2], m[3], 1) // rgb(255, 0, 0) | |
| : (m = reRgbPercent$1.exec(format)) ? new Rgb$1(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%) | |
| : (m = reRgbaInteger$1.exec(format)) ? rgba$1(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1) | |
| : (m = reRgbaPercent$1.exec(format)) ? rgba$1(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1) | |
| : (m = reHslPercent$1.exec(format)) ? hsla$1(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%) | |
| : (m = reHslaPercent$1.exec(format)) ? hsla$1(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1) | |
| : named$1.hasOwnProperty(format) ? rgbn$1(named$1[format]) | |
| : format === "transparent" ? new Rgb$1(NaN, NaN, NaN, 0) | |
| : null; | |
| } | |
| function rgbn$1(n) { | |
| return new Rgb$1(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1); | |
| } | |
| function rgba$1(r, g, b, a) { | |
| if (a <= 0) r = g = b = NaN; | |
| return new Rgb$1(r, g, b, a); | |
| } | |
| function rgbConvert$1(o) { | |
| if (!(o instanceof Color$1)) o = color$1(o); | |
| if (!o) return new Rgb$1; | |
| o = o.rgb(); | |
| return new Rgb$1(o.r, o.g, o.b, o.opacity); | |
| } | |
| function rgb$1(r, g, b, opacity) { | |
| return arguments.length === 1 ? rgbConvert$1(r) : new Rgb$1(r, g, b, opacity == null ? 1 : opacity); | |
| } | |
| function Rgb$1(r, g, b, opacity) { | |
| this.r = +r; | |
| this.g = +g; | |
| this.b = +b; | |
| this.opacity = +opacity; | |
| } | |
| define$1(Rgb$1, rgb$1, extend$1(Color$1, { | |
| brighter: function(k) { | |
| k = k == null ? brighter$1 : Math.pow(brighter$1, k); | |
| return new Rgb$1(this.r * k, this.g * k, this.b * k, this.opacity); | |
| }, | |
| darker: function(k) { | |
| k = k == null ? darker$1 : Math.pow(darker$1, k); | |
| return new Rgb$1(this.r * k, this.g * k, this.b * k, this.opacity); | |
| }, | |
| rgb: function() { | |
| return this; | |
| }, | |
| displayable: function() { | |
| return (0 <= this.r && this.r <= 255) | |
| && (0 <= this.g && this.g <= 255) | |
| && (0 <= this.b && this.b <= 255) | |
| && (0 <= this.opacity && this.opacity <= 1); | |
| }, | |
| toString: function() { | |
| var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a)); | |
| return (a === 1 ? "rgb(" : "rgba(") | |
| + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", " | |
| + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", " | |
| + Math.max(0, Math.min(255, Math.round(this.b) || 0)) | |
| + (a === 1 ? ")" : ", " + a + ")"); | |
| } | |
| })); | |
| function hsla$1(h, s, l, a) { | |
| if (a <= 0) h = s = l = NaN; | |
| else if (l <= 0 || l >= 1) h = s = NaN; | |
| else if (s <= 0) h = NaN; | |
| return new Hsl$1(h, s, l, a); | |
| } | |
| function hslConvert$1(o) { | |
| if (o instanceof Hsl$1) return new Hsl$1(o.h, o.s, o.l, o.opacity); | |
| if (!(o instanceof Color$1)) o = color$1(o); | |
| if (!o) return new Hsl$1; | |
| if (o instanceof Hsl$1) return o; | |
| o = o.rgb(); | |
| var r = o.r / 255, | |
| g = o.g / 255, | |
| b = o.b / 255, | |
| min = Math.min(r, g, b), | |
| max = Math.max(r, g, b), | |
| h = NaN, | |
| s = max - min, | |
| l = (max + min) / 2; | |
| if (s) { | |
| if (r === max) h = (g - b) / s + (g < b) * 6; | |
| else if (g === max) h = (b - r) / s + 2; | |
| else h = (r - g) / s + 4; | |
| s /= l < 0.5 ? max + min : 2 - max - min; | |
| h *= 60; | |
| } else { | |
| s = l > 0 && l < 1 ? 0 : h; | |
| } | |
| return new Hsl$1(h, s, l, o.opacity); | |
| } | |
| function hsl$3(h, s, l, opacity) { | |
| return arguments.length === 1 ? hslConvert$1(h) : new Hsl$1(h, s, l, opacity == null ? 1 : opacity); | |
| } | |
| function Hsl$1(h, s, l, opacity) { | |
| this.h = +h; | |
| this.s = +s; | |
| this.l = +l; | |
| this.opacity = +opacity; | |
| } | |
| define$1(Hsl$1, hsl$3, extend$1(Color$1, { | |
| brighter: function(k) { | |
| k = k == null ? brighter$1 : Math.pow(brighter$1, k); | |
| return new Hsl$1(this.h, this.s, this.l * k, this.opacity); | |
| }, | |
| darker: function(k) { | |
| k = k == null ? darker$1 : Math.pow(darker$1, k); | |
| return new Hsl$1(this.h, this.s, this.l * k, this.opacity); | |
| }, | |
| rgb: function() { | |
| var h = this.h % 360 + (this.h < 0) * 360, | |
| s = isNaN(h) || isNaN(this.s) ? 0 : this.s, | |
| l = this.l, | |
| m2 = l + (l < 0.5 ? l : 1 - l) * s, | |
| m1 = 2 * l - m2; | |
| return new Rgb$1( | |
| hsl2rgb$1(h >= 240 ? h - 240 : h + 120, m1, m2), | |
| hsl2rgb$1(h, m1, m2), | |
| hsl2rgb$1(h < 120 ? h + 240 : h - 120, m1, m2), | |
| this.opacity | |
| ); | |
| }, | |
| displayable: function() { | |
| return (0 <= this.s && this.s <= 1 || isNaN(this.s)) | |
| && (0 <= this.l && this.l <= 1) | |
| && (0 <= this.opacity && this.opacity <= 1); | |
| } | |
| })); | |
| /* From FvD 13.37, CSS Color Module Level 3 */ | |
| function hsl2rgb$1(h, m1, m2) { | |
| return (h < 60 ? m1 + (m2 - m1) * h / 60 | |
| : h < 180 ? m2 | |
| : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60 | |
| : m1) * 255; | |
| } | |
| var deg2rad$1 = Math.PI / 180; | |
| var rad2deg$1 = 180 / Math.PI; | |
| var Kn$1 = 18; | |
| var Xn$1 = 0.950470; | |
| var Yn$1 = 1; | |
| var Zn$1 = 1.088830; | |
| var t0$2 = 4 / 29; | |
| var t1$2 = 6 / 29; | |
| var t2$1 = 3 * t1$2 * t1$2; | |
| var t3$1 = t1$2 * t1$2 * t1$2; | |
| function labConvert$1(o) { | |
| if (o instanceof Lab$1) return new Lab$1(o.l, o.a, o.b, o.opacity); | |
| if (o instanceof Hcl$1) { | |
| var h = o.h * deg2rad$1; | |
| return new Lab$1(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity); | |
| } | |
| if (!(o instanceof Rgb$1)) o = rgbConvert$1(o); | |
| var b = rgb2xyz$1(o.r), | |
| a = rgb2xyz$1(o.g), | |
| l = rgb2xyz$1(o.b), | |
| x = xyz2lab$1((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn$1), | |
| y = xyz2lab$1((0.2126729 * b + 0.7151522 * a + 0.0721750 * l) / Yn$1), | |
| z = xyz2lab$1((0.0193339 * b + 0.1191920 * a + 0.9503041 * l) / Zn$1); | |
| return new Lab$1(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity); | |
| } | |
| function lab$2(l, a, b, opacity) { | |
| return arguments.length === 1 ? labConvert$1(l) : new Lab$1(l, a, b, opacity == null ? 1 : opacity); | |
| } | |
| function Lab$1(l, a, b, opacity) { | |
| this.l = +l; | |
| this.a = +a; | |
| this.b = +b; | |
| this.opacity = +opacity; | |
| } | |
| define$1(Lab$1, lab$2, extend$1(Color$1, { | |
| brighter: function(k) { | |
| return new Lab$1(this.l + Kn$1 * (k == null ? 1 : k), this.a, this.b, this.opacity); | |
| }, | |
| darker: function(k) { | |
| return new Lab$1(this.l - Kn$1 * (k == null ? 1 : k), this.a, this.b, this.opacity); | |
| }, | |
| rgb: function() { | |
| var y = (this.l + 16) / 116, | |
| x = isNaN(this.a) ? y : y + this.a / 500, | |
| z = isNaN(this.b) ? y : y - this.b / 200; | |
| y = Yn$1 * lab2xyz$1(y); | |
| x = Xn$1 * lab2xyz$1(x); | |
| z = Zn$1 * lab2xyz$1(z); | |
| return new Rgb$1( | |
| xyz2rgb$1( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB | |
| xyz2rgb$1(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z), | |
| xyz2rgb$1( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z), | |
| this.opacity | |
| ); | |
| } | |
| })); | |
| function xyz2lab$1(t) { | |
| return t > t3$1 ? Math.pow(t, 1 / 3) : t / t2$1 + t0$2; | |
| } | |
| function lab2xyz$1(t) { | |
| return t > t1$2 ? t * t * t : t2$1 * (t - t0$2); | |
| } | |
| function xyz2rgb$1(x) { | |
| return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055); | |
| } | |
| function rgb2xyz$1(x) { | |
| return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4); | |
| } | |
| function hclConvert$1(o) { | |
| if (o instanceof Hcl$1) return new Hcl$1(o.h, o.c, o.l, o.opacity); | |
| if (!(o instanceof Lab$1)) o = labConvert$1(o); | |
| var h = Math.atan2(o.b, o.a) * rad2deg$1; | |
| return new Hcl$1(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity); | |
| } | |
| function hcl$3(h, c, l, opacity) { | |
| return arguments.length === 1 ? hclConvert$1(h) : new Hcl$1(h, c, l, opacity == null ? 1 : opacity); | |
| } | |
| function Hcl$1(h, c, l, opacity) { | |
| this.h = +h; | |
| this.c = +c; | |
| this.l = +l; | |
| this.opacity = +opacity; | |
| } | |
| define$1(Hcl$1, hcl$3, extend$1(Color$1, { | |
| brighter: function(k) { | |
| return new Hcl$1(this.h, this.c, this.l + Kn$1 * (k == null ? 1 : k), this.opacity); | |
| }, | |
| darker: function(k) { | |
| return new Hcl$1(this.h, this.c, this.l - Kn$1 * (k == null ? 1 : k), this.opacity); | |
| }, | |
| rgb: function() { | |
| return labConvert$1(this).rgb(); | |
| } | |
| })); | |
| var A$1 = -0.14861; | |
| var B$1 = +1.78277; | |
| var C$1 = -0.29227; | |
| var D$1 = -0.90649; | |
| var E$1 = +1.97294; | |
| var ED$1 = E$1 * D$1; | |
| var EB$1 = E$1 * B$1; | |
| var BC_DA$1 = B$1 * C$1 - D$1 * A$1; | |
| function cubehelixConvert$1(o) { | |
| if (o instanceof Cubehelix$1) return new Cubehelix$1(o.h, o.s, o.l, o.opacity); | |
| if (!(o instanceof Rgb$1)) o = rgbConvert$1(o); | |
| var r = o.r / 255, | |
| g = o.g / 255, | |
| b = o.b / 255, | |
| l = (BC_DA$1 * b + ED$1 * r - EB$1 * g) / (BC_DA$1 + ED$1 - EB$1), | |
| bl = b - l, | |
| k = (E$1 * (g - l) - C$1 * bl) / D$1, | |
| s = Math.sqrt(k * k + bl * bl) / (E$1 * l * (1 - l)), // NaN if l=0 or l=1 | |
| h = s ? Math.atan2(k, bl) * rad2deg$1 - 120 : NaN; | |
| return new Cubehelix$1(h < 0 ? h + 360 : h, s, l, o.opacity); | |
| } | |
| function cubehelix$4(h, s, l, opacity) { | |
| return arguments.length === 1 ? cubehelixConvert$1(h) : new Cubehelix$1(h, s, l, opacity == null ? 1 : opacity); | |
| } | |
| function Cubehelix$1(h, s, l, opacity) { | |
| this.h = +h; | |
| this.s = +s; | |
| this.l = +l; | |
| this.opacity = +opacity; | |
| } | |
| define$1(Cubehelix$1, cubehelix$4, extend$1(Color$1, { | |
| brighter: function(k) { | |
| k = k == null ? brighter$1 : Math.pow(brighter$1, k); | |
| return new Cubehelix$1(this.h, this.s, this.l * k, this.opacity); | |
| }, | |
| darker: function(k) { | |
| k = k == null ? darker$1 : Math.pow(darker$1, k); | |
| return new Cubehelix$1(this.h, this.s, this.l * k, this.opacity); | |
| }, | |
| rgb: function() { | |
| var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad$1, | |
| l = +this.l, | |
| a = isNaN(this.s) ? 0 : this.s * l * (1 - l), | |
| cosh = Math.cos(h), | |
| sinh = Math.sin(h); | |
| return new Rgb$1( | |
| 255 * (l + a * (A$1 * cosh + B$1 * sinh)), | |
| 255 * (l + a * (C$1 * cosh + D$1 * sinh)), | |
| 255 * (l + a * (E$1 * cosh)), | |
| this.opacity | |
| ); | |
| } | |
| })); | |
| function basis$2(t1, v0, v1, v2, v3) { | |
| var t2 = t1 * t1, t3 = t2 * t1; | |
| return ((1 - 3 * t1 + 3 * t2 - t3) * v0 | |
| + (4 - 6 * t2 + 3 * t3) * v1 | |
| + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2 | |
| + t3 * v3) / 6; | |
| } | |
| var constant$5 = function(x) { | |
| return function() { | |
| return x; | |
| }; | |
| }; | |
| function linear$3(a, d) { | |
| return function(t) { | |
| return a + t * d; | |
| }; | |
| } | |
| function exponential$2(a, b, y) { | |
| return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) { | |
| return Math.pow(a + t * b, y); | |
| }; | |
| } | |
| function hue$1(a, b) { | |
| var d = b - a; | |
| return d ? linear$3(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant$5(isNaN(a) ? b : a); | |
| } | |
| function gamma$1(y) { | |
| return (y = +y) === 1 ? nogamma$1 : function(a, b) { | |
| return b - a ? exponential$2(a, b, y) : constant$5(isNaN(a) ? b : a); | |
| }; | |
| } | |
| function nogamma$1(a, b) { | |
| var d = b - a; | |
| return d ? linear$3(a, d) : constant$5(isNaN(a) ? b : a); | |
| } | |
| var interpolateRgb$1 = ((function rgbGamma(y) { | |
| var color$$1 = gamma$1(y); | |
| function rgb$$1(start, end) { | |
| var r = color$$1((start = rgb$1(start)).r, (end = rgb$1(end)).r), | |
| g = color$$1(start.g, end.g), | |
| b = color$$1(start.b, end.b), | |
| opacity = nogamma$1(start.opacity, end.opacity); | |
| return function(t) { | |
| start.r = r(t); | |
| start.g = g(t); | |
| start.b = b(t); | |
| start.opacity = opacity(t); | |
| return start + ""; | |
| }; | |
| } | |
| rgb$$1.gamma = rgbGamma; | |
| return rgb$$1; | |
| }))(1); | |
| var interpolateNumber = function(a, b) { | |
| return a = +a, b -= a, function(t) { | |
| return a + b * t; | |
| }; | |
| }; | |
| var reA$1 = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g; | |
| var reB$1 = new RegExp(reA$1.source, "g"); | |
| function zero$1(b) { | |
| return function() { | |
| return b; | |
| }; | |
| } | |
| function one$1(b) { | |
| return function(t) { | |
| return b(t) + ""; | |
| }; | |
| } | |
| var interpolateString$1 = function(a, b) { | |
| var bi = reA$1.lastIndex = reB$1.lastIndex = 0, // scan index for next number in b | |
| am, // current match in a | |
| bm, // current match in b | |
| bs, // string preceding current number in b, if any | |
| i = -1, // index in s | |
| s = [], // string constants and placeholders | |
| q = []; // number interpolators | |
| // Coerce inputs to strings. | |
| a = a + "", b = b + ""; | |
| // Interpolate pairs of numbers in a & b. | |
| while ((am = reA$1.exec(a)) | |
| && (bm = reB$1.exec(b))) { | |
| if ((bs = bm.index) > bi) { // a string precedes the next number in b | |
| bs = b.slice(bi, bs); | |
| if (s[i]) s[i] += bs; // coalesce with previous string | |
| else s[++i] = bs; | |
| } | |
| if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match | |
| if (s[i]) s[i] += bm; // coalesce with previous string | |
| else s[++i] = bm; | |
| } else { // interpolate non-matching numbers | |
| s[++i] = null; | |
| q.push({i: i, x: interpolateNumber(am, bm)}); | |
| } | |
| bi = reB$1.lastIndex; | |
| } | |
| // Add remains of b. | |
| if (bi < b.length) { | |
| bs = b.slice(bi); | |
| if (s[i]) s[i] += bs; // coalesce with previous string | |
| else s[++i] = bs; | |
| } | |
| // Special optimization for only a single match. | |
| // Otherwise, interpolate each of the numbers and rejoin the string. | |
| return s.length < 2 ? (q[0] | |
| ? one$1(q[0].x) | |
| : zero$1(b)) | |
| : (b = q.length, function(t) { | |
| for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t); | |
| return s.join(""); | |
| }); | |
| }; | |
| var degrees$1 = 180 / Math.PI; | |
| var identity$5 = { | |
| translateX: 0, | |
| translateY: 0, | |
| rotate: 0, | |
| skewX: 0, | |
| scaleX: 1, | |
| scaleY: 1 | |
| }; | |
| var decompose$1 = function(a, b, c, d, e, f) { | |
| var scaleX, scaleY, skewX; | |
| if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX; | |
| if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX; | |
| if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY; | |
| if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX; | |
| return { | |
| translateX: e, | |
| translateY: f, | |
| rotate: Math.atan2(b, a) * degrees$1, | |
| skewX: Math.atan(skewX) * degrees$1, | |
| scaleX: scaleX, | |
| scaleY: scaleY | |
| }; | |
| }; | |
| var cssNode$1; | |
| var cssRoot$1; | |
| var cssView$1; | |
| var svgNode$1; | |
| function parseCss$1(value) { | |
| if (value === "none") return identity$5; | |
| if (!cssNode$1) cssNode$1 = document.createElement("DIV"), cssRoot$1 = document.documentElement, cssView$1 = document.defaultView; | |
| cssNode$1.style.transform = value; | |
| value = cssView$1.getComputedStyle(cssRoot$1.appendChild(cssNode$1), null).getPropertyValue("transform"); | |
| cssRoot$1.removeChild(cssNode$1); | |
| value = value.slice(7, -1).split(","); | |
| return decompose$1(+value[0], +value[1], +value[2], +value[3], +value[4], +value[5]); | |
| } | |
| function parseSvg$1(value) { | |
| if (value == null) return identity$5; | |
| if (!svgNode$1) svgNode$1 = document.createElementNS("http://www.w3.org/2000/svg", "g"); | |
| svgNode$1.setAttribute("transform", value); | |
| if (!(value = svgNode$1.transform.baseVal.consolidate())) return identity$5; | |
| value = value.matrix; | |
| return decompose$1(value.a, value.b, value.c, value.d, value.e, value.f); | |
| } | |
| function interpolateTransform$1(parse, pxComma, pxParen, degParen) { | |
| function pop(s) { | |
| return s.length ? s.pop() + " " : ""; | |
| } | |
| function translate(xa, ya, xb, yb, s, q) { | |
| if (xa !== xb || ya !== yb) { | |
| var i = s.push("translate(", null, pxComma, null, pxParen); | |
| q.push({i: i - 4, x: interpolateNumber(xa, xb)}, {i: i - 2, x: interpolateNumber(ya, yb)}); | |
| } else if (xb || yb) { | |
| s.push("translate(" + xb + pxComma + yb + pxParen); | |
| } | |
| } | |
| function rotate(a, b, s, q) { | |
| if (a !== b) { | |
| if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path | |
| q.push({i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: interpolateNumber(a, b)}); | |
| } else if (b) { | |
| s.push(pop(s) + "rotate(" + b + degParen); | |
| } | |
| } | |
| function skewX(a, b, s, q) { | |
| if (a !== b) { | |
| q.push({i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: interpolateNumber(a, b)}); | |
| } else if (b) { | |
| s.push(pop(s) + "skewX(" + b + degParen); | |
| } | |
| } | |
| function scale(xa, ya, xb, yb, s, q) { | |
| if (xa !== xb || ya !== yb) { | |
| var i = s.push(pop(s) + "scale(", null, ",", null, ")"); | |
| q.push({i: i - 4, x: interpolateNumber(xa, xb)}, {i: i - 2, x: interpolateNumber(ya, yb)}); | |
| } else if (xb !== 1 || yb !== 1) { | |
| s.push(pop(s) + "scale(" + xb + "," + yb + ")"); | |
| } | |
| } | |
| return function(a, b) { | |
| var s = [], // string constants and placeholders | |
| q = []; // number interpolators | |
| a = parse(a), b = parse(b); | |
| translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q); | |
| rotate(a.rotate, b.rotate, s, q); | |
| skewX(a.skewX, b.skewX, s, q); | |
| scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q); | |
| a = b = null; // gc | |
| return function(t) { | |
| var i = -1, n = q.length, o; | |
| while (++i < n) s[(o = q[i]).i] = o.x(t); | |
| return s.join(""); | |
| }; | |
| }; | |
| } | |
| var interpolateTransformCss$1 = interpolateTransform$1(parseCss$1, "px, ", "px)", "deg)"); | |
| var interpolateTransformSvg$1 = interpolateTransform$1(parseSvg$1, ", ", ")", ")"); | |
| // p0 = [ux0, uy0, w0] | |
| // p1 = [ux1, uy1, w1] | |
| function cubehelix$5(hue$$1) { | |
| return (function cubehelixGamma(y) { | |
| y = +y; | |
| function cubehelix$$1(start, end) { | |
| var h = hue$$1((start = cubehelix$4(start)).h, (end = cubehelix$4(end)).h), | |
| s = nogamma$1(start.s, end.s), | |
| l = nogamma$1(start.l, end.l), | |
| opacity = nogamma$1(start.opacity, end.opacity); | |
| return function(t) { | |
| start.h = h(t); | |
| start.s = s(t); | |
| start.l = l(Math.pow(t, y)); | |
| start.opacity = opacity(t); | |
| return start + ""; | |
| }; | |
| } | |
| cubehelix$$1.gamma = cubehelixGamma; | |
| return cubehelix$$1; | |
| })(1); | |
| } | |
| cubehelix$5(hue$1); | |
| var cubehelixLong$1 = cubehelix$5(nogamma$1); | |
| function tweenRemove$1(id, name) { | |
| var tween0, tween1; | |
| return function() { | |
| var schedule = set$4(this, id), | |
| tween = schedule.tween; | |
| // If this node shared tween with the previous node, | |
| // just assign the updated shared tween and we’re done! | |
| // Otherwise, copy-on-write. | |
| if (tween !== tween0) { | |
| tween1 = tween0 = tween; | |
| for (var i = 0, n = tween1.length; i < n; ++i) { | |
| if (tween1[i].name === name) { | |
| tween1 = tween1.slice(); | |
| tween1.splice(i, 1); | |
| break; | |
| } | |
| } | |
| } | |
| schedule.tween = tween1; | |
| }; | |
| } | |
| function tweenFunction$1(id, name, value) { | |
| var tween0, tween1; | |
| if (typeof value !== "function") throw new Error; | |
| return function() { | |
| var schedule = set$4(this, id), | |
| tween = schedule.tween; | |
| // If this node shared tween with the previous node, | |
| // just assign the updated shared tween and we’re done! | |
| // Otherwise, copy-on-write. | |
| if (tween !== tween0) { | |
| tween1 = (tween0 = tween).slice(); | |
| for (var t = {name: name, value: value}, i = 0, n = tween1.length; i < n; ++i) { | |
| if (tween1[i].name === name) { | |
| tween1[i] = t; | |
| break; | |
| } | |
| } | |
| if (i === n) tween1.push(t); | |
| } | |
| schedule.tween = tween1; | |
| }; | |
| } | |
| var transition_tween$1 = function(name, value) { | |
| var id = this._id; | |
| name += ""; | |
| if (arguments.length < 2) { | |
| var tween = get$2(this.node(), id).tween; | |
| for (var i = 0, n = tween.length, t; i < n; ++i) { | |
| if ((t = tween[i]).name === name) { | |
| return t.value; | |
| } | |
| } | |
| return null; | |
| } | |
| return this.each((value == null ? tweenRemove$1 : tweenFunction$1)(id, name, value)); | |
| }; | |
| function tweenValue$1(transition, name, value) { | |
| var id = transition._id; | |
| transition.each(function() { | |
| var schedule = set$4(this, id); | |
| (schedule.value || (schedule.value = {}))[name] = value.apply(this, arguments); | |
| }); | |
| return function(node) { | |
| return get$2(node, id).value[name]; | |
| }; | |
| } | |
| var interpolate$1 = function(a, b) { | |
| var c; | |
| return (typeof b === "number" ? interpolateNumber | |
| : b instanceof color$1 ? interpolateRgb$1 | |
| : (c = color$1(b)) ? (b = c, interpolateRgb$1) | |
| : interpolateString$1)(a, b); | |
| }; | |
| function attrRemove$3(name) { | |
| return function() { | |
| this.removeAttribute(name); | |
| }; | |
| } | |
| function attrRemoveNS$3(fullname) { | |
| return function() { | |
| this.removeAttributeNS(fullname.space, fullname.local); | |
| }; | |
| } | |
| function attrConstant$3(name, interpolate$$1, value1) { | |
| var value00, | |
| interpolate0; | |
| return function() { | |
| var value0 = this.getAttribute(name); | |
| return value0 === value1 ? null | |
| : value0 === value00 ? interpolate0 | |
| : interpolate0 = interpolate$$1(value00 = value0, value1); | |
| }; | |
| } | |
| function attrConstantNS$3(fullname, interpolate$$1, value1) { | |
| var value00, | |
| interpolate0; | |
| return function() { | |
| var value0 = this.getAttributeNS(fullname.space, fullname.local); | |
| return value0 === value1 ? null | |
| : value0 === value00 ? interpolate0 | |
| : interpolate0 = interpolate$$1(value00 = value0, value1); | |
| }; | |
| } | |
| function attrFunction$3(name, interpolate$$1, value) { | |
| var value00, | |
| value10, | |
| interpolate0; | |
| return function() { | |
| var value0, value1 = value(this); | |
| if (value1 == null) return void this.removeAttribute(name); | |
| value0 = this.getAttribute(name); | |
| return value0 === value1 ? null | |
| : value0 === value00 && value1 === value10 ? interpolate0 | |
| : interpolate0 = interpolate$$1(value00 = value0, value10 = value1); | |
| }; | |
| } | |
| function attrFunctionNS$3(fullname, interpolate$$1, value) { | |
| var value00, | |
| value10, | |
| interpolate0; | |
| return function() { | |
| var value0, value1 = value(this); | |
| if (value1 == null) return void this.removeAttributeNS(fullname.space, fullname.local); | |
| value0 = this.getAttributeNS(fullname.space, fullname.local); | |
| return value0 === value1 ? null | |
| : value0 === value00 && value1 === value10 ? interpolate0 | |
| : interpolate0 = interpolate$$1(value00 = value0, value10 = value1); | |
| }; | |
| } | |
| var transition_attr$1 = function(name, value) { | |
| var fullname = namespace$1(name), i = fullname === "transform" ? interpolateTransformSvg$1 : interpolate$1; | |
| return this.attrTween(name, typeof value === "function" | |
| ? (fullname.local ? attrFunctionNS$3 : attrFunction$3)(fullname, i, tweenValue$1(this, "attr." + name, value)) | |
| : value == null ? (fullname.local ? attrRemoveNS$3 : attrRemove$3)(fullname) | |
| : (fullname.local ? attrConstantNS$3 : attrConstant$3)(fullname, i, value + "")); | |
| }; | |
| function attrTweenNS$1(fullname, value) { | |
| function tween() { | |
| var node = this, i = value.apply(node, arguments); | |
| return i && function(t) { | |
| node.setAttributeNS(fullname.space, fullname.local, i(t)); | |
| }; | |
| } | |
| tween._value = value; | |
| return tween; | |
| } | |
| function attrTween$1(name, value) { | |
| function tween() { | |
| var node = this, i = value.apply(node, arguments); | |
| return i && function(t) { | |
| node.setAttribute(name, i(t)); | |
| }; | |
| } | |
| tween._value = value; | |
| return tween; | |
| } | |
| var transition_attrTween$1 = function(name, value) { | |
| var key = "attr." + name; | |
| if (arguments.length < 2) return (key = this.tween(key)) && key._value; | |
| if (value == null) return this.tween(key, null); | |
| if (typeof value !== "function") throw new Error; | |
| var fullname = namespace$1(name); | |
| return this.tween(key, (fullname.local ? attrTweenNS$1 : attrTween$1)(fullname, value)); | |
| }; | |
| function delayFunction$1(id, value) { | |
| return function() { | |
| init$1(this, id).delay = +value.apply(this, arguments); | |
| }; | |
| } | |
| function delayConstant$1(id, value) { | |
| return value = +value, function() { | |
| init$1(this, id).delay = value; | |
| }; | |
| } | |
| var transition_delay$1 = function(value) { | |
| var id = this._id; | |
| return arguments.length | |
| ? this.each((typeof value === "function" | |
| ? delayFunction$1 | |
| : delayConstant$1)(id, value)) | |
| : get$2(this.node(), id).delay; | |
| }; | |
| function durationFunction$1(id, value) { | |
| return function() { | |
| set$4(this, id).duration = +value.apply(this, arguments); | |
| }; | |
| } | |
| function durationConstant$1(id, value) { | |
| return value = +value, function() { | |
| set$4(this, id).duration = value; | |
| }; | |
| } | |
| var transition_duration$1 = function(value) { | |
| var id = this._id; | |
| return arguments.length | |
| ? this.each((typeof value === "function" | |
| ? durationFunction$1 | |
| : durationConstant$1)(id, value)) | |
| : get$2(this.node(), id).duration; | |
| }; | |
| function easeConstant$1(id, value) { | |
| if (typeof value !== "function") throw new Error; | |
| return function() { | |
| set$4(this, id).ease = value; | |
| }; | |
| } | |
| var transition_ease$1 = function(value) { | |
| var id = this._id; | |
| return arguments.length | |
| ? this.each(easeConstant$1(id, value)) | |
| : get$2(this.node(), id).ease; | |
| }; | |
| var transition_filter$1 = function(match) { | |
| if (typeof match !== "function") match = matcher$3(match); | |
| for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) { | |
| if ((node = group[i]) && match.call(node, node.__data__, i, group)) { | |
| subgroup.push(node); | |
| } | |
| } | |
| } | |
| return new Transition$1(subgroups, this._parents, this._name, this._id); | |
| }; | |
| var transition_merge$1 = function(transition) { | |
| if (transition._id !== this._id) throw new Error; | |
| for (var groups0 = this._groups, groups1 = transition._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) { | |
| for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) { | |
| if (node = group0[i] || group1[i]) { | |
| merge[i] = node; | |
| } | |
| } | |
| } | |
| for (; j < m0; ++j) { | |
| merges[j] = groups0[j]; | |
| } | |
| return new Transition$1(merges, this._parents, this._name, this._id); | |
| }; | |
| function start$1(name) { | |
| return (name + "").trim().split(/^|\s+/).every(function(t) { | |
| var i = t.indexOf("."); | |
| if (i >= 0) t = t.slice(0, i); | |
| return !t || t === "start"; | |
| }); | |
| } | |
| function onFunction$1(id, name, listener) { | |
| var on0, on1, sit = start$1(name) ? init$1 : set$4; | |
| return function() { | |
| var schedule = sit(this, id), | |
| on = schedule.on; | |
| // If this node shared a dispatch with the previous node, | |
| // just assign the updated shared dispatch and we’re done! | |
| // Otherwise, copy-on-write. | |
| if (on !== on0) (on1 = (on0 = on).copy()).on(name, listener); | |
| schedule.on = on1; | |
| }; | |
| } | |
| var transition_on$1 = function(name, listener) { | |
| var id = this._id; | |
| return arguments.length < 2 | |
| ? get$2(this.node(), id).on.on(name) | |
| : this.each(onFunction$1(id, name, listener)); | |
| }; | |
| function removeFunction$1(id) { | |
| return function() { | |
| var parent = this.parentNode; | |
| for (var i in this.__transition) if (+i !== id) return; | |
| if (parent) parent.removeChild(this); | |
| }; | |
| } | |
| var transition_remove$1 = function() { | |
| return this.on("end.remove", removeFunction$1(this._id)); | |
| }; | |
| var transition_select$1 = function(select$$1) { | |
| var name = this._name, | |
| id = this._id; | |
| if (typeof select$$1 !== "function") select$$1 = selector$1(select$$1); | |
| for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) { | |
| if ((node = group[i]) && (subnode = select$$1.call(node, node.__data__, i, group))) { | |
| if ("__data__" in node) subnode.__data__ = node.__data__; | |
| subgroup[i] = subnode; | |
| schedule$1(subgroup[i], name, id, i, subgroup, get$2(node, id)); | |
| } | |
| } | |
| } | |
| return new Transition$1(subgroups, this._parents, name, id); | |
| }; | |
| var transition_selectAll$1 = function(select$$1) { | |
| var name = this._name, | |
| id = this._id; | |
| if (typeof select$$1 !== "function") select$$1 = selectorAll$1(select$$1); | |
| for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { | |
| if (node = group[i]) { | |
| for (var children = select$$1.call(node, node.__data__, i, group), child, inherit = get$2(node, id), k = 0, l = children.length; k < l; ++k) { | |
| if (child = children[k]) { | |
| schedule$1(child, name, id, k, children, inherit); | |
| } | |
| } | |
| subgroups.push(children); | |
| parents.push(node); | |
| } | |
| } | |
| } | |
| return new Transition$1(subgroups, parents, name, id); | |
| }; | |
| var Selection$3 = selection$2.prototype.constructor; | |
| var transition_selection$1 = function() { | |
| return new Selection$3(this._groups, this._parents); | |
| }; | |
| function styleRemove$3(name, interpolate$$1) { | |
| var value00, | |
| value10, | |
| interpolate0; | |
| return function() { | |
| var style = window$2(this).getComputedStyle(this, null), | |
| value0 = style.getPropertyValue(name), | |
| value1 = (this.style.removeProperty(name), style.getPropertyValue(name)); | |
| return value0 === value1 ? null | |
| : value0 === value00 && value1 === value10 ? interpolate0 | |
| : interpolate0 = interpolate$$1(value00 = value0, value10 = value1); | |
| }; | |
| } | |
| function styleRemoveEnd$1(name) { | |
| return function() { | |
| this.style.removeProperty(name); | |
| }; | |
| } | |
| function styleConstant$3(name, interpolate$$1, value1) { | |
| var value00, | |
| interpolate0; | |
| return function() { | |
| var value0 = window$2(this).getComputedStyle(this, null).getPropertyValue(name); | |
| return value0 === value1 ? null | |
| : value0 === value00 ? interpolate0 | |
| : interpolate0 = interpolate$$1(value00 = value0, value1); | |
| }; | |
| } | |
| function styleFunction$3(name, interpolate$$1, value) { | |
| var value00, | |
| value10, | |
| interpolate0; | |
| return function() { | |
| var style = window$2(this).getComputedStyle(this, null), | |
| value0 = style.getPropertyValue(name), | |
| value1 = value(this); | |
| if (value1 == null) value1 = (this.style.removeProperty(name), style.getPropertyValue(name)); | |
| return value0 === value1 ? null | |
| : value0 === value00 && value1 === value10 ? interpolate0 | |
| : interpolate0 = interpolate$$1(value00 = value0, value10 = value1); | |
| }; | |
| } | |
| var transition_style$1 = function(name, value, priority) { | |
| var i = (name += "") === "transform" ? interpolateTransformCss$1 : interpolate$1; | |
| return value == null ? this | |
| .styleTween(name, styleRemove$3(name, i)) | |
| .on("end.style." + name, styleRemoveEnd$1(name)) | |
| : this.styleTween(name, typeof value === "function" | |
| ? styleFunction$3(name, i, tweenValue$1(this, "style." + name, value)) | |
| : styleConstant$3(name, i, value + ""), priority); | |
| }; | |
| function styleTween$1(name, value, priority) { | |
| function tween() { | |
| var node = this, i = value.apply(node, arguments); | |
| return i && function(t) { | |
| node.style.setProperty(name, i(t), priority); | |
| }; | |
| } | |
| tween._value = value; | |
| return tween; | |
| } | |
| var transition_styleTween$1 = function(name, value, priority) { | |
| var key = "style." + (name += ""); | |
| if (arguments.length < 2) return (key = this.tween(key)) && key._value; | |
| if (value == null) return this.tween(key, null); | |
| if (typeof value !== "function") throw new Error; | |
| return this.tween(key, styleTween$1(name, value, priority == null ? "" : priority)); | |
| }; | |
| function textConstant$3(value) { | |
| return function() { | |
| this.textContent = value; | |
| }; | |
| } | |
| function textFunction$3(value) { | |
| return function() { | |
| var value1 = value(this); | |
| this.textContent = value1 == null ? "" : value1; | |
| }; | |
| } | |
| var transition_text$1 = function(value) { | |
| return this.tween("text", typeof value === "function" | |
| ? textFunction$3(tweenValue$1(this, "text", value)) | |
| : textConstant$3(value == null ? "" : value + "")); | |
| }; | |
| var transition_transition$1 = function() { | |
| var name = this._name, | |
| id0 = this._id, | |
| id1 = newId$1(); | |
| for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { | |
| if (node = group[i]) { | |
| var inherit = get$2(node, id0); | |
| schedule$1(node, name, id1, i, group, { | |
| time: inherit.time + inherit.delay + inherit.duration, | |
| delay: 0, | |
| duration: inherit.duration, | |
| ease: inherit.ease | |
| }); | |
| } | |
| } | |
| } | |
| return new Transition$1(groups, this._parents, name, id1); | |
| }; | |
| var id$1 = 0; | |
| function Transition$1(groups, parents, name, id) { | |
| this._groups = groups; | |
| this._parents = parents; | |
| this._name = name; | |
| this._id = id; | |
| } | |
| function transition$1(name) { | |
| return selection$2().transition(name); | |
| } | |
| function newId$1() { | |
| return ++id$1; | |
| } | |
| var selection_prototype$1 = selection$2.prototype; | |
| Transition$1.prototype = transition$1.prototype = { | |
| constructor: Transition$1, | |
| select: transition_select$1, | |
| selectAll: transition_selectAll$1, | |
| filter: transition_filter$1, | |
| merge: transition_merge$1, | |
| selection: transition_selection$1, | |
| transition: transition_transition$1, | |
| call: selection_prototype$1.call, | |
| nodes: selection_prototype$1.nodes, | |
| node: selection_prototype$1.node, | |
| size: selection_prototype$1.size, | |
| empty: selection_prototype$1.empty, | |
| each: selection_prototype$1.each, | |
| on: transition_on$1, | |
| attr: transition_attr$1, | |
| attrTween: transition_attrTween$1, | |
| style: transition_style$1, | |
| styleTween: transition_styleTween$1, | |
| text: transition_text$1, | |
| remove: transition_remove$1, | |
| tween: transition_tween$1, | |
| delay: transition_delay$1, | |
| duration: transition_duration$1, | |
| ease: transition_ease$1 | |
| }; | |
| function linear$4(t) { | |
| return +t; | |
| } | |
| function quadIn$1(t) { | |
| return t * t; | |
| } | |
| function quadOut$1(t) { | |
| return t * (2 - t); | |
| } | |
| function quadInOut$1(t) { | |
| return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2; | |
| } | |
| function cubicIn$1(t) { | |
| return t * t * t; | |
| } | |
| function cubicOut$1(t) { | |
| return --t * t * t + 1; | |
| } | |
| function cubicInOut$1(t) { | |
| return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2; | |
| } | |
| var exponent$2 = 3; | |
| var polyIn$1 = (function custom(e) { | |
| e = +e; | |
| function polyIn(t) { | |
| return Math.pow(t, e); | |
| } | |
| polyIn.exponent = custom; | |
| return polyIn; | |
| })(exponent$2); | |
| var polyOut$1 = (function custom(e) { | |
| e = +e; | |
| function polyOut(t) { | |
| return 1 - Math.pow(1 - t, e); | |
| } | |
| polyOut.exponent = custom; | |
| return polyOut; | |
| })(exponent$2); | |
| var polyInOut$1 = (function custom(e) { | |
| e = +e; | |
| function polyInOut(t) { | |
| return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2; | |
| } | |
| polyInOut.exponent = custom; | |
| return polyInOut; | |
| })(exponent$2); | |
| var pi$1 = Math.PI; | |
| var halfPi$1 = pi$1 / 2; | |
| function sinIn$1(t) { | |
| return 1 - Math.cos(t * halfPi$1); | |
| } | |
| function sinOut$1(t) { | |
| return Math.sin(t * halfPi$1); | |
| } | |
| function sinInOut$1(t) { | |
| return (1 - Math.cos(pi$1 * t)) / 2; | |
| } | |
| function expIn$1(t) { | |
| return Math.pow(2, 10 * t - 10); | |
| } | |
| function expOut$1(t) { | |
| return 1 - Math.pow(2, -10 * t); | |
| } | |
| function expInOut$1(t) { | |
| return ((t *= 2) <= 1 ? Math.pow(2, 10 * t - 10) : 2 - Math.pow(2, 10 - 10 * t)) / 2; | |
| } | |
| function circleIn$1(t) { | |
| return 1 - Math.sqrt(1 - t * t); | |
| } | |
| function circleOut$1(t) { | |
| return Math.sqrt(1 - --t * t); | |
| } | |
| function circleInOut$1(t) { | |
| return ((t *= 2) <= 1 ? 1 - Math.sqrt(1 - t * t) : Math.sqrt(1 - (t -= 2) * t) + 1) / 2; | |
| } | |
| var b1$1 = 4 / 11; | |
| var b2$1 = 6 / 11; | |
| var b3$1 = 8 / 11; | |
| var b4$1 = 3 / 4; | |
| var b5$1 = 9 / 11; | |
| var b6$1 = 10 / 11; | |
| var b7$1 = 15 / 16; | |
| var b8$1 = 21 / 22; | |
| var b9$1 = 63 / 64; | |
| var b0$1 = 1 / b1$1 / b1$1; | |
| function bounceIn$1(t) { | |
| return 1 - bounceOut$1(1 - t); | |
| } | |
| function bounceOut$1(t) { | |
| return (t = +t) < b1$1 ? b0$1 * t * t : t < b3$1 ? b0$1 * (t -= b2$1) * t + b4$1 : t < b6$1 ? b0$1 * (t -= b5$1) * t + b7$1 : b0$1 * (t -= b8$1) * t + b9$1; | |
| } | |
| function bounceInOut$1(t) { | |
| return ((t *= 2) <= 1 ? 1 - bounceOut$1(1 - t) : bounceOut$1(t - 1) + 1) / 2; | |
| } | |
| var overshoot$1 = 1.70158; | |
| var backIn$1 = (function custom(s) { | |
| s = +s; | |
| function backIn(t) { | |
| return t * t * ((s + 1) * t - s); | |
| } | |
| backIn.overshoot = custom; | |
| return backIn; | |
| })(overshoot$1); | |
| var backOut$1 = (function custom(s) { | |
| s = +s; | |
| function backOut(t) { | |
| return --t * t * ((s + 1) * t + s) + 1; | |
| } | |
| backOut.overshoot = custom; | |
| return backOut; | |
| })(overshoot$1); | |
| var backInOut$1 = (function custom(s) { | |
| s = +s; | |
| function backInOut(t) { | |
| return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2; | |
| } | |
| backInOut.overshoot = custom; | |
| return backInOut; | |
| })(overshoot$1); | |
| var tau$1 = 2 * Math.PI; | |
| var amplitude$1 = 1; | |
| var period$1 = 0.3; | |
| var elasticIn$1 = (function custom(a, p) { | |
| var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau$1); | |
| function elasticIn(t) { | |
| return a * Math.pow(2, 10 * --t) * Math.sin((s - t) / p); | |
| } | |
| elasticIn.amplitude = function(a) { return custom(a, p * tau$1); }; | |
| elasticIn.period = function(p) { return custom(a, p); }; | |
| return elasticIn; | |
| })(amplitude$1, period$1); | |
| var elasticOut$1 = (function custom(a, p) { | |
| var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau$1); | |
| function elasticOut(t) { | |
| return 1 - a * Math.pow(2, -10 * (t = +t)) * Math.sin((t + s) / p); | |
| } | |
| elasticOut.amplitude = function(a) { return custom(a, p * tau$1); }; | |
| elasticOut.period = function(p) { return custom(a, p); }; | |
| return elasticOut; | |
| })(amplitude$1, period$1); | |
| var elasticInOut$1 = (function custom(a, p) { | |
| var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau$1); | |
| function elasticInOut(t) { | |
| return ((t = t * 2 - 1) < 0 | |
| ? a * Math.pow(2, 10 * t) * Math.sin((s - t) / p) | |
| : 2 - a * Math.pow(2, -10 * t) * Math.sin((s + t) / p)) / 2; | |
| } | |
| elasticInOut.amplitude = function(a) { return custom(a, p * tau$1); }; | |
| elasticInOut.period = function(p) { return custom(a, p); }; | |
| return elasticInOut; | |
| })(amplitude$1, period$1); | |
| var ease = Object.freeze({ | |
| easeLinear: linear$4, | |
| easeQuad: quadInOut$1, | |
| easeQuadIn: quadIn$1, | |
| easeQuadOut: quadOut$1, | |
| easeQuadInOut: quadInOut$1, | |
| easeCubic: cubicInOut$1, | |
| easeCubicIn: cubicIn$1, | |
| easeCubicOut: cubicOut$1, | |
| easeCubicInOut: cubicInOut$1, | |
| easePoly: polyInOut$1, | |
| easePolyIn: polyIn$1, | |
| easePolyOut: polyOut$1, | |
| easePolyInOut: polyInOut$1, | |
| easeSin: sinInOut$1, | |
| easeSinIn: sinIn$1, | |
| easeSinOut: sinOut$1, | |
| easeSinInOut: sinInOut$1, | |
| easeExp: expInOut$1, | |
| easeExpIn: expIn$1, | |
| easeExpOut: expOut$1, | |
| easeExpInOut: expInOut$1, | |
| easeCircle: circleInOut$1, | |
| easeCircleIn: circleIn$1, | |
| easeCircleOut: circleOut$1, | |
| easeCircleInOut: circleInOut$1, | |
| easeBounce: bounceOut$1, | |
| easeBounceIn: bounceIn$1, | |
| easeBounceOut: bounceOut$1, | |
| easeBounceInOut: bounceInOut$1, | |
| easeBack: backInOut$1, | |
| easeBackIn: backIn$1, | |
| easeBackOut: backOut$1, | |
| easeBackInOut: backInOut$1, | |
| easeElastic: elasticOut$1, | |
| easeElasticIn: elasticIn$1, | |
| easeElasticOut: elasticOut$1, | |
| easeElasticInOut: elasticInOut$1 | |
| }); | |
| var defaultTiming$1 = { | |
| time: null, // Set on use. | |
| delay: 0, | |
| duration: 250, | |
| ease: cubicInOut$1 | |
| }; | |
| function inherit$1(node, id) { | |
| var timing; | |
| while (!(timing = node.__transition) || !(timing = timing[id])) { | |
| if (!(node = node.parentNode)) { | |
| return defaultTiming$1.time = now$1(), defaultTiming$1; | |
| } | |
| } | |
| return timing; | |
| } | |
| var selection_transition$1 = function(name) { | |
| var id, | |
| timing; | |
| if (name instanceof Transition$1) { | |
| id = name._id, name = name._name; | |
| } else { | |
| id = newId$1(), (timing = defaultTiming$1).time = now$1(), name = name == null ? null : name + ""; | |
| } | |
| for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { | |
| if (node = group[i]) { | |
| schedule$1(node, name, id, i, group, timing || inherit$1(node, id)); | |
| } | |
| } | |
| } | |
| return new Transition$1(groups, this._parents, name, id); | |
| }; | |
| selection$2.prototype.interrupt = selection_interrupt$1; | |
| selection$2.prototype.transition = selection_transition$1; | |
| function attrsFunction$2(selection$$1, map) { | |
| return selection$$1.each(function() { | |
| var x = map.apply(this, arguments), s = select$1(this); | |
| for (var name in x) s.attr(name, x[name]); | |
| }); | |
| } | |
| function attrsObject$2(selection$$1, map) { | |
| for (var name in map) selection$$1.attr(name, map[name]); | |
| return selection$$1; | |
| } | |
| var selection_attrs$1 = function(map) { | |
| return (typeof map === "function" ? attrsFunction$2 : attrsObject$2)(this, map); | |
| }; | |
| function stylesFunction$2(selection$$1, map, priority) { | |
| return selection$$1.each(function() { | |
| var x = map.apply(this, arguments), s = select$1(this); | |
| for (var name in x) s.style(name, x[name], priority); | |
| }); | |
| } | |
| function stylesObject$2(selection$$1, map, priority) { | |
| for (var name in map) selection$$1.style(name, map[name], priority); | |
| return selection$$1; | |
| } | |
| var selection_styles$1 = function(map, priority) { | |
| return (typeof map === "function" ? stylesFunction$2 : stylesObject$2)(this, map, priority == null ? "" : priority); | |
| }; | |
| function propertiesFunction$1(selection$$1, map) { | |
| return selection$$1.each(function() { | |
| var x = map.apply(this, arguments), s = select$1(this); | |
| for (var name in x) s.property(name, x[name]); | |
| }); | |
| } | |
| function propertiesObject$1(selection$$1, map) { | |
| for (var name in map) selection$$1.property(name, map[name]); | |
| return selection$$1; | |
| } | |
| var selection_properties$1 = function(map) { | |
| return (typeof map === "function" ? propertiesFunction$1 : propertiesObject$1)(this, map); | |
| }; | |
| function attrsFunction$3(transition, map) { | |
| return transition.each(function() { | |
| var x = map.apply(this, arguments), t = select$1(this).transition(transition); | |
| for (var name in x) t.attr(name, x[name]); | |
| }); | |
| } | |
| function attrsObject$3(transition, map) { | |
| for (var name in map) transition.attr(name, map[name]); | |
| return transition; | |
| } | |
| var transition_attrs$1 = function(map) { | |
| return (typeof map === "function" ? attrsFunction$3 : attrsObject$3)(this, map); | |
| }; | |
| function stylesFunction$3(transition, map, priority) { | |
| return transition.each(function() { | |
| var x = map.apply(this, arguments), t = select$1(this).transition(transition); | |
| for (var name in x) t.style(name, x[name], priority); | |
| }); | |
| } | |
| function stylesObject$3(transition, map, priority) { | |
| for (var name in map) transition.style(name, map[name], priority); | |
| return transition; | |
| } | |
| var transition_styles$1 = function(map, priority) { | |
| return (typeof map === "function" ? stylesFunction$3 : stylesObject$3)(this, map, priority == null ? "" : priority); | |
| }; | |
| selection$2.prototype.attrs = selection_attrs$1; | |
| selection$2.prototype.styles = selection_styles$1; | |
| selection$2.prototype.properties = selection_properties$1; | |
| transition$1.prototype.attrs = transition_attrs$1; | |
| transition$1.prototype.styles = transition_styles$1; | |
| function nopropagation() { | |
| event$1.stopImmediatePropagation(); | |
| } | |
| var noevent = function() { | |
| event$1.preventDefault(); | |
| event$1.stopImmediatePropagation(); | |
| }; | |
| var nodrag = function(view) { | |
| var root = view.document.documentElement, | |
| selection$$1 = select$1(view).on("dragstart.drag", noevent, true); | |
| if ("onselectstart" in root) { | |
| selection$$1.on("selectstart.drag", noevent, true); | |
| } else { | |
| root.__noselect = root.style.MozUserSelect; | |
| root.style.MozUserSelect = "none"; | |
| } | |
| }; | |
| function yesdrag(view, noclick) { | |
| var root = view.document.documentElement, | |
| selection$$1 = select$1(view).on("dragstart.drag", null); | |
| if (noclick) { | |
| selection$$1.on("click.drag", noevent, true); | |
| setTimeout(function() { selection$$1.on("click.drag", null); }, 0); | |
| } | |
| if ("onselectstart" in root) { | |
| selection$$1.on("selectstart.drag", null); | |
| } else { | |
| root.style.MozUserSelect = root.__noselect; | |
| delete root.__noselect; | |
| } | |
| } | |
| var constant$6 = function(x) { | |
| return function() { | |
| return x; | |
| }; | |
| }; | |
| function DragEvent(target, type, subject, id, active, x, y, dx, dy, dispatch) { | |
| this.target = target; | |
| this.type = type; | |
| this.subject = subject; | |
| this.identifier = id; | |
| this.active = active; | |
| this.x = x; | |
| this.y = y; | |
| this.dx = dx; | |
| this.dy = dy; | |
| this._ = dispatch; | |
| } | |
| DragEvent.prototype.on = function() { | |
| var value = this._.on.apply(this._, arguments); | |
| return value === this._ ? this : value; | |
| }; | |
| // Ignore right-click, since that should open the context menu. | |
| function defaultFilter() { | |
| return !event$1.button; | |
| } | |
| function defaultContainer() { | |
| return this.parentNode; | |
| } | |
| function defaultSubject(d) { | |
| return d == null ? {x: event$1.x, y: event$1.y} : d; | |
| } | |
| var drag = function() { | |
| var filter = defaultFilter, | |
| container = defaultContainer, | |
| subject = defaultSubject, | |
| gestures = {}, | |
| listeners = dispatch$2("start", "drag", "end"), | |
| active = 0, | |
| mousemoving, | |
| touchending; | |
| function drag(selection$$1) { | |
| selection$$1 | |
| .on("mousedown.drag", mousedowned) | |
| .on("touchstart.drag", touchstarted) | |
| .on("touchmove.drag", touchmoved) | |
| .on("touchend.drag touchcancel.drag", touchended) | |
| .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)"); | |
| } | |
| function mousedowned() { | |
| if (touchending || !filter.apply(this, arguments)) return; | |
| var gesture = beforestart("mouse", container.apply(this, arguments), mouse$1, this, arguments); | |
| if (!gesture) return; | |
| select$1(event$1.view).on("mousemove.drag", mousemoved, true).on("mouseup.drag", mouseupped, true); | |
| nodrag(event$1.view); | |
| nopropagation(); | |
| mousemoving = false; | |
| gesture("start"); | |
| } | |
| function mousemoved() { | |
| noevent(); | |
| mousemoving = true; | |
| gestures.mouse("drag"); | |
| } | |
| function mouseupped() { | |
| select$1(event$1.view).on("mousemove.drag mouseup.drag", null); | |
| yesdrag(event$1.view, mousemoving); | |
| noevent(); | |
| gestures.mouse("end"); | |
| } | |
| function touchstarted() { | |
| if (!filter.apply(this, arguments)) return; | |
| var touches$$1 = event$1.changedTouches, | |
| c = container.apply(this, arguments), | |
| n = touches$$1.length, i, gesture; | |
| for (i = 0; i < n; ++i) { | |
| if (gesture = beforestart(touches$$1[i].identifier, c, touch$1, this, arguments)) { | |
| nopropagation(); | |
| gesture("start"); | |
| } | |
| } | |
| } | |
| function touchmoved() { | |
| var touches$$1 = event$1.changedTouches, | |
| n = touches$$1.length, i, gesture; | |
| for (i = 0; i < n; ++i) { | |
| if (gesture = gestures[touches$$1[i].identifier]) { | |
| noevent(); | |
| gesture("drag"); | |
| } | |
| } | |
| } | |
| function touchended() { | |
| var touches$$1 = event$1.changedTouches, | |
| n = touches$$1.length, i, gesture; | |
| if (touchending) clearTimeout(touchending); | |
| touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed! | |
| for (i = 0; i < n; ++i) { | |
| if (gesture = gestures[touches$$1[i].identifier]) { | |
| nopropagation(); | |
| gesture("end"); | |
| } | |
| } | |
| } | |
| function beforestart(id, container, point, that, args) { | |
| var p = point(container, id), s, dx, dy, | |
| sublisteners = listeners.copy(); | |
| if (!customEvent$1(new DragEvent(drag, "beforestart", s, id, active, p[0], p[1], 0, 0, sublisteners), function() { | |
| if ((event$1.subject = s = subject.apply(that, args)) == null) return false; | |
| dx = s.x - p[0] || 0; | |
| dy = s.y - p[1] || 0; | |
| return true; | |
| })) return; | |
| return function gesture(type) { | |
| var p0 = p, n; | |
| switch (type) { | |
| case "start": gestures[id] = gesture, n = active++; break; | |
| case "end": delete gestures[id], --active; // nobreak | |
| case "drag": p = point(container, id), n = active; break; | |
| } | |
| customEvent$1(new DragEvent(drag, type, s, id, n, p[0] + dx, p[1] + dy, p[0] - p0[0], p[1] - p0[1], sublisteners), sublisteners.apply, sublisteners, [type, that, args]); | |
| }; | |
| } | |
| drag.filter = function(_) { | |
| return arguments.length ? (filter = typeof _ === "function" ? _ : constant$6(!!_), drag) : filter; | |
| }; | |
| drag.container = function(_) { | |
| return arguments.length ? (container = typeof _ === "function" ? _ : constant$6(_), drag) : container; | |
| }; | |
| drag.subject = function(_) { | |
| return arguments.length ? (subject = typeof _ === "function" ? _ : constant$6(_), drag) : subject; | |
| }; | |
| drag.on = function() { | |
| var value = listeners.on.apply(listeners, arguments); | |
| return value === listeners ? drag : value; | |
| }; | |
| return drag; | |
| }; | |
| // Computes the decimal coefficient and exponent of the specified number x with | |
| // significant digits p, where x is positive and p is in [1, 21] or undefined. | |
| // For example, formatDecimal(1.23) returns ["123", 0]. | |
| var formatDecimal$1 = function(x, p) { | |
| if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf("e")) < 0) return null; // NaN, ±Infinity | |
| var i, coefficient = x.slice(0, i); | |
| // The string returned by toExponential either has the form \d\.\d+e[-+]\d+ | |
| // (e.g., 1.2e+3) or the form \de[-+]\d+ (e.g., 1e+3). | |
| return [ | |
| coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient, | |
| +x.slice(i + 1) | |
| ]; | |
| }; | |
| var exponent$3 = function(x) { | |
| return x = formatDecimal$1(Math.abs(x)), x ? x[1] : NaN; | |
| }; | |
| var formatGroup$1 = function(grouping, thousands) { | |
| return function(value, width) { | |
| var i = value.length, | |
| t = [], | |
| j = 0, | |
| g = grouping[0], | |
| length = 0; | |
| while (i > 0 && g > 0) { | |
| if (length + g + 1 > width) g = Math.max(1, width - length); | |
| t.push(value.substring(i -= g, i + g)); | |
| if ((length += g + 1) > width) break; | |
| g = grouping[j = (j + 1) % grouping.length]; | |
| } | |
| return t.reverse().join(thousands); | |
| }; | |
| }; | |
| var formatNumerals$1 = function(numerals) { | |
| return function(value) { | |
| return value.replace(/[0-9]/g, function(i) { | |
| return numerals[+i]; | |
| }); | |
| }; | |
| }; | |
| var formatDefault$1 = function(x, p) { | |
| x = x.toPrecision(p); | |
| out: for (var n = x.length, i = 1, i0 = -1, i1; i < n; ++i) { | |
| switch (x[i]) { | |
| case ".": i0 = i1 = i; break; | |
| case "0": if (i0 === 0) i0 = i; i1 = i; break; | |
| case "e": break out; | |
| default: if (i0 > 0) i0 = 0; break; | |
| } | |
| } | |
| return i0 > 0 ? x.slice(0, i0) + x.slice(i1 + 1) : x; | |
| }; | |
| var prefixExponent$1; | |
| var formatPrefixAuto$1 = function(x, p) { | |
| var d = formatDecimal$1(x, p); | |
| if (!d) return x + ""; | |
| var coefficient = d[0], | |
| exponent = d[1], | |
| i = exponent - (prefixExponent$1 = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1, | |
| n = coefficient.length; | |
| return i === n ? coefficient | |
| : i > n ? coefficient + new Array(i - n + 1).join("0") | |
| : i > 0 ? coefficient.slice(0, i) + "." + coefficient.slice(i) | |
| : "0." + new Array(1 - i).join("0") + formatDecimal$1(x, Math.max(0, p + i - 1))[0]; // less than 1y! | |
| }; | |
| var formatRounded$1 = function(x, p) { | |
| var d = formatDecimal$1(x, p); | |
| if (!d) return x + ""; | |
| var coefficient = d[0], | |
| exponent = d[1]; | |
| return exponent < 0 ? "0." + new Array(-exponent).join("0") + coefficient | |
| : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + "." + coefficient.slice(exponent + 1) | |
| : coefficient + new Array(exponent - coefficient.length + 2).join("0"); | |
| }; | |
| var formatTypes$1 = { | |
| "": formatDefault$1, | |
| "%": function(x, p) { return (x * 100).toFixed(p); }, | |
| "b": function(x) { return Math.round(x).toString(2); }, | |
| "c": function(x) { return x + ""; }, | |
| "d": function(x) { return Math.round(x).toString(10); }, | |
| "e": function(x, p) { return x.toExponential(p); }, | |
| "f": function(x, p) { return x.toFixed(p); }, | |
| "g": function(x, p) { return x.toPrecision(p); }, | |
| "o": function(x) { return Math.round(x).toString(8); }, | |
| "p": function(x, p) { return formatRounded$1(x * 100, p); }, | |
| "r": formatRounded$1, | |
| "s": formatPrefixAuto$1, | |
| "X": function(x) { return Math.round(x).toString(16).toUpperCase(); }, | |
| "x": function(x) { return Math.round(x).toString(16); } | |
| }; | |
| // [[fill]align][sign][symbol][0][width][,][.precision][type] | |
| var re$1 = /^(?:(.)?([<>=^]))?([+\-\( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?([a-z%])?$/i; | |
| function formatSpecifier$1(specifier) { | |
| return new FormatSpecifier$1(specifier); | |
| } | |
| formatSpecifier$1.prototype = FormatSpecifier$1.prototype; // instanceof | |
| function FormatSpecifier$1(specifier) { | |
| if (!(match = re$1.exec(specifier))) throw new Error("invalid format: " + specifier); | |
| var match, | |
| fill = match[1] || " ", | |
| align = match[2] || ">", | |
| sign = match[3] || "-", | |
| symbol = match[4] || "", | |
| zero = !!match[5], | |
| width = match[6] && +match[6], | |
| comma = !!match[7], | |
| precision = match[8] && +match[8].slice(1), | |
| type = match[9] || ""; | |
| // The "n" type is an alias for ",g". | |
| if (type === "n") comma = true, type = "g"; | |
| // Map invalid types to the default format. | |
| else if (!formatTypes$1[type]) type = ""; | |
| // If zero fill is specified, padding goes after sign and before digits. | |
| if (zero || (fill === "0" && align === "=")) zero = true, fill = "0", align = "="; | |
| this.fill = fill; | |
| this.align = align; | |
| this.sign = sign; | |
| this.symbol = symbol; | |
| this.zero = zero; | |
| this.width = width; | |
| this.comma = comma; | |
| this.precision = precision; | |
| this.type = type; | |
| } | |
| FormatSpecifier$1.prototype.toString = function() { | |
| return this.fill | |
| + this.align | |
| + this.sign | |
| + this.symbol | |
| + (this.zero ? "0" : "") | |
| + (this.width == null ? "" : Math.max(1, this.width | 0)) | |
| + (this.comma ? "," : "") | |
| + (this.precision == null ? "" : "." + Math.max(0, this.precision | 0)) | |
| + this.type; | |
| }; | |
| var identity$6 = function(x) { | |
| return x; | |
| }; | |
| var prefixes$1 = ["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"]; | |
| var formatLocale$2 = function(locale) { | |
| var group = locale.grouping && locale.thousands ? formatGroup$1(locale.grouping, locale.thousands) : identity$6, | |
| currency = locale.currency, | |
| decimal = locale.decimal, | |
| numerals = locale.numerals ? formatNumerals$1(locale.numerals) : identity$6; | |
| function newFormat(specifier) { | |
| specifier = formatSpecifier$1(specifier); | |
| var fill = specifier.fill, | |
| align = specifier.align, | |
| sign = specifier.sign, | |
| symbol = specifier.symbol, | |
| zero = specifier.zero, | |
| width = specifier.width, | |
| comma = specifier.comma, | |
| precision = specifier.precision, | |
| type = specifier.type; | |
| // Compute the prefix and suffix. | |
| // For SI-prefix, the suffix is lazily computed. | |
| var prefix = symbol === "$" ? currency[0] : symbol === "#" && /[boxX]/.test(type) ? "0" + type.toLowerCase() : "", | |
| suffix = symbol === "$" ? currency[1] : /[%p]/.test(type) ? "%" : ""; | |
| // What format function should we use? | |
| // Is this an integer type? | |
| // Can this type generate exponential notation? | |
| var formatType = formatTypes$1[type], | |
| maybeSuffix = !type || /[defgprs%]/.test(type); | |
| // Set the default precision if not specified, | |
| // or clamp the specified precision to the supported range. | |
| // For significant precision, it must be in [1, 21]. | |
| // For fixed precision, it must be in [0, 20]. | |
| precision = precision == null ? (type ? 6 : 12) | |
| : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision)) | |
| : Math.max(0, Math.min(20, precision)); | |
| function format(value) { | |
| var valuePrefix = prefix, | |
| valueSuffix = suffix, | |
| i, n, c; | |
| if (type === "c") { | |
| valueSuffix = formatType(value) + valueSuffix; | |
| value = ""; | |
| } else { | |
| value = +value; | |
| // Perform the initial formatting. | |
| var valueNegative = value < 0; | |
| value = formatType(Math.abs(value), precision); | |
| // If a negative value rounds to zero during formatting, treat as positive. | |
| if (valueNegative && +value === 0) valueNegative = false; | |
| // Compute the prefix and suffix. | |
| valuePrefix = (valueNegative ? (sign === "(" ? sign : "-") : sign === "-" || sign === "(" ? "" : sign) + valuePrefix; | |
| valueSuffix = valueSuffix + (type === "s" ? prefixes$1[8 + prefixExponent$1 / 3] : "") + (valueNegative && sign === "(" ? ")" : ""); | |
| // Break the formatted value into the integer “value” part that can be | |
| // grouped, and fractional or exponential “suffix” part that is not. | |
| if (maybeSuffix) { | |
| i = -1, n = value.length; | |
| while (++i < n) { | |
| if (c = value.charCodeAt(i), 48 > c || c > 57) { | |
| valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix; | |
| value = value.slice(0, i); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| // If the fill character is not "0", grouping is applied before padding. | |
| if (comma && !zero) value = group(value, Infinity); | |
| // Compute the padding. | |
| var length = valuePrefix.length + value.length + valueSuffix.length, | |
| padding = length < width ? new Array(width - length + 1).join(fill) : ""; | |
| // If the fill character is "0", grouping is applied after padding. | |
| if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = ""; | |
| // Reconstruct the final output based on the desired alignment. | |
| switch (align) { | |
| case "<": value = valuePrefix + value + valueSuffix + padding; break; | |
| case "=": value = valuePrefix + padding + value + valueSuffix; break; | |
| case "^": value = padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length); break; | |
| default: value = padding + valuePrefix + value + valueSuffix; break; | |
| } | |
| return numerals(value); | |
| } | |
| format.toString = function() { | |
| return specifier + ""; | |
| }; | |
| return format; | |
| } | |
| function formatPrefix(specifier, value) { | |
| var f = newFormat((specifier = formatSpecifier$1(specifier), specifier.type = "f", specifier)), | |
| e = Math.max(-8, Math.min(8, Math.floor(exponent$3(value) / 3))) * 3, | |
| k = Math.pow(10, -e), | |
| prefix = prefixes$1[8 + e / 3]; | |
| return function(value) { | |
| return f(k * value) + prefix; | |
| }; | |
| } | |
| return { | |
| format: newFormat, | |
| formatPrefix: formatPrefix | |
| }; | |
| }; | |
| var locale$3; | |
| var format$1; | |
| var formatPrefix$1; | |
| defaultLocale$2({ | |
| decimal: ".", | |
| thousands: ",", | |
| grouping: [3], | |
| currency: ["$", ""] | |
| }); | |
| function defaultLocale$2(definition) { | |
| locale$3 = formatLocale$2(definition); | |
| format$1 = locale$3.format; | |
| formatPrefix$1 = locale$3.formatPrefix; | |
| return locale$3; | |
| } | |
| var forceCenter = function(x, y) { | |
| var nodes; | |
| if (x == null) x = 0; | |
| if (y == null) y = 0; | |
| function force() { | |
| var i, | |
| n = nodes.length, | |
| node, | |
| sx = 0, | |
| sy = 0; | |
| for (i = 0; i < n; ++i) { | |
| node = nodes[i], sx += node.x, sy += node.y; | |
| } | |
| for (sx = sx / n - x, sy = sy / n - y, i = 0; i < n; ++i) { | |
| node = nodes[i], node.x -= sx, node.y -= sy; | |
| } | |
| } | |
| force.initialize = function(_) { | |
| nodes = _; | |
| }; | |
| force.x = function(_) { | |
| return arguments.length ? (x = +_, force) : x; | |
| }; | |
| force.y = function(_) { | |
| return arguments.length ? (y = +_, force) : y; | |
| }; | |
| return force; | |
| }; | |
| var constant$7 = function(x) { | |
| return function() { | |
| return x; | |
| }; | |
| }; | |
| var jiggle$1 = function() { | |
| return (Math.random() - 0.5) * 1e-6; | |
| }; | |
| var tree_add = function(d) { | |
| var x = +this._x.call(null, d), | |
| y = +this._y.call(null, d); | |
| return add(this.cover(x, y), x, y, d); | |
| }; | |
| function add(tree, x, y, d) { | |
| if (isNaN(x) || isNaN(y)) return tree; // ignore invalid points | |
| var parent, | |
| node = tree._root, | |
| leaf = {data: d}, | |
| x0 = tree._x0, | |
| y0 = tree._y0, | |
| x1 = tree._x1, | |
| y1 = tree._y1, | |
| xm, | |
| ym, | |
| xp, | |
| yp, | |
| right, | |
| bottom, | |
| i, | |
| j; | |
| // If the tree is empty, initialize the root as a leaf. | |
| if (!node) return tree._root = leaf, tree; | |
| // Find the existing leaf for the new point, or add it. | |
| while (node.length) { | |
| if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; | |
| if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; | |
| if (parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree; | |
| } | |
| // Is the new point is exactly coincident with the existing point? | |
| xp = +tree._x.call(null, node.data); | |
| yp = +tree._y.call(null, node.data); | |
| if (x === xp && y === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree; | |
| // Otherwise, split the leaf node until the old and new point are separated. | |
| do { | |
| parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4); | |
| if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; | |
| if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; | |
| } while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | (xp >= xm))); | |
| return parent[j] = node, parent[i] = leaf, tree; | |
| } | |
| function addAll(data) { | |
| var d, i, n = data.length, | |
| x, | |
| y, | |
| xz = new Array(n), | |
| yz = new Array(n), | |
| x0 = Infinity, | |
| y0 = Infinity, | |
| x1 = -Infinity, | |
| y1 = -Infinity; | |
| // Compute the points and their extent. | |
| for (i = 0; i < n; ++i) { | |
| if (isNaN(x = +this._x.call(null, d = data[i])) || isNaN(y = +this._y.call(null, d))) continue; | |
| xz[i] = x; | |
| yz[i] = y; | |
| if (x < x0) x0 = x; | |
| if (x > x1) x1 = x; | |
| if (y < y0) y0 = y; | |
| if (y > y1) y1 = y; | |
| } | |
| // If there were no (valid) points, inherit the existing extent. | |
| if (x1 < x0) x0 = this._x0, x1 = this._x1; | |
| if (y1 < y0) y0 = this._y0, y1 = this._y1; | |
| // Expand the tree to cover the new points. | |
| this.cover(x0, y0).cover(x1, y1); | |
| // Add the new points. | |
| for (i = 0; i < n; ++i) { | |
| add(this, xz[i], yz[i], data[i]); | |
| } | |
| return this; | |
| } | |
| var tree_cover = function(x, y) { | |
| if (isNaN(x = +x) || isNaN(y = +y)) return this; // ignore invalid points | |
| var x0 = this._x0, | |
| y0 = this._y0, | |
| x1 = this._x1, | |
| y1 = this._y1; | |
| // If the quadtree has no extent, initialize them. | |
| // Integer extent are necessary so that if we later double the extent, | |
| // the existing quadrant boundaries don’t change due to floating point error! | |
| if (isNaN(x0)) { | |
| x1 = (x0 = Math.floor(x)) + 1; | |
| y1 = (y0 = Math.floor(y)) + 1; | |
| } | |
| // Otherwise, double repeatedly to cover. | |
| else if (x0 > x || x > x1 || y0 > y || y > y1) { | |
| var z = x1 - x0, | |
| node = this._root, | |
| parent, | |
| i; | |
| switch (i = (y < (y0 + y1) / 2) << 1 | (x < (x0 + x1) / 2)) { | |
| case 0: { | |
| do parent = new Array(4), parent[i] = node, node = parent; | |
| while (z *= 2, x1 = x0 + z, y1 = y0 + z, x > x1 || y > y1); | |
| break; | |
| } | |
| case 1: { | |
| do parent = new Array(4), parent[i] = node, node = parent; | |
| while (z *= 2, x0 = x1 - z, y1 = y0 + z, x0 > x || y > y1); | |
| break; | |
| } | |
| case 2: { | |
| do parent = new Array(4), parent[i] = node, node = parent; | |
| while (z *= 2, x1 = x0 + z, y0 = y1 - z, x > x1 || y0 > y); | |
| break; | |
| } | |
| case 3: { | |
| do parent = new Array(4), parent[i] = node, node = parent; | |
| while (z *= 2, x0 = x1 - z, y0 = y1 - z, x0 > x || y0 > y); | |
| break; | |
| } | |
| } | |
| if (this._root && this._root.length) this._root = node; | |
| } | |
| // If the quadtree covers the point already, just return. | |
| else return this; | |
| this._x0 = x0; | |
| this._y0 = y0; | |
| this._x1 = x1; | |
| this._y1 = y1; | |
| return this; | |
| }; | |
| var tree_data = function() { | |
| var data = []; | |
| this.visit(function(node) { | |
| if (!node.length) do data.push(node.data); while (node = node.next) | |
| }); | |
| return data; | |
| }; | |
| var tree_extent = function(_) { | |
| return arguments.length | |
| ? this.cover(+_[0][0], +_[0][1]).cover(+_[1][0], +_[1][1]) | |
| : isNaN(this._x0) ? undefined : [[this._x0, this._y0], [this._x1, this._y1]]; | |
| }; | |
| var Quad = function(node, x0, y0, x1, y1) { | |
| this.node = node; | |
| this.x0 = x0; | |
| this.y0 = y0; | |
| this.x1 = x1; | |
| this.y1 = y1; | |
| }; | |
| var tree_find = function(x, y, radius) { | |
| var data, | |
| x0 = this._x0, | |
| y0 = this._y0, | |
| x1, | |
| y1, | |
| x2, | |
| y2, | |
| x3 = this._x1, | |
| y3 = this._y1, | |
| quads = [], | |
| node = this._root, | |
| q, | |
| i; | |
| if (node) quads.push(new Quad(node, x0, y0, x3, y3)); | |
| if (radius == null) radius = Infinity; | |
| else { | |
| x0 = x - radius, y0 = y - radius; | |
| x3 = x + radius, y3 = y + radius; | |
| radius *= radius; | |
| } | |
| while (q = quads.pop()) { | |
| // Stop searching if this quadrant can’t contain a closer node. | |
| if (!(node = q.node) | |
| || (x1 = q.x0) > x3 | |
| || (y1 = q.y0) > y3 | |
| || (x2 = q.x1) < x0 | |
| || (y2 = q.y1) < y0) continue; | |
| // Bisect the current quadrant. | |
| if (node.length) { | |
| var xm = (x1 + x2) / 2, | |
| ym = (y1 + y2) / 2; | |
| quads.push( | |
| new Quad(node[3], xm, ym, x2, y2), | |
| new Quad(node[2], x1, ym, xm, y2), | |
| new Quad(node[1], xm, y1, x2, ym), | |
| new Quad(node[0], x1, y1, xm, ym) | |
| ); | |
| // Visit the closest quadrant first. | |
| if (i = (y >= ym) << 1 | (x >= xm)) { | |
| q = quads[quads.length - 1]; | |
| quads[quads.length - 1] = quads[quads.length - 1 - i]; | |
| quads[quads.length - 1 - i] = q; | |
| } | |
| } | |
| // Visit this point. (Visiting coincident points isn’t necessary!) | |
| else { | |
| var dx = x - +this._x.call(null, node.data), | |
| dy = y - +this._y.call(null, node.data), | |
| d2 = dx * dx + dy * dy; | |
| if (d2 < radius) { | |
| var d = Math.sqrt(radius = d2); | |
| x0 = x - d, y0 = y - d; | |
| x3 = x + d, y3 = y + d; | |
| data = node.data; | |
| } | |
| } | |
| } | |
| return data; | |
| }; | |
| var tree_remove = function(d) { | |
| if (isNaN(x = +this._x.call(null, d)) || isNaN(y = +this._y.call(null, d))) return this; // ignore invalid points | |
| var parent, | |
| node = this._root, | |
| retainer, | |
| previous, | |
| next, | |
| x0 = this._x0, | |
| y0 = this._y0, | |
| x1 = this._x1, | |
| y1 = this._y1, | |
| x, | |
| y, | |
| xm, | |
| ym, | |
| right, | |
| bottom, | |
| i, | |
| j; | |
| // If the tree is empty, initialize the root as a leaf. | |
| if (!node) return this; | |
| // Find the leaf node for the point. | |
| // While descending, also retain the deepest parent with a non-removed sibling. | |
| if (node.length) while (true) { | |
| if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; | |
| if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; | |
| if (!(parent = node, node = node[i = bottom << 1 | right])) return this; | |
| if (!node.length) break; | |
| if (parent[(i + 1) & 3] || parent[(i + 2) & 3] || parent[(i + 3) & 3]) retainer = parent, j = i; | |
| } | |
| // Find the point to remove. | |
| while (node.data !== d) if (!(previous = node, node = node.next)) return this; | |
| if (next = node.next) delete node.next; | |
| // If there are multiple coincident points, remove just the point. | |
| if (previous) return (next ? previous.next = next : delete previous.next), this; | |
| // If this is the root point, remove it. | |
| if (!parent) return this._root = next, this; | |
| // Remove this leaf. | |
| next ? parent[i] = next : delete parent[i]; | |
| // If the parent now contains exactly one leaf, collapse superfluous parents. | |
| if ((node = parent[0] || parent[1] || parent[2] || parent[3]) | |
| && node === (parent[3] || parent[2] || parent[1] || parent[0]) | |
| && !node.length) { | |
| if (retainer) retainer[j] = node; | |
| else this._root = node; | |
| } | |
| return this; | |
| }; | |
| function removeAll(data) { | |
| for (var i = 0, n = data.length; i < n; ++i) this.remove(data[i]); | |
| return this; | |
| } | |
| var tree_root = function() { | |
| return this._root; | |
| }; | |
| var tree_size = function() { | |
| var size = 0; | |
| this.visit(function(node) { | |
| if (!node.length) do ++size; while (node = node.next) | |
| }); | |
| return size; | |
| }; | |
| var tree_visit = function(callback) { | |
| var quads = [], q, node = this._root, child, x0, y0, x1, y1; | |
| if (node) quads.push(new Quad(node, this._x0, this._y0, this._x1, this._y1)); | |
| while (q = quads.pop()) { | |
| if (!callback(node = q.node, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1) && node.length) { | |
| var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2; | |
| if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1)); | |
| if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1)); | |
| if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym)); | |
| if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym)); | |
| } | |
| } | |
| return this; | |
| }; | |
| var tree_visitAfter = function(callback) { | |
| var quads = [], next = [], q; | |
| if (this._root) quads.push(new Quad(this._root, this._x0, this._y0, this._x1, this._y1)); | |
| while (q = quads.pop()) { | |
| var node = q.node; | |
| if (node.length) { | |
| var child, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2; | |
| if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym)); | |
| if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym)); | |
| if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1)); | |
| if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1)); | |
| } | |
| next.push(q); | |
| } | |
| while (q = next.pop()) { | |
| callback(q.node, q.x0, q.y0, q.x1, q.y1); | |
| } | |
| return this; | |
| }; | |
| function defaultX(d) { | |
| return d[0]; | |
| } | |
| var tree_x = function(_) { | |
| return arguments.length ? (this._x = _, this) : this._x; | |
| }; | |
| function defaultY(d) { | |
| return d[1]; | |
| } | |
| var tree_y = function(_) { | |
| return arguments.length ? (this._y = _, this) : this._y; | |
| }; | |
| function quadtree(nodes, x, y) { | |
| var tree = new Quadtree(x == null ? defaultX : x, y == null ? defaultY : y, NaN, NaN, NaN, NaN); | |
| return nodes == null ? tree : tree.addAll(nodes); | |
| } | |
| function Quadtree(x, y, x0, y0, x1, y1) { | |
| this._x = x; | |
| this._y = y; | |
| this._x0 = x0; | |
| this._y0 = y0; | |
| this._x1 = x1; | |
| this._y1 = y1; | |
| this._root = undefined; | |
| } | |
| function leaf_copy(leaf) { | |
| var copy = {data: leaf.data}, next = copy; | |
| while (leaf = leaf.next) next = next.next = {data: leaf.data}; | |
| return copy; | |
| } | |
| var treeProto = quadtree.prototype = Quadtree.prototype; | |
| treeProto.copy = function() { | |
| var copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1), | |
| node = this._root, | |
| nodes, | |
| child; | |
| if (!node) return copy; | |
| if (!node.length) return copy._root = leaf_copy(node), copy; | |
| nodes = [{source: node, target: copy._root = new Array(4)}]; | |
| while (node = nodes.pop()) { | |
| for (var i = 0; i < 4; ++i) { | |
| if (child = node.source[i]) { | |
| if (child.length) nodes.push({source: child, target: node.target[i] = new Array(4)}); | |
| else node.target[i] = leaf_copy(child); | |
| } | |
| } | |
| } | |
| return copy; | |
| }; | |
| treeProto.add = tree_add; | |
| treeProto.addAll = addAll; | |
| treeProto.cover = tree_cover; | |
| treeProto.data = tree_data; | |
| treeProto.extent = tree_extent; | |
| treeProto.find = tree_find; | |
| treeProto.remove = tree_remove; | |
| treeProto.removeAll = removeAll; | |
| treeProto.root = tree_root; | |
| treeProto.size = tree_size; | |
| treeProto.visit = tree_visit; | |
| treeProto.visitAfter = tree_visitAfter; | |
| treeProto.x = tree_x; | |
| treeProto.y = tree_y; | |
| function x(d) { | |
| return d.x + d.vx; | |
| } | |
| function y(d) { | |
| return d.y + d.vy; | |
| } | |
| var forceCollide = function(radius) { | |
| var nodes, | |
| radii, | |
| strength = 1, | |
| iterations = 1; | |
| if (typeof radius !== "function") radius = constant$7(radius == null ? 1 : +radius); | |
| function force() { | |
| var i, n = nodes.length, | |
| tree, | |
| node, | |
| xi, | |
| yi, | |
| ri, | |
| ri2; | |
| for (var k = 0; k < iterations; ++k) { | |
| tree = quadtree(nodes, x, y).visitAfter(prepare); | |
| for (i = 0; i < n; ++i) { | |
| node = nodes[i]; | |
| ri = radii[node.index], ri2 = ri * ri; | |
| xi = node.x + node.vx; | |
| yi = node.y + node.vy; | |
| tree.visit(apply); | |
| } | |
| } | |
| function apply(quad, x0, y0, x1, y1) { | |
| var data = quad.data, rj = quad.r, r = ri + rj; | |
| if (data) { | |
| if (data.index > node.index) { | |
| var x = xi - data.x - data.vx, | |
| y = yi - data.y - data.vy, | |
| l = x * x + y * y; | |
| if (l < r * r) { | |
| if (x === 0) x = jiggle$1(), l += x * x; | |
| if (y === 0) y = jiggle$1(), l += y * y; | |
| l = (r - (l = Math.sqrt(l))) / l * strength; | |
| node.vx += (x *= l) * (r = (rj *= rj) / (ri2 + rj)); | |
| node.vy += (y *= l) * r; | |
| data.vx -= x * (r = 1 - r); | |
| data.vy -= y * r; | |
| } | |
| } | |
| return; | |
| } | |
| return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r; | |
| } | |
| } | |
| function prepare(quad) { | |
| if (quad.data) return quad.r = radii[quad.data.index]; | |
| for (var i = quad.r = 0; i < 4; ++i) { | |
| if (quad[i] && quad[i].r > quad.r) { | |
| quad.r = quad[i].r; | |
| } | |
| } | |
| } | |
| function initialize() { | |
| if (!nodes) return; | |
| var i, n = nodes.length, node; | |
| radii = new Array(n); | |
| for (i = 0; i < n; ++i) node = nodes[i], radii[node.index] = +radius(node, i, nodes); | |
| } | |
| force.initialize = function(_) { | |
| nodes = _; | |
| initialize(); | |
| }; | |
| force.iterations = function(_) { | |
| return arguments.length ? (iterations = +_, force) : iterations; | |
| }; | |
| force.strength = function(_) { | |
| return arguments.length ? (strength = +_, force) : strength; | |
| }; | |
| force.radius = function(_) { | |
| return arguments.length ? (radius = typeof _ === "function" ? _ : constant$7(+_), initialize(), force) : radius; | |
| }; | |
| return force; | |
| }; | |
| var prefix$1 = "$"; | |
| function Map$1() {} | |
| Map$1.prototype = map$4.prototype = { | |
| constructor: Map$1, | |
| has: function(key) { | |
| return (prefix$1 + key) in this; | |
| }, | |
| get: function(key) { | |
| return this[prefix$1 + key]; | |
| }, | |
| set: function(key, value) { | |
| this[prefix$1 + key] = value; | |
| return this; | |
| }, | |
| remove: function(key) { | |
| var property = prefix$1 + key; | |
| return property in this && delete this[property]; | |
| }, | |
| clear: function() { | |
| for (var property in this) if (property[0] === prefix$1) delete this[property]; | |
| }, | |
| keys: function() { | |
| var keys = []; | |
| for (var property in this) if (property[0] === prefix$1) keys.push(property.slice(1)); | |
| return keys; | |
| }, | |
| values: function() { | |
| var values = []; | |
| for (var property in this) if (property[0] === prefix$1) values.push(this[property]); | |
| return values; | |
| }, | |
| entries: function() { | |
| var entries = []; | |
| for (var property in this) if (property[0] === prefix$1) entries.push({key: property.slice(1), value: this[property]}); | |
| return entries; | |
| }, | |
| size: function() { | |
| var size = 0; | |
| for (var property in this) if (property[0] === prefix$1) ++size; | |
| return size; | |
| }, | |
| empty: function() { | |
| for (var property in this) if (property[0] === prefix$1) return false; | |
| return true; | |
| }, | |
| each: function(f) { | |
| for (var property in this) if (property[0] === prefix$1) f(this[property], property.slice(1), this); | |
| } | |
| }; | |
| function map$4(object, f) { | |
| var map = new Map$1; | |
| // Copy constructor. | |
| if (object instanceof Map$1) object.each(function(value, key) { map.set(key, value); }); | |
| // Index array by numeric index or specified key function. | |
| else if (Array.isArray(object)) { | |
| var i = -1, | |
| n = object.length, | |
| o; | |
| if (f == null) while (++i < n) map.set(i, object[i]); | |
| else while (++i < n) map.set(f(o = object[i], i, object), o); | |
| } | |
| // Convert object to map. | |
| else if (object) for (var key in object) map.set(key, object[key]); | |
| return map; | |
| } | |
| function Set$1() {} | |
| var proto$1 = map$4.prototype; | |
| Set$1.prototype = set$6.prototype = { | |
| constructor: Set$1, | |
| has: proto$1.has, | |
| add: function(value) { | |
| value += ""; | |
| this[prefix$1 + value] = value; | |
| return this; | |
| }, | |
| remove: proto$1.remove, | |
| clear: proto$1.clear, | |
| values: proto$1.keys, | |
| size: proto$1.size, | |
| empty: proto$1.empty, | |
| each: proto$1.each | |
| }; | |
| function set$6(object, f) { | |
| var set = new Set$1; | |
| // Copy constructor. | |
| if (object instanceof Set$1) object.each(function(value) { set.add(value); }); | |
| // Otherwise, assume it’s an array. | |
| else if (object) { | |
| var i = -1, n = object.length; | |
| if (f == null) while (++i < n) set.add(object[i]); | |
| else while (++i < n) set.add(f(object[i], i, object)); | |
| } | |
| return set; | |
| } | |
| var initialRadius = 10; | |
| var initialAngle = Math.PI * (3 - Math.sqrt(5)); | |
| var forceSimulation = function(nodes) { | |
| var simulation, | |
| alpha = 1, | |
| alphaMin = 0.001, | |
| alphaDecay = 1 - Math.pow(alphaMin, 1 / 300), | |
| alphaTarget = 0, | |
| velocityDecay = 0.6, | |
| forces = map$4(), | |
| stepper = timer$1(step), | |
| event = dispatch$2("tick", "end"); | |
| if (nodes == null) nodes = []; | |
| function step() { | |
| tick(); | |
| event.call("tick", simulation); | |
| if (alpha < alphaMin) { | |
| stepper.stop(); | |
| event.call("end", simulation); | |
| } | |
| } | |
| function tick() { | |
| var i, n = nodes.length, node; | |
| alpha += (alphaTarget - alpha) * alphaDecay; | |
| forces.each(function(force) { | |
| force(alpha); | |
| }); | |
| for (i = 0; i < n; ++i) { | |
| node = nodes[i]; | |
| if (node.fx == null) node.x += node.vx *= velocityDecay; | |
| else node.x = node.fx, node.vx = 0; | |
| if (node.fy == null) node.y += node.vy *= velocityDecay; | |
| else node.y = node.fy, node.vy = 0; | |
| } | |
| } | |
| function initializeNodes() { | |
| for (var i = 0, n = nodes.length, node; i < n; ++i) { | |
| node = nodes[i], node.index = i; | |
| if (isNaN(node.x) || isNaN(node.y)) { | |
| var radius = initialRadius * Math.sqrt(i), angle = i * initialAngle; | |
| node.x = radius * Math.cos(angle); | |
| node.y = radius * Math.sin(angle); | |
| } | |
| if (isNaN(node.vx) || isNaN(node.vy)) { | |
| node.vx = node.vy = 0; | |
| } | |
| } | |
| } | |
| function initializeForce(force) { | |
| if (force.initialize) force.initialize(nodes); | |
| return force; | |
| } | |
| initializeNodes(); | |
| return simulation = { | |
| tick: tick, | |
| restart: function() { | |
| return stepper.restart(step), simulation; | |
| }, | |
| stop: function() { | |
| return stepper.stop(), simulation; | |
| }, | |
| nodes: function(_) { | |
| return arguments.length ? (nodes = _, initializeNodes(), forces.each(initializeForce), simulation) : nodes; | |
| }, | |
| alpha: function(_) { | |
| return arguments.length ? (alpha = +_, simulation) : alpha; | |
| }, | |
| alphaMin: function(_) { | |
| return arguments.length ? (alphaMin = +_, simulation) : alphaMin; | |
| }, | |
| alphaDecay: function(_) { | |
| return arguments.length ? (alphaDecay = +_, simulation) : +alphaDecay; | |
| }, | |
| alphaTarget: function(_) { | |
| return arguments.length ? (alphaTarget = +_, simulation) : alphaTarget; | |
| }, | |
| velocityDecay: function(_) { | |
| return arguments.length ? (velocityDecay = 1 - _, simulation) : 1 - velocityDecay; | |
| }, | |
| force: function(name, _) { | |
| return arguments.length > 1 ? ((_ == null ? forces.remove(name) : forces.set(name, initializeForce(_))), simulation) : forces.get(name); | |
| }, | |
| find: function(x, y, radius) { | |
| var i = 0, | |
| n = nodes.length, | |
| dx, | |
| dy, | |
| d2, | |
| node, | |
| closest; | |
| if (radius == null) radius = Infinity; | |
| else radius *= radius; | |
| for (i = 0; i < n; ++i) { | |
| node = nodes[i]; | |
| dx = x - node.x; | |
| dy = y - node.y; | |
| d2 = dx * dx + dy * dy; | |
| if (d2 < radius) closest = node, radius = d2; | |
| } | |
| return closest; | |
| }, | |
| on: function(name, _) { | |
| return arguments.length > 1 ? (event.on(name, _), simulation) : event.on(name); | |
| } | |
| }; | |
| }; | |
| var forceX = function(x) { | |
| var strength = constant$7(0.1), | |
| nodes, | |
| strengths, | |
| xz; | |
| if (typeof x !== "function") x = constant$7(x == null ? 0 : +x); | |
| function force(alpha) { | |
| for (var i = 0, n = nodes.length, node; i < n; ++i) { | |
| node = nodes[i], node.vx += (xz[i] - node.x) * strengths[i] * alpha; | |
| } | |
| } | |
| function initialize() { | |
| if (!nodes) return; | |
| var i, n = nodes.length; | |
| strengths = new Array(n); | |
| xz = new Array(n); | |
| for (i = 0; i < n; ++i) { | |
| strengths[i] = isNaN(xz[i] = +x(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes); | |
| } | |
| } | |
| force.initialize = function(_) { | |
| nodes = _; | |
| initialize(); | |
| }; | |
| force.strength = function(_) { | |
| return arguments.length ? (strength = typeof _ === "function" ? _ : constant$7(+_), initialize(), force) : strength; | |
| }; | |
| force.x = function(_) { | |
| return arguments.length ? (x = typeof _ === "function" ? _ : constant$7(+_), initialize(), force) : x; | |
| }; | |
| return force; | |
| }; | |
| var forceY = function(y) { | |
| var strength = constant$7(0.1), | |
| nodes, | |
| strengths, | |
| yz; | |
| if (typeof y !== "function") y = constant$7(y == null ? 0 : +y); | |
| function force(alpha) { | |
| for (var i = 0, n = nodes.length, node; i < n; ++i) { | |
| node = nodes[i], node.vy += (yz[i] - node.y) * strengths[i] * alpha; | |
| } | |
| } | |
| function initialize() { | |
| if (!nodes) return; | |
| var i, n = nodes.length; | |
| strengths = new Array(n); | |
| yz = new Array(n); | |
| for (i = 0; i < n; ++i) { | |
| strengths[i] = isNaN(yz[i] = +y(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes); | |
| } | |
| } | |
| force.initialize = function(_) { | |
| nodes = _; | |
| initialize(); | |
| }; | |
| force.strength = function(_) { | |
| return arguments.length ? (strength = typeof _ === "function" ? _ : constant$7(+_), initialize(), force) : strength; | |
| }; | |
| force.y = function(_) { | |
| return arguments.length ? (y = typeof _ === "function" ? _ : constant$7(+_), initialize(), force) : y; | |
| }; | |
| return force; | |
| }; | |
| var ascending$3 = function(a, b) { | |
| return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; | |
| }; | |
| var bisector$1 = function(compare) { | |
| if (compare.length === 1) compare = ascendingComparator$1(compare); | |
| return { | |
| left: function(a, x, lo, hi) { | |
| if (lo == null) lo = 0; | |
| if (hi == null) hi = a.length; | |
| while (lo < hi) { | |
| var mid = lo + hi >>> 1; | |
| if (compare(a[mid], x) < 0) lo = mid + 1; | |
| else hi = mid; | |
| } | |
| return lo; | |
| }, | |
| right: function(a, x, lo, hi) { | |
| if (lo == null) lo = 0; | |
| if (hi == null) hi = a.length; | |
| while (lo < hi) { | |
| var mid = lo + hi >>> 1; | |
| if (compare(a[mid], x) > 0) hi = mid; | |
| else lo = mid + 1; | |
| } | |
| return lo; | |
| } | |
| }; | |
| }; | |
| function ascendingComparator$1(f) { | |
| return function(d, x) { | |
| return ascending$3(f(d), x); | |
| }; | |
| } | |
| var ascendingBisect$1 = bisector$1(ascending$3); | |
| var bisectRight$1 = ascendingBisect$1.right; | |
| function pair$1(a, b) { | |
| return [a, b]; | |
| } | |
| var number$3 = function(x) { | |
| return x === null ? NaN : +x; | |
| }; | |
| var extent$1 = function(array, f) { | |
| var i = -1, | |
| n = array.length, | |
| a, | |
| b, | |
| c; | |
| if (f == null) { | |
| while (++i < n) if ((b = array[i]) != null && b >= b) { a = c = b; break; } | |
| while (++i < n) if ((b = array[i]) != null) { | |
| if (a > b) a = b; | |
| if (c < b) c = b; | |
| } | |
| } | |
| else { | |
| while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = c = b; break; } | |
| while (++i < n) if ((b = f(array[i], i, array)) != null) { | |
| if (a > b) a = b; | |
| if (c < b) c = b; | |
| } | |
| } | |
| return [a, c]; | |
| }; | |
| var identity$7 = function(x) { | |
| return x; | |
| }; | |
| var range = function(start, stop, step) { | |
| start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step; | |
| var i = -1, | |
| n = Math.max(0, Math.ceil((stop - start) / step)) | 0, | |
| range = new Array(n); | |
| while (++i < n) { | |
| range[i] = start + i * step; | |
| } | |
| return range; | |
| }; | |
| var e10$1 = Math.sqrt(50); | |
| var e5$1 = Math.sqrt(10); | |
| var e2$1 = Math.sqrt(2); | |
| var ticks$1 = function(start, stop, count) { | |
| var step = tickStep$1(start, stop, count); | |
| return range( | |
| Math.ceil(start / step) * step, | |
| Math.floor(stop / step) * step + step / 2, // inclusive | |
| step | |
| ); | |
| }; | |
| function tickStep$1(start, stop, count) { | |
| var step0 = Math.abs(stop - start) / Math.max(0, count), | |
| step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)), | |
| error = step0 / step1; | |
| if (error >= e10$1) step1 *= 10; | |
| else if (error >= e5$1) step1 *= 5; | |
| else if (error >= e2$1) step1 *= 2; | |
| return stop < start ? -step1 : step1; | |
| } | |
| var sturges$1 = function(values) { | |
| return Math.ceil(Math.log(values.length) / Math.LN2) + 1; | |
| }; | |
| var quantile$1 = function(array, p, f) { | |
| if (f == null) f = number$3; | |
| if (!(n = array.length)) return; | |
| if ((p = +p) <= 0 || n < 2) return +f(array[0], 0, array); | |
| if (p >= 1) return +f(array[n - 1], n - 1, array); | |
| var n, | |
| h = (n - 1) * p, | |
| i = Math.floor(h), | |
| a = +f(array[i], i, array), | |
| b = +f(array[i + 1], i + 1, array); | |
| return a + (b - a) * (h - i); | |
| }; | |
| var min$1 = function(array, f) { | |
| var i = -1, | |
| n = array.length, | |
| a, | |
| b; | |
| if (f == null) { | |
| while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; } | |
| while (++i < n) if ((b = array[i]) != null && a > b) a = b; | |
| } | |
| else { | |
| while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; } | |
| while (++i < n) if ((b = f(array[i], i, array)) != null && a > b) a = b; | |
| } | |
| return a; | |
| }; | |
| function length$1(d) { | |
| return d.length; | |
| } | |
| /** | |
| * Created by cool.blue on 3/04/2017. | |
| */ | |
| // animate | |
| const dummyNode = document.createElement('custom'); | |
| const Tinfl = 4000; | |
| const Tdefl = 4000; | |
| const tinfl = cat => [300, Tinfl][+!!cat]; | |
| const tdefl = cat => [300, Tdefl][+!!cat]; | |
| const inflate = cat => ["easeInOutCubic", "easeInOutCubic"][+!!cat]; | |
| const deflate = cat => ["easeInOutCubic", "easeOutQuad"][+!!cat]; | |
| const maxFactor = [1.2, 1.3]; | |
| var tick; | |
| var rmax$1; | |
| var renderer = 'Velocity'; | |
| var loop = {stop: ()=>{}}; | |
| var animate = function(options) { | |
| tick = options.tick || tick; | |
| rmax$1 = options.rmax || rmax$1; | |
| renderer = options.renderer || renderer; | |
| loop.stop(); | |
| // Drive the force simulation from here | |
| loop = animationLoop[renderer](); | |
| function _init() { | |
| let nodes = tick ? tick.nodes : undefined; | |
| if (typeof(nodes) === 'undefined') return; | |
| // feed in the cat 0 nodes a bit randomly | |
| nodes | |
| .filter(d => ((!d.scheduled || options.force) && Math.random() > 0.8)) | |
| .each(function (d) { | |
| window.setTimeout(function () { | |
| d.scheduled = true; | |
| }, 0); | |
| d.stopBreathing && d.stopBreathing(); | |
| breath[renderer].call(this, d); | |
| }); | |
| return this; | |
| } | |
| _init.unSchedule = function(d){ return(delete d.scheduled, d) }; | |
| return _init; | |
| }; | |
| const animationLoop = { | |
| Velocity: function () { | |
| // it needs a node as the first argument so just use a dummy one with dummy properties | |
| Velocity(dummyNode, {p: 0}, | |
| { | |
| progress: tick, | |
| loop: true | |
| }, 0); | |
| return {stop: function(){ Velocity(dummyNode, 'stop');}} | |
| }, | |
| d3: function tt(){ | |
| return timer$1(tick); | |
| }, | |
| d3Scale: function tt(){ | |
| return timer$1(tick); | |
| } | |
| }; | |
| function updateLine(d) { | |
| let l = select$1(this).attrs({ | |
| x1: -d.rt + rmax$1 / 10, | |
| x2: d.rt - rmax$1 / 10 | |
| }); | |
| // let x1 = l.attr('x1'), x2 = l.attr('x2'); | |
| // console.log((d.rt*2*0.8 - Math.abs(x1-x2))/(rmax)) | |
| } | |
| const breath = { | |
| Velocity: function (d) { | |
| let target = this; | |
| let circle = target.getElementsByTagName('circle')[0]; | |
| let line = target.getElementsByTagName('line')[0]; | |
| (function breath(){ | |
| Velocity(circle, | |
| {r: d.r0 * maxFactor[+!!d.category]}, | |
| { | |
| duration: tinfl(d.category), | |
| easing: inflate(d.category), | |
| progress: function () { | |
| updateLine.call(line, d); | |
| } | |
| }) | |
| .then(() => Velocity(circle, | |
| {r: d.r0}, | |
| { | |
| duration: tdefl(d.category), | |
| easing: deflate(d.category), | |
| progress: function () { | |
| updateLine.call(line, d); | |
| }, | |
| complete: breath | |
| })) | |
| .catch(e => console.log(e)); | |
| })(); | |
| d.stopBreathing = function(){ Velocity(target, 'stop', true);}; | |
| }, | |
| d3: function (d) { | |
| let target = this; | |
| let circle = select$1(target.getElementsByTagName('circle')[0]); | |
| let line = select$1(target.getElementsByTagName('line')[0]); | |
| let f = 1; | |
| (function breath() { | |
| let tInflate = transition$1('breath') | |
| .duration(tinfl(d.category) * f) | |
| .ease(d3Ease(inflate(d.category))), | |
| rInf = d.r0 * maxFactor[+!!d.category]; | |
| let tDeflate = transition$1('breath') | |
| .duration(tdefl(d.category) * f) | |
| .ease(d3Ease(deflate(d.category))); | |
| circle | |
| .transition(tInflate) | |
| .attr('r', rInf) | |
| .transition(tDeflate) | |
| .attr('r', d.r0) | |
| .on('end', breath); | |
| line | |
| .transition(tInflate) | |
| .attrs({ | |
| x1: -rInf + rmax$1 / 10, | |
| x2: rInf - rmax$1 / 10 | |
| }) | |
| .transition(tDeflate) | |
| .attrs({ | |
| x1: -d.r0 + rmax$1 / 10, | |
| x2: d.r0 - rmax$1 / 10 | |
| }); | |
| })(); | |
| d.stopBreathing = function () { | |
| circle.interrupt('breath'); | |
| line.interrupt('breath'); | |
| }; | |
| }, | |
| d3Scale: function (d) { | |
| let target = this; | |
| let circle = select$1(target.getElementsByTagName('circle')[0]); | |
| let line = select$1(target.getElementsByTagName('line')[0]); | |
| let f = 1; | |
| (function breath() { | |
| let tInflate = transition$1('breath') | |
| .duration(tinfl(d.category)*f) | |
| .ease(d3Ease(inflate(d.category))), | |
| scaleInf = maxFactor[+!!d.category]; | |
| let tDeflate = transition$1('breath') | |
| .duration(tdefl(d.category)*f) | |
| .ease(d3Ease(deflate(d.category))); | |
| circle | |
| .transition(tInflate) | |
| .attr('transform', "scale(" + scaleInf + ")") | |
| .transition(tDeflate) | |
| .attr('transform', "scale(1)") | |
| .on('end', breath); | |
| line | |
| .transition(tInflate) | |
| .attr('transform', "scale(" + scaleInf + ")") | |
| .transition(tDeflate) | |
| .attr('transform', "scale(1)"); | |
| })(); | |
| d.stopBreathing = function () { | |
| circle.interrupt('breath'); | |
| line.interrupt('breath'); | |
| }; | |
| } | |
| }; | |
| function d3Ease(easeName){ | |
| return ease[easeName.replace(/ease(In(?!O)|Out|InOut)(.*)/, "ease$2$1")] | |
| } | |
| /** | |
| * d3-select-element | |
| * | |
| * Created by cool.blue on 4/04/2017. | |
| * Example | |
| * <script src="https://gitcdn.xyz/repo/cool-Blue/d3-lib/master/inputs/select/select.js"></script> | |
| * | |
| * isoLines = d3.ui.select({ | |
| * base: inputs, | |
| * onUpdate: update, | |
| * data: [{text: "show lines", value: "#ccc"}, {text: "hide lines", value: "none"}] | |
| * }), | |
| * | |
| * .style("stroke", isoLines.value()); | |
| */ | |
| var selectElement = function (config) { | |
| // add a select element on base with options matching data | |
| // if the text and value is the same then data is scalar array | |
| // otherwise the data elements must have text and value fields | |
| // config | |
| // base | |
| // before | |
| // style | |
| // initial | |
| // hook | |
| // onX | |
| var selectElement = (config.base ? | |
| (config.base.append ? config.base : select$1(config.base)) : | |
| select$1("body")) | |
| [config.before ? "insert" : "append"]("select", config.before ? config.before : null) | |
| .each(hookEvents) | |
| .data([config.data]), | |
| options = selectElement.selectAll("option").data(function(d) {return d}); | |
| options = options.merge(options.enter().append("option")); | |
| options = options.enter().append("option").merge(options); | |
| options.exit().remove(); | |
| if(config.style) selectElement.styles(config.style); | |
| return merge(config, options, ["base", "before", "style", "initial", "hook", /on.+/]) | |
| .attrs({ | |
| value: function(d) { | |
| return d.value || d; | |
| }, | |
| selected: function(d){return d == config.initial ? "selected" : null} | |
| }) | |
| .text(function(d) { | |
| return d.text || d | |
| }) | |
| .call(function(selection$$1) { //add a custom property to the final selection | |
| if(config.hook) config.hook(); | |
| selection$$1.value = function() { | |
| return selectElement.property('value') | |
| }; | |
| }); | |
| function hookEvents() { | |
| // store the DOM element | |
| var _control = this; | |
| // config object for the control | |
| // parse the keys and bind a listener to any key beginning with "on" | |
| Object.keys(config).filter(function(k) { | |
| return k.slice(0, 2) == "on"; | |
| }).map(function(p, i, listeners) { | |
| // strip the event name off the listener | |
| var e = p.slice(2); | |
| if(!config.on) | |
| // lazily create a dispatch with the events found in config | |
| config.on = dispatch$2 | |
| .apply(null, listeners.map(function(l) { | |
| return l.slice(2); | |
| })); | |
| config.on.on(e, config[p]); | |
| // then hook the dispatch to the element event | |
| select$1(_control).on(e, function() { | |
| config.on.apply(e, this, arguments); | |
| }); | |
| }); | |
| } | |
| function merge(source, target, exclude) { | |
| function included(test){ | |
| return !exclude.some(function(p,i){return test.match(p)}) | |
| } | |
| for(var p in source) | |
| if(included(p) && target && !target.hasOwnProperty(p)) | |
| Object.defineProperty(target, p, Object.getOwnPropertyDescriptor(source, p)); | |
| return target; | |
| } | |
| }; | |
| /** | |
| * index | |
| * Created by cool.blue on 20/03/2017. | |
| */ | |
| // import collide from '../src/collide' | |
| const containerWidth = 960; | |
| // helpers | |
| let random = function (min$$1, max$$1) { | |
| if (max$$1 == null) { | |
| max$$1 = min$$1; | |
| min$$1 = 0; | |
| } | |
| return min$$1 + Math.floor(Math.random() * (max$$1 - min$$1 + 1)); | |
| }; | |
| let metrics = select$1('#bubble-cloud').append("div") | |
| .attr("id", "metrics"); | |
| let hist = Histogram("#metrics", {display: "block"}, { | |
| height: 10, width: 100, | |
| values: function (d) { | |
| return 1 / d | |
| }, | |
| domain: [0, 60] | |
| }) | |
| .message(function (value, this_lap, aveLap) { | |
| return 'alpha:' + format$1(" >7,.3f")(value) | |
| }); | |
| let rendererSelect = selectElement({ | |
| base: "#metrics", | |
| style: {float: "right", top: 0 + "px"}, | |
| onchange: function() { | |
| layout.restart(this.value); | |
| }, | |
| data: ["Velocity", "d3", "d3Scale"], | |
| initial: "Velocity" | |
| }); | |
| let colors = [ | |
| { | |
| fill: 'rgba(242,216,28,0.3)', | |
| stroke: 'rgba(242,216,28,1)' | |
| }, | |
| { | |
| fill: 'rgba(207,203,196,0.3)', | |
| stroke: 'rgba(207,203,196,1)' | |
| }, | |
| { | |
| fill: 'rgba(0,0,0,0.2)', | |
| stroke: 'rgba(100,100,100,1)' | |
| } | |
| ]; | |
| // initialize | |
| let container = select$1('#bubble-cloud'); | |
| let containerHeight = 470 - hist.selection.node().clientHeight; | |
| let svgContainer = container | |
| .append('svg') | |
| .attr('width', containerWidth) | |
| .attr('height', containerHeight) | |
| .attr('class', 'svg-container'); | |
| let jiggle = function() { | |
| return (Math.random() - 0.5) * 1e-6; | |
| }; | |
| const rScale = 0.3; | |
| const Rmin = 30; | |
| const Rmax = 60; | |
| const rmin = Rmin*rScale; | |
| const rmax = Rmax*rScale; | |
| const catRange = range(0, 3); | |
| const textRange = range(0, 24); | |
| const groups = 9; | |
| const groupDomain = range(groups + 1); | |
| const groupXY = groupDomain.map((d, i) => { | |
| return {x: containerWidth/2 + jiggle(), y: containerHeight/2 + jiggle()} | |
| }); | |
| const alphaCool = 0.7; | |
| let data = []; | |
| catRange.forEach(function(j){ | |
| textRange.forEach(function(i){ | |
| let r = random(rmin, rmax); | |
| let group = random(0, groups); | |
| data.push({ | |
| text: i, | |
| category: j, | |
| group: group, | |
| x: groupXY[group].x, //containerWidth/2 /*random(rmax, containerWidth - rmax)*/, | |
| y: groupXY[group].y /*random(rmax, containerHeight - rmax)*/, | |
| r: r, | |
| r0: r, | |
| get gX() { return groupXY[this.group].x}, | |
| get gY() { return groupXY[this.group].y}, | |
| fill: colors[j].fill, | |
| stroke: colors[j].stroke, | |
| get v() { | |
| let d = this; | |
| return {x: d.vx || 0, y: d.vy || 0} | |
| }, | |
| set v(v) { | |
| var d = this; | |
| d.vx = v.x; | |
| d.vy = v.y; | |
| }, | |
| get s() { | |
| var d = this; | |
| return Math.sqrt(d.vx * d.vx + d.vy * d.vy) | |
| }, | |
| set s(s1){ | |
| var s0 = this.s, v0 = this.v; | |
| if(!v0 || s0 == 0) { | |
| var theta = Math.random() * Math.PI * 2; | |
| this.v = {x: Math.cos(theta) * s1, y: Math.sin(theta) * s1}; | |
| } else this.v = {x: v0.x * s1/s0, y: v0.y * s1/s0}; | |
| }, | |
| set sx(s) { | |
| this.v = {x: s, y: this.v.y}; | |
| }, | |
| set sy(s) { | |
| this.v = {y: s, x: this.v.x}; | |
| }, | |
| }); | |
| }); | |
| }); | |
| function radius(d) { | |
| return d.rt*1.1; | |
| } | |
| let layout = (function(){ | |
| let nodes, node, circles, lines, force; | |
| // create item groups | |
| function init(data, restart){ | |
| if(!restart) | |
| data.forEach(function(d){ | |
| d.x = d.gX + jiggle(); | |
| d.y = d.gY + jiggle(); | |
| }); | |
| let G = d => [1, 10][+!!d.category] * baseG; | |
| force = forceSimulation(data) | |
| .force("X", forceX(d => groupXY[d.group].x) | |
| .strength(G)) //(baseG * 10)) | |
| .force("Y", forceY(d => groupXY[d.group].y) | |
| .strength(G)) | |
| .force("collide", forceCollide(radius).strength(1).iterations(1)) | |
| // .force("collide", collide(radius).strength(1).iterations(3)) | |
| .alphaTarget(0.05) | |
| // .velocityDecay(0.4) | |
| .alpha(0.05); | |
| force.stop(); | |
| nodes = svgContainer.selectAll('.nodes') | |
| .data([data]) | |
| .enter() | |
| .append('g') | |
| .attr('class', 'nodes'); | |
| node = nodes.selectAll('.node') | |
| .data(function(d) { return d; }) | |
| .enter() | |
| .append('g') | |
| .attr('class', 'node'); | |
| node.exit().remove(); | |
| // create circles | |
| circles = node.append('circle') | |
| .classed('circle', true) | |
| .attr('r', function (d) { | |
| return d.r; | |
| }) | |
| .style('fill', function (d) { | |
| return d.fill; | |
| }) | |
| .style('stroke', function (d) { | |
| return d.stroke; | |
| }) | |
| .attr('transform', "scale(1)") | |
| .each(function(d){ | |
| // add dynamic r getter | |
| let n= select$1(this); | |
| Object.defineProperty(d, "rt", {get: function(){ | |
| return +(n.attr("r").replace("px", "")) | |
| }}); | |
| }); | |
| // create labels | |
| node.append('text') | |
| .text(function(d) { | |
| return 'text' + d.text | |
| }) | |
| .classed('text', true) | |
| .styles({ | |
| 'fill': '#ffffff', | |
| 'text-anchor': 'middle', | |
| 'font-size': (12 * rScale) + 'px', | |
| 'font-weight': 'bold', | |
| 'text-transform': 'uppercase', | |
| 'font-family': 'Tahoma, Arial, sans-serif' | |
| }) | |
| .attr('x', function (d) { | |
| return 0; | |
| }) | |
| .attr('y', function (d) { | |
| return - rmax/5; | |
| }); | |
| node.append('text') | |
| .text(function(d) { | |
| return 'Cat ' + d.category | |
| }) | |
| .classed('category', true) | |
| .styles({ | |
| 'fill': '#ffffff', | |
| 'font-family': 'Tahoma, Arial, sans-serif', | |
| 'text-anchor': 'middle', | |
| 'font-size': (12 * rScale) + 'px' | |
| }) | |
| .attr('x', function (d) { | |
| return 0; | |
| }) | |
| .attr('y', function (d) { | |
| return rmax/3; | |
| }); | |
| lines = node.append('line') | |
| .classed('line', true) | |
| .attrs({ | |
| x1: function (d) { | |
| return - d.r + rmax/10; | |
| }, | |
| y1: function (d) { | |
| return 0; | |
| }, | |
| x2: function (d) { | |
| return d.r - rmax/10; | |
| }, | |
| y2: function (d) { | |
| return 0; | |
| } | |
| }) | |
| .attr('stroke-width', 1) | |
| .attr('stroke', function (d) { | |
| return d.stroke; | |
| }) | |
| .attr('transform', "scale(1)") | |
| .each(function(d){ | |
| // add dynamic x getter | |
| var n= select$1(this); | |
| Object.defineProperty(d, "lxt", {get: function(){ | |
| return {x1: +n.attr("x1").replace("px", ""), x2: +n.attr("x2").replace("px", "")} | |
| }}); | |
| }); | |
| function dragstarted() { | |
| outerForce.restart().alpha(0.1); | |
| event$1.subject.fx = event$1.subject.x; | |
| event$1.subject.fy = event$1.subject.y; | |
| } | |
| function dragged() { | |
| let d = event$1.subject; | |
| d.fx = event$1.x; | |
| d.fy = event$1.y; | |
| if(d.category == 0) return; | |
| groupXY[d.group].x = d.x; | |
| groupXY[d.group].y = d.y; | |
| force.force('X').initialize(force.nodes()); | |
| force.force('Y').initialize(force.nodes()); | |
| } | |
| function dragended() { | |
| let d = event$1.subject; | |
| d.fx = null; | |
| d.fy = null; | |
| groupXY[d.group].x = d.x; | |
| groupXY[d.group].y = d.y; | |
| force.force('X').initialize(force.nodes()); | |
| force.force('Y').initialize(force.nodes()); | |
| } | |
| svgContainer.call(drag() | |
| .subject(() => force.find(event$1.x, event$1.y)) | |
| .on("start", dragstarted) | |
| .on("drag", dragged) | |
| .on("end", dragended)); | |
| tick.force = force; | |
| tick.nodes = node; | |
| // force.force("collide").initialize(force.node()); | |
| t(); | |
| return {nodes: node, circles: circles, lines: lines, force: force} | |
| } | |
| // put circle into movement | |
| function t(){ | |
| if(typeof force == "undefined") return; | |
| const s0 = 0.25, k = 0.3; | |
| // regulate the speed of the circles | |
| data.forEach(function reg(d){ | |
| if(d.fx || d.fy) return; | |
| if(!d.escaped) d.s = ([s0*5, s0, s0][+d.category] - d.s * k) / (1 - k); | |
| }); | |
| force.force('X').initialize(force.nodes()); | |
| force.force('Y').initialize(force.nodes()); | |
| force.force("collide").initialize(force.nodes()); | |
| let a = force.alpha(); | |
| hist.mark(a); | |
| node | |
| .attr("transform", function position(d){ | |
| return "translate(" + [d.x, d.y] + ")" | |
| }); | |
| return this; | |
| } | |
| // remote tick function | |
| function tick(){ | |
| if(typeof force == "undefined") return; | |
| force.tick(); | |
| t(); | |
| } | |
| function restart(renderer){ | |
| // data = data.map(d => Object.assign({}, this.animate.unSchedule(d))); | |
| this.animate = animate({force: true, renderer: renderer}); | |
| outerForce.alpha(alphaCool).restart(); | |
| this._init(); | |
| } | |
| return { | |
| init: init, | |
| animate: animate({tick: tick, rmax: rmax, renderer: rendererSelect.value()}), | |
| restart: restart | |
| } | |
| })(); | |
| let baseG = 0.1; | |
| let groupR = 60; | |
| let outerForce = forceSimulation(groupXY) | |
| .force("center", forceCenter(containerWidth/2, containerHeight/2)) | |
| .force('X', forceX(containerWidth/2).strength(baseG*containerHeight/containerWidth)) | |
| .force('Y', forceY(containerHeight/2).strength(baseG*containerWidth/containerHeight)) | |
| .force("Gcollide", forceCollide(groupR*1.5)) | |
| // .alphaTarget(alphaTarget) | |
| .on('tick.main', function() { | |
| groupNodes.attr("transform", function position(d){return "translate(" + [d.x, d.y] + ")"}); | |
| if(this.alpha() > alphaCool) return; | |
| layout.animate(); // start the animations | |
| }) | |
| .on('tick.emerge', function(){ | |
| if(this.alpha() > alphaCool) return; | |
| layout.init(data); | |
| this.on('tick.emerge', null); | |
| }); | |
| // outer group | |
| let groupNodes = svgContainer.selectAll('.group-node') | |
| .data(groupXY) | |
| .enter() | |
| .append('circle') | |
| .attr('r', groupR) | |
| .attr('class', 'group-node'); | |
| hist.start(100); | |
| }))); |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <!DOCTYPE html> | |
| <html lang="en"> | |
| <head> | |
| <meta charset="UTF-8"> | |
| <title>http://stackoverflow.com/questions/32521887/animate-objects-in-force-layout-in-d3-js/32523428#32523428</title> | |
| <link rel="stylesheet" type="text/css" href="https://gitcdn.xyz/repo/cool-Blue/d3-lib/master/plot/fps-histogram.css"> | |
| <style> | |
| body { | |
| background: black; | |
| margin:0; | |
| padding:0; | |
| } | |
| #histogram rect{ | |
| will-change: height; | |
| -webkit-transition: all 0.1s linear; | |
| -moz-transition: all 0.1s linear; | |
| -o-transition: all 0.1s linear; | |
| transition: all 0.1s linear; | |
| outline: 1px red; | |
| } | |
| #bubble-cloud { | |
| background: url("http://dummyimage.com/100x100/111/494d05?text=sample") 0 0; | |
| width: 960px; | |
| height: 470px; | |
| /*overflow: hidden;*/ | |
| position: relative; | |
| margin:0 auto; | |
| } | |
| svg { | |
| outline: rgba(242,216,28,1); | |
| overflow: visible; | |
| } | |
| .group-node { | |
| stroke: red; | |
| fill: none; | |
| } | |
| .nodes circle { | |
| cursor: pointer; | |
| will-change: r, cx, cy; | |
| /*will-change: transform;*/ | |
| } | |
| .nodes line { | |
| cursor: pointer; | |
| will-change: x1, x2; | |
| /*will-change: transform;*/ | |
| } | |
| .nodes text { | |
| pointer-events: none; | |
| } | |
| </style> | |
| </head> | |
| <body> | |
| <div id="bubble-cloud"></div> | |
| <script src="https://cdnjs.cloudflare.com/ajax/libs/velocity/1.5.0/velocity.min.js"></script> | |
| <script src="https://cdnjs.cloudflare.com/ajax/libs/velocity/1.5.0/velocity.ui.min.js"></script> | |
| <script src="bundle.js"></script> | |
| </body> | |
| </html> |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment