@d3plus/dom 3.0.0-alpha.0

package/umd/d3plus-dom.full.js

@@ -0,0 +1,2690 @@
+/*
+  @d3plus/dom v3.0.0
+  JavaScript functions for manipulating and analyzing DOM elements.
+  Copyright (c) 2025 D3plus - https://d3plus.org
+  @license MIT
+*/
+
+(function (factory) {
+  typeof define === 'function' && define.amd ? define(factory) :
+  factory();
+})((function () { 'use strict';
+
+  if (typeof window !== "undefined") {
+    (function () {
+      try {
+        if (typeof SVGElement === 'undefined' || Boolean(SVGElement.prototype.innerHTML)) {
+          return;
+        }
+      } catch (e) {
+          return;
+      }
+
+      function serializeNode (node) {
+        switch (node.nodeType) {
+          case 1:
+            return serializeElementNode(node);
+          case 3:
+            return serializeTextNode(node);
+          case 8:
+            return serializeCommentNode(node);
+        }
+      }
+
+      function serializeTextNode (node) {
+          return node.textContent.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+      }
+
+      function serializeCommentNode (node) {
+          return '<!--' + node.nodeValue + '-->'
+      }
+
+      function serializeElementNode (node) {
+          var output = '';
+
+          output += '<' + node.tagName;
+
+          if (node.hasAttributes()) {
+              [].forEach.call(node.attributes, function(attrNode) {
+                  output += ' ' + attrNode.name + '="' + attrNode.value + '"';
+              });
+          }
+
+          output += '>';
+
+          if (node.hasChildNodes()) {
+              [].forEach.call(node.childNodes, function(childNode) {
+                  output += serializeNode(childNode);
+              });
+          }
+
+          output += '</' + node.tagName + '>';
+
+          return output;
+      }
+
+      Object.defineProperty(SVGElement.prototype, 'innerHTML', {
+        get: function () {
+          var output = '';
+
+          [].forEach.call(this.childNodes, function(childNode) {
+              output += serializeNode(childNode);
+          });
+
+          return output;
+        },
+        set: function (markup) {
+          while (this.firstChild) {
+            this.removeChild(this.firstChild);
+          }
+
+          try {
+            var dXML = new DOMParser();
+            dXML.async = false;
+
+            var sXML = '<svg xmlns=\'http://www.w3.org/2000/svg\' xmlns:xlink=\'http://www.w3.org/1999/xlink\'>' + markup + '</svg>';
+            var svgDocElement = dXML.parseFromString(sXML, 'text/xml').documentElement;
+
+            [].forEach.call(svgDocElement.childNodes, function(childNode) {
+                this.appendChild(this.ownerDocument.importNode(childNode, true));
+            }.bind(this));
+          } catch (e) {
+              throw new Error('Error parsing markup string');
+          }
+        }
+      });
+
+      Object.defineProperty(SVGElement.prototype, 'innerSVG', {
+        get: function () {
+          return this.innerHTML;
+        },
+        set: function (markup) {
+          this.innerHTML = markup;
+        }
+      });
+
+    })();
+  }
+
+}));
+
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define('@d3plus/dom', ['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.d3plus = {}));
+})(this, (function (exports) {
+  /**
+      @function isObject
+      @desc Detects if a variable is a javascript Object.
+      @param {*} item
+  */ function isObject(item) {
+      return item && typeof item === "object" && (typeof window === "undefined" || item !== window && item !== window.document && !(item instanceof Element)) && !Array.isArray(item) ? true : false;
+  }
+
+  /**
+      @function validObject
+      @desc Determines if the object passed is the document or window.
+      @param {Object} obj
+      @private
+  */ function validObject(obj) {
+      if (typeof window === "undefined") return true;
+      else return obj !== window && obj !== document;
+  }
+  /**
+      @function assign
+      @desc A deeply recursive version of `Object.assign`.
+      @param {...Object} objects
+      @example <caption>this</caption>
+  assign({id: "foo", deep: {group: "A"}}, {id: "bar", deep: {value: 20}}));
+      @example <caption>returns this</caption>
+  {id: "bar", deep: {group: "A", value: 20}}
+  */ function assign(...objects) {
+      const target = objects[0];
+      for(let i = 1; i < objects.length; i++){
+          const source = objects[i];
+          if (!isObject(source)) continue;
+          Object.keys(source).forEach((prop)=>{
+              const value = source[prop];
+              if (isObject(value) && validObject(value)) {
+                  if (Object.prototype.hasOwnProperty.call(target, prop) && isObject(target[prop])) target[prop] = assign({}, target[prop], value);
+                  else target[prop] = assign({}, value);
+              } else if (Array.isArray(value)) target[prop] = value.slice();
+              else target[prop] = value;
+          });
+      }
+      return target;
+  }
+
+  /**
+      @function attrize
+      @desc Applies each key/value in an object as an attr.
+      @param {D3selection} elem The D3 element to apply the styles to.
+      @param {Object} attrs An object of key/value attr pairs.
+  */ function attrize(e, a = {}) {
+      for(const k in a)if (({}).hasOwnProperty.call(a, k)) e.attr(k, a[k]);
+  }
+
+  /**
+      @function date
+      @summary Parses numbers and strings to valid Javascript Date objects.
+      @description Returns a javascript Date object for a given a Number (representing either a 4-digit year or milliseconds since epoch), a String representing a Quarter (ie. "Q2 1987", mapping to the last day in that quarter), or a String that is in [valid dateString format](http://dygraphs.com/date-formats.html). Besides the 4-digit year parsing, this function is useful when needing to parse negative (BC) years, which the vanilla Date object cannot parse.
+      @param {Number|String} *date*
+  */ function date(d) {
+      // returns if falsey or already Date object
+      if ([
+          false,
+          undefined,
+          NaN
+      ].includes(d) || d.constructor === Date) return d;
+      else if (d.constructor === Number && `${d}`.length > 5 && d % 1 === 0) return new Date(d);
+      let s = `${d}`;
+      // tests for MM/DD/YYYY and MM-DD-YYYY format
+      const dayFormat = new RegExp(/^\d{1,2}[./-]\d{1,2}[./-](-*\d{1,4})$/g).exec(s);
+      if (dayFormat) {
+          const year = dayFormat[1];
+          if (year.indexOf("-") === 0) s = s.replace(year, year.substring(1));
+          const date = new Date(s);
+          date.setFullYear(year);
+          return date;
+      }
+      // tests for full Date object string format
+      const strFormat = new RegExp(/^[A-z]{1,3} [A-z]{1,3} \d{1,2} (-*\d{1,4}) \d{1,2}:\d{1,2}:\d{1,2} [A-z]{1,3}-*\d{1,4} \([A-z]{1,3}\)/g).exec(s);
+      if (strFormat) {
+          const year = strFormat[1];
+          if (year.indexOf("-") === 0) s = s.replace(year, year.substring(1));
+          const date = new Date(s);
+          date.setFullYear(year);
+          return date;
+      }
+      // tests for quarterly formats (ie. "QX YYYY")
+      const quarterPrefix = new RegExp(/^([qQ]{1}[1-4]{1}|[1-4]{1}[qQ]{1})[\s|-]{0,1}(-*\d{1,4})$/g).exec(s);
+      const quarterSuffix = new RegExp(/^(-*\d{1,4})[\s|-]{0,1}([qQ]{1}[1-4]{1}|[1-4]{1}[qQ]{1})$/g).exec(s);
+      if (quarterPrefix || quarterSuffix) {
+          const quarter = +(quarterPrefix ? quarterPrefix[1] : quarterSuffix[2]).toLowerCase().replace("q", "");
+          const year = +(quarterPrefix ? quarterPrefix[2] : quarterSuffix[1]);
+          const date = new Date(year, quarter * 3 - 3, 1);
+          date.setFullYear(year);
+          return date;
+      }
+      // detects if only passing a year value
+      if (!s.includes("/") && !s.includes(" ") && (!s.includes("-") || !s.indexOf("-"))) {
+          const date = new Date(+s, 0, 1);
+          date.setFullYear(d);
+          return date;
+      }
+      // falls back to Date object
+      return new Date(s);
+  }
+
+  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/"
+  };
+
+  function namespace(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; // eslint-disable-line no-prototype-builtins
+  }
+
+  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);
+      };
+  }
+  function creator(name) {
+      var fullname = namespace(name);
+      return (fullname.local ? creatorFixed : creatorInherit)(fullname);
+  }
+
+  function none() {}
+  function selector(selector) {
+      return selector == null ? none : function() {
+          return this.querySelector(selector);
+      };
+  }
+
+  function selection_select(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$1(subgroups, this._parents);
+  }
+
+  // Given something array like (or null), returns something that is strictly an
+  // array. This is used to ensure that array-like objects passed to d3.selectAll
+  // or selection.selectAll are converted into proper arrays when creating a
+  // selection; we don’t ever want to create a selection backed by a live
+  // HTMLCollection or NodeList. However, note that selection.selectAll will use a
+  // static NodeList as a group, since it safely derived from querySelectorAll.
+  function array(x) {
+      return x == null ? [] : Array.isArray(x) ? x : Array.from(x);
+  }
+
+  function empty() {
+      return [];
+  }
+  function selectorAll(selector) {
+      return selector == null ? empty : function() {
+          return this.querySelectorAll(selector);
+      };
+  }
+
+  function arrayAll(select) {
+      return function() {
+          return array(select.apply(this, arguments));
+      };
+  }
+  function selection_selectAll(select) {
+      if (typeof select === "function") select = arrayAll(select);
+      else 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$1(subgroups, parents);
+  }
+
+  function matcher(selector) {
+      return function() {
+          return this.matches(selector);
+      };
+  }
+  function childMatcher(selector) {
+      return function(node) {
+          return node.matches(selector);
+      };
+  }
+
+  var find = Array.prototype.find;
+  function childFind(match) {
+      return function() {
+          return find.call(this.children, match);
+      };
+  }
+  function childFirst() {
+      return this.firstElementChild;
+  }
+  function selection_selectChild(match) {
+      return this.select(match == null ? childFirst : childFind(typeof match === "function" ? match : childMatcher(match)));
+  }
+
+  var filter = Array.prototype.filter;
+  function children() {
+      return Array.from(this.children);
+  }
+  function childrenFilter(match) {
+      return function() {
+          return filter.call(this.children, match);
+      };
+  }
+  function selection_selectChildren(match) {
+      return this.selectAll(match == null ? children : childrenFilter(typeof match === "function" ? match : childMatcher(match)));
+  }
+
+  function selection_filter(match) {
+      if (typeof match !== "function") match = matcher(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$1(subgroups, this._parents);
+  }
+
+  function sparse(update) {
+      return new Array(update.length);
+  }
+
+  function selection_enter() {
+      return new Selection$1(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);
+      }
+  };
+
+  function constant$1(x) {
+      return function() {
+          return x;
+      };
+  }
+
+  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 = new Map, 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 = key.call(node, node.__data__, i, group) + "";
+              if (nodeByKeyValue.has(keyValue)) {
+                  exit[i] = node;
+              } else {
+                  nodeByKeyValue.set(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 = key.call(parent, data[i], i, data) + "";
+          if (node = nodeByKeyValue.get(keyValue)) {
+              update[i] = node;
+              node.__data__ = data[i];
+              nodeByKeyValue.delete(keyValue);
+          } 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.get(keyValues[i]) === node) {
+              exit[i] = node;
+          }
+      }
+  }
+  function datum(node) {
+      return node.__data__;
+  }
+  function selection_data(value, key) {
+      if (!arguments.length) return Array.from(this, datum);
+      var bind = key ? bindKey : bindIndex, parents = this._parents, groups = this._groups;
+      if (typeof value !== "function") value = constant$1(value);
+      for(var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j){
+          var parent = parents[j], group = groups[j], groupLength = group.length, data = arraylike(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$1(update, parents);
+      update._enter = enter;
+      update._exit = exit;
+      return update;
+  }
+  // Given some data, this returns an array-like view of it: an object that
+  // exposes a length property and allows numeric indexing. Note that unlike
+  // selectAll, this isn’t worried about “live” collections because the resulting
+  // array will only be used briefly while data is being bound. (It is possible to
+  // cause the data to change while iterating by using a key function, but please
+  // don’t; we’d rather avoid a gratuitous copy.)
+  function arraylike(data) {
+      return typeof data === "object" && "length" in data ? data // Array, TypedArray, NodeList, array-like
+       : Array.from(data); // Map, Set, iterable, string, or anything else
+  }
+
+  function selection_exit() {
+      return new Selection$1(this._exit || this._groups.map(sparse), this._parents);
+  }
+
+  function selection_join(onenter, onupdate, onexit) {
+      var enter = this.enter(), update = this, exit = this.exit();
+      if (typeof onenter === "function") {
+          enter = onenter(enter);
+          if (enter) enter = enter.selection();
+      } else {
+          enter = enter.append(onenter + "");
+      }
+      if (onupdate != null) {
+          update = onupdate(update);
+          if (update) update = update.selection();
+      }
+      if (onexit == null) exit.remove();
+      else onexit(exit);
+      return enter && update ? enter.merge(update).order() : update;
+  }
+
+  function selection_merge(context) {
+      var selection = context.selection ? context.selection() : context;
+      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$1(merges, this._parents);
+  }
+
+  function selection_order() {
+      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 && node.compareDocumentPosition(next) ^ 4) next.parentNode.insertBefore(node, next);
+                  next = node;
+              }
+          }
+      }
+      return this;
+  }
+
+  function selection_sort(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$1(sortgroups, this._parents).order();
+  }
+  function ascending(a, b) {
+      return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+  }
+
+  function selection_call() {
+      var callback = arguments[0];
+      arguments[0] = this;
+      callback.apply(null, arguments);
+      return this;
+  }
+
+  function selection_nodes() {
+      return Array.from(this);
+  }
+
+  function selection_node() {
+      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;
+  }
+
+  function selection_size() {
+      let size = 0;
+      for (const node of this)++size; // eslint-disable-line no-unused-vars
+      return size;
+  }
+
+  function selection_empty() {
+      return !this.node();
+  }
+
+  function selection_each(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$1(name) {
+      return function() {
+          this.removeAttribute(name);
+      };
+  }
+  function attrRemoveNS$1(fullname) {
+      return function() {
+          this.removeAttributeNS(fullname.space, fullname.local);
+      };
+  }
+  function attrConstant$1(name, value) {
+      return function() {
+          this.setAttribute(name, value);
+      };
+  }
+  function attrConstantNS$1(fullname, value) {
+      return function() {
+          this.setAttributeNS(fullname.space, fullname.local, value);
+      };
+  }
+  function attrFunction$1(name, value) {
+      return function() {
+          var v = value.apply(this, arguments);
+          if (v == null) this.removeAttribute(name);
+          else this.setAttribute(name, v);
+      };
+  }
+  function attrFunctionNS$1(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);
+      };
+  }
+  function selection_attr(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$1 : attrRemove$1 : typeof value === "function" ? fullname.local ? attrFunctionNS$1 : attrFunction$1 : fullname.local ? attrConstantNS$1 : attrConstant$1)(fullname, value));
+  }
+
+  function defaultView(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$1(name) {
+      return function() {
+          this.style.removeProperty(name);
+      };
+  }
+  function styleConstant$1(name, value, priority) {
+      return function() {
+          this.style.setProperty(name, value, priority);
+      };
+  }
+  function styleFunction$1(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);
+      };
+  }
+  function selection_style(name, value, priority) {
+      return arguments.length > 1 ? this.each((value == null ? styleRemove$1 : typeof value === "function" ? styleFunction$1 : styleConstant$1)(name, value, priority == null ? "" : priority)) : styleValue(this.node(), name);
+  }
+  function styleValue(node, name) {
+      return node.style.getPropertyValue(name) || defaultView(node).getComputedStyle(node, null).getPropertyValue(name);
+  }
+
+  function propertyRemove(name) {
+      return function() {
+          delete this[name];
+      };
+  }
+  function propertyConstant(name, value) {
+      return function() {
+          this[name] = value;
+      };
+  }
+  function propertyFunction(name, value) {
+      return function() {
+          var v = value.apply(this, arguments);
+          if (v == null) delete this[name];
+          else this[name] = v;
+      };
+  }
+  function selection_property(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);
+      };
+  }
+  function selection_classed(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$1(value) {
+      return function() {
+          this.textContent = value;
+      };
+  }
+  function textFunction$1(value) {
+      return function() {
+          var v = value.apply(this, arguments);
+          this.textContent = v == null ? "" : v;
+      };
+  }
+  function selection_text(value) {
+      return arguments.length ? this.each(value == null ? textRemove : (typeof value === "function" ? textFunction$1 : textConstant$1)(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;
+      };
+  }
+  function selection_html(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);
+  }
+  function selection_raise() {
+      return this.each(raise);
+  }
+
+  function lower() {
+      if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild);
+  }
+  function selection_lower() {
+      return this.each(lower);
+  }
+
+  function selection_append(name) {
+      var create = typeof name === "function" ? name : creator(name);
+      return this.select(function() {
+          return this.appendChild(create.apply(this, arguments));
+      });
+  }
+
+  function constantNull() {
+      return null;
+  }
+  function selection_insert(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);
+  }
+  function selection_remove() {
+      return this.each(remove);
+  }
+
+  function selection_cloneShallow() {
+      var clone = this.cloneNode(false), parent = this.parentNode;
+      return parent ? parent.insertBefore(clone, this.nextSibling) : clone;
+  }
+  function selection_cloneDeep() {
+      var clone = this.cloneNode(true), parent = this.parentNode;
+      return parent ? parent.insertBefore(clone, this.nextSibling) : clone;
+  }
+  function selection_clone(deep) {
+      return this.select(deep ? selection_cloneDeep : selection_cloneShallow);
+  }
+
+  function selection_datum(value) {
+      return arguments.length ? this.property("__data__", value) : this.node().__data__;
+  }
+
+  function contextListener(listener) {
+      return function(event) {
+          listener.call(this, event, this.__data__);
+      };
+  }
+  function parseTypenames$1(typenames) {
+      return typenames.trim().split(/^|\s+/).map(function(t) {
+          var name = "", i = t.indexOf(".");
+          if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);
+          return {
+              type: t,
+              name: name
+          };
+      });
+  }
+  function onRemove(typename) {
+      return function() {
+          var on = this.__on;
+          if (!on) return;
+          for(var j = 0, i = -1, m = on.length, o; j < m; ++j){
+              if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {
+                  this.removeEventListener(o.type, o.listener, o.options);
+              } else {
+                  on[++i] = o;
+              }
+          }
+          if (++i) on.length = i;
+          else delete this.__on;
+      };
+  }
+  function onAdd(typename, value, options) {
+      return function() {
+          var on = this.__on, o, listener = contextListener(value);
+          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.options);
+                  this.addEventListener(o.type, o.listener = listener, o.options = options);
+                  o.value = value;
+                  return;
+              }
+          }
+          this.addEventListener(typename.type, listener, options);
+          o = {
+              type: typename.type,
+              name: typename.name,
+              value: value,
+              listener: listener,
+              options: options
+          };
+          if (!on) this.__on = [
+              o
+          ];
+          else on.push(o);
+      };
+  }
+  function selection_on(typename, value, options) {
+      var typenames = parseTypenames$1(typename + ""), i, n = typenames.length, t;
+      if (arguments.length < 2) {
+          var on = this.node().__on;
+          if (on) for(var j = 0, m = on.length, o; j < m; ++j){
+              for(i = 0, o = on[j]; i < n; ++i){
+                  if ((t = typenames[i]).type === o.type && t.name === o.name) {
+                      return o.value;
+                  }
+              }
+          }
+          return;
+      }
+      on = value ? onAdd : onRemove;
+      for(i = 0; i < n; ++i)this.each(on(typenames[i], value, options));
+      return this;
+  }
+
+  function dispatchEvent(node, type, params) {
+      var window = defaultView(node), event = window.CustomEvent;
+      if (typeof event === "function") {
+          event = new event(type, params);
+      } else {
+          event = window.document.createEvent("Event");
+          if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail;
+          else event.initEvent(type, false, false);
+      }
+      node.dispatchEvent(event);
+  }
+  function dispatchConstant(type, params) {
+      return function() {
+          return dispatchEvent(this, type, params);
+      };
+  }
+  function dispatchFunction(type, params) {
+      return function() {
+          return dispatchEvent(this, type, params.apply(this, arguments));
+      };
+  }
+  function selection_dispatch(type, params) {
+      return this.each((typeof params === "function" ? dispatchFunction : dispatchConstant)(type, params));
+  }
+
+  function* selection_iterator() {
+      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]) yield node;
+          }
+      }
+  }
+
+  var root = [
+      null
+  ];
+  function Selection$1(groups, parents) {
+      this._groups = groups;
+      this._parents = parents;
+  }
+  function selection() {
+      return new Selection$1([
+          [
+              document.documentElement
+          ]
+      ], root);
+  }
+  function selection_selection() {
+      return this;
+  }
+  Selection$1.prototype = selection.prototype = {
+      constructor: Selection$1,
+      select: selection_select,
+      selectAll: selection_selectAll,
+      selectChild: selection_selectChild,
+      selectChildren: selection_selectChildren,
+      filter: selection_filter,
+      data: selection_data,
+      enter: selection_enter,
+      exit: selection_exit,
+      join: selection_join,
+      merge: selection_merge,
+      selection: selection_selection,
+      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,
+      clone: selection_clone,
+      datum: selection_datum,
+      on: selection_on,
+      dispatch: selection_dispatch,
+      [Symbol.iterator]: selection_iterator
+  };
+
+  function select(selector) {
+      return typeof selector === "string" ? new Selection$1([
+          [
+              document.querySelector(selector)
+          ]
+      ], [
+          document.documentElement
+      ]) : new Selection$1([
+          [
+              selector
+          ]
+      ], root);
+  }
+
+  var noop = {
+      value: ()=>{}
+  };
+  function dispatch() {
+      for(var i = 0, n = arguments.length, _ = {}, t; i < n; ++i){
+          if (!(t = arguments[i] + "") || t in _ || /[\s.]/.test(t)) throw new Error("illegal type: " + t);
+          _[t] = [];
+      }
+      return new Dispatch(_);
+  }
+  function Dispatch(_) {
+      this._ = _;
+  }
+  function parseTypenames(typenames, types) {
+      return typenames.trim().split(/^|\s+/).map(function(t) {
+          var name = "", i = t.indexOf(".");
+          if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);
+          if (t && !types.hasOwnProperty(t)) throw new Error("unknown type: " + t);
+          return {
+              type: t,
+              name: name
+          };
+      });
+  }
+  Dispatch.prototype = dispatch.prototype = {
+      constructor: Dispatch,
+      on: function(typename, callback) {
+          var _ = this._, T = parseTypenames(typename + "", _), t, i = -1, n = T.length;
+          // If no callback was specified, return the callback of the given type and name.
+          if (arguments.length < 2) {
+              while(++i < n)if ((t = (typename = T[i]).type) && (t = get$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, timeout$1 = 0, interval = 0, pokeDelay = 1000, taskHead, taskTail, clockLast = 0, clockNow = 0, clockSkew = 0, clock = typeof performance === "object" && performance.now ? performance : Date, setFrame = typeof window === "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f) {
+      setTimeout(f, 17);
+  };
+  function now() {
+      return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);
+  }
+  function clearNow() {
+      clockNow = 0;
+  }
+  function Timer() {
+      this._call = this._time = this._next = null;
+  }
+  Timer.prototype = timer.prototype = {
+      constructor: Timer,
+      restart: function(callback, delay, time) {
+          if (typeof callback !== "function") throw new TypeError("callback is not a function");
+          time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);
+          if (!this._next && taskTail !== this) {
+              if (taskTail) taskTail._next = this;
+              else taskHead = this;
+              taskTail = this;
+          }
+          this._call = callback;
+          this._time = time;
+          sleep();
+      },
+      stop: function() {
+          if (this._call) {
+              this._call = null;
+              this._time = Infinity;
+              sleep();
+          }
+      }
+  };
+  function timer(callback, delay, time) {
+      var t = new Timer;
+      t.restart(callback, delay, time);
+      return t;
+  }
+  function timerFlush() {
+      now(); // Get the current time, if not already set.
+      ++frame; // Pretend we’ve set an alarm, if we haven’t already.
+      var t = taskHead, e;
+      while(t){
+          if ((e = clockNow - t._time) >= 0) t._call.call(undefined, e);
+          t = t._next;
+      }
+      --frame;
+  }
+  function wake() {
+      clockNow = (clockLast = clock.now()) + clockSkew;
+      frame = timeout$1 = 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$1) timeout$1 = clearTimeout(timeout$1);
+      var delay = time - clockNow; // Strictly less than if we recomputed clockNow.
+      if (delay > 24) {
+          if (time < Infinity) timeout$1 = setTimeout(wake, time - clock.now() - clockSkew);
+          if (interval) interval = clearInterval(interval);
+      } else {
+          if (!interval) clockLast = clock.now(), interval = setInterval(poke, pokeDelay);
+          frame = 1, setFrame(wake);
+      }
+  }
+
+  function timeout(callback, delay, time) {
+      var t = new Timer;
+      delay = delay == null ? 0 : +delay;
+      t.restart((elapsed)=>{
+          t.stop();
+          callback(elapsed + delay);
+      }, delay, time);
+      return t;
+  }
+
+  var emptyOn = dispatch("start", "end", "cancel", "interrupt");
+  var emptyTween = [];
+  var CREATED = 0;
+  var SCHEDULED = 1;
+  var STARTING = 2;
+  var STARTED = 3;
+  var RUNNING = 4;
+  var ENDING = 5;
+  var ENDED = 6;
+  function schedule(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,
+          group: group,
+          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 = get(node, id);
+      if (schedule.state > CREATED) throw new Error("too late; already scheduled");
+      return schedule;
+  }
+  function set(node, id) {
+      var schedule = get(node, id);
+      if (schedule.state > STARTED) throw new Error("too late; already running");
+      return schedule;
+  }
+  function get(node, id) {
+      var schedule = node.__transition;
+      if (!schedule || !(schedule = schedule[id])) throw new Error("transition not found");
+      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(start);
+              // Interrupt the active transition, if any.
+              if (o.state === RUNNING) {
+                  o.state = ENDED;
+                  o.timer.stop();
+                  o.on.call("interrupt", node, node.__data__, o.index, o.group);
+                  delete schedules[i];
+              } else if (+i < id) {
+                  o.state = ENDED;
+                  o.timer.stop();
+                  o.on.call("cancel", node, node.__data__, o.index, o.group);
+                  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(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(node, 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;
+      }
+  }
+
+  function interrupt(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();
+          schedule.on.call(active ? "interrupt" : "cancel", node, node.__data__, schedule.index, schedule.group);
+          delete schedules[i];
+      }
+      if (empty) delete node.__transition;
+  }
+
+  function selection_interrupt(name) {
+      return this.each(function() {
+          interrupt(this, name);
+      });
+  }
+
+  function define(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*", reN = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*", reP = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*", reHex = /^#([0-9a-f]{3,8})$/, reRgbInteger = new RegExp(`^rgb\\(${reI},${reI},${reI}\\)$`), reRgbPercent = new RegExp(`^rgb\\(${reP},${reP},${reP}\\)$`), reRgbaInteger = new RegExp(`^rgba\\(${reI},${reI},${reI},${reN}\\)$`), reRgbaPercent = new RegExp(`^rgba\\(${reP},${reP},${reP},${reN}\\)$`), reHslPercent = new RegExp(`^hsl\\(${reN},${reP},${reP}\\)$`), 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, {
+      copy (channels) {
+          return Object.assign(new this.constructor, this, channels);
+      },
+      displayable () {
+          return this.rgb().displayable();
+      },
+      hex: color_formatHex,
+      formatHex: color_formatHex,
+      formatHex8: color_formatHex8,
+      formatHsl: color_formatHsl,
+      formatRgb: color_formatRgb,
+      toString: color_formatRgb
+  });
+  function color_formatHex() {
+      return this.rgb().formatHex();
+  }
+  function color_formatHex8() {
+      return this.rgb().formatHex8();
+  }
+  function color_formatHsl() {
+      return hslConvert(this).formatHsl();
+  }
+  function color_formatRgb() {
+      return this.rgb().formatRgb();
+  }
+  function color(format) {
+      var m, l;
+      format = (format + "").trim().toLowerCase();
+      return (m = reHex.exec(format)) ? (l = m[1].length, m = parseInt(m[1], 16), l === 6 ? rgbn(m) // #ff0000
+       : l === 3 ? new Rgb(m >> 8 & 0xf | m >> 4 & 0xf0, m >> 4 & 0xf | m & 0xf0, (m & 0xf) << 4 | m & 0xf, 1) // #f00
+       : l === 8 ? rgba(m >> 24 & 0xff, m >> 16 & 0xff, m >> 8 & 0xff, (m & 0xff) / 0xff) // #ff000000
+       : l === 4 ? rgba(m >> 12 & 0xf | m >> 8 & 0xf0, m >> 8 & 0xf | m >> 4 & 0xf0, m >> 4 & 0xf | m & 0xf0, ((m & 0xf) << 4 | m & 0xf) / 0xff) // #f000
+       : null // invalid hex
+      ) : (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]) // eslint-disable-line no-prototype-builtins
+       : 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 (k) {
+          k = k == null ? brighter : Math.pow(brighter, k);
+          return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+      },
+      darker (k) {
+          k = k == null ? darker : Math.pow(darker, k);
+          return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+      },
+      rgb () {
+          return this;
+      },
+      clamp () {
+          return new Rgb(clampi(this.r), clampi(this.g), clampi(this.b), clampa(this.opacity));
+      },
+      displayable () {
+          return -0.5 <= this.r && this.r < 255.5 && -0.5 <= this.g && this.g < 255.5 && -0.5 <= this.b && this.b < 255.5 && 0 <= this.opacity && this.opacity <= 1;
+      },
+      hex: rgb_formatHex,
+      formatHex: rgb_formatHex,
+      formatHex8: rgb_formatHex8,
+      formatRgb: rgb_formatRgb,
+      toString: rgb_formatRgb
+  }));
+  function rgb_formatHex() {
+      return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}`;
+  }
+  function rgb_formatHex8() {
+      return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}${hex((isNaN(this.opacity) ? 1 : this.opacity) * 255)}`;
+  }
+  function rgb_formatRgb() {
+      const a = clampa(this.opacity);
+      return `${a === 1 ? "rgb(" : "rgba("}${clampi(this.r)}, ${clampi(this.g)}, ${clampi(this.b)}${a === 1 ? ")" : `, ${a})`}`;
+  }
+  function clampa(opacity) {
+      return isNaN(opacity) ? 1 : Math.max(0, Math.min(1, opacity));
+  }
+  function clampi(value) {
+      return Math.max(0, Math.min(255, Math.round(value) || 0));
+  }
+  function hex(value) {
+      value = clampi(value);
+      return (value < 16 ? "0" : "") + value.toString(16);
+  }
+  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 (k) {
+          k = k == null ? brighter : Math.pow(brighter, k);
+          return new Hsl(this.h, this.s, this.l * k, this.opacity);
+      },
+      darker (k) {
+          k = k == null ? darker : Math.pow(darker, k);
+          return new Hsl(this.h, this.s, this.l * k, this.opacity);
+      },
+      rgb () {
+          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);
+      },
+      clamp () {
+          return new Hsl(clamph(this.h), clampt(this.s), clampt(this.l), clampa(this.opacity));
+      },
+      displayable () {
+          return (0 <= this.s && this.s <= 1 || isNaN(this.s)) && 0 <= this.l && this.l <= 1 && 0 <= this.opacity && this.opacity <= 1;
+      },
+      formatHsl () {
+          const a = clampa(this.opacity);
+          return `${a === 1 ? "hsl(" : "hsla("}${clamph(this.h)}, ${clampt(this.s) * 100}%, ${clampt(this.l) * 100}%${a === 1 ? ")" : `, ${a})`}`;
+      }
+  }));
+  function clamph(value) {
+      value = (value || 0) % 360;
+      return value < 0 ? value + 360 : value;
+  }
+  function clampt(value) {
+      return Math.max(0, Math.min(1, value || 0));
+  }
+  /* 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 constant = ((x)=>()=>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 gamma(y) {
+      return (y = +y) === 1 ? nogamma : function(a, b) {
+          return b - a ? exponential(a, b, y) : constant(isNaN(a) ? b : a);
+      };
+  }
+  function nogamma(a, b) {
+      var d = b - a;
+      return d ? linear(a, d) : constant(isNaN(a) ? b : a);
+  }
+
+  var interpolateRgb = (function rgbGamma(y) {
+      var color = gamma(y);
+      function rgb$1(start, end) {
+          var r = color((start = rgb(start)).r, (end = rgb(end)).r), g = color(start.g, end.g), b = color(start.b, end.b), opacity = nogamma(start.opacity, end.opacity);
+          return function(t) {
+              start.r = r(t);
+              start.g = g(t);
+              start.b = b(t);
+              start.opacity = opacity(t);
+              return start + "";
+          };
+      }
+      rgb$1.gamma = rgbGamma;
+      return rgb$1;
+  })(1);
+
+  function interpolateNumber(a, b) {
+      return a = +a, b = +b, function(t) {
+          return a * (1 - t) + b * t;
+      };
+  }
+
+  var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, reB = new RegExp(reA.source, "g");
+  function zero(b) {
+      return function() {
+          return b;
+      };
+  }
+  function one(b) {
+      return function(t) {
+          return b(t) + "";
+      };
+  }
+  function interpolateString(a, b) {
+      var bi = reA.lastIndex = reB.lastIndex = 0, am, bm, bs, i = -1, s = [], 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) {
+              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])) {
+              if (s[i]) s[i] += bm; // coalesce with previous string
+              else s[++i] = bm;
+          } else {
+              s[++i] = null;
+              q.push({
+                  i: i,
+                  x: interpolateNumber(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 degrees = 180 / Math.PI;
+  var identity = {
+      translateX: 0,
+      translateY: 0,
+      rotate: 0,
+      skewX: 0,
+      scaleX: 1,
+      scaleY: 1
+  };
+  function decompose(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 svgNode;
+  /* eslint-disable no-undef */ function parseCss(value) {
+      const m = new (typeof DOMMatrix === "function" ? DOMMatrix : WebKitCSSMatrix)(value + "");
+      return m.isIdentity ? identity : decompose(m.a, m.b, m.c, m.d, m.e, m.f);
+  }
+  function parseSvg(value) {
+      if (value == null) return identity;
+      if (!svgNode) svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g");
+      svgNode.setAttribute("transform", value);
+      if (!(value = svgNode.transform.baseVal.consolidate())) return identity;
+      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: 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 = [], 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, ", ", ")", ")");
+
+  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;
+      };
+  }
+  function transition_tween(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];
+      };
+  }
+
+  function interpolate(a, b) {
+      var c;
+      return (typeof b === "number" ? interpolateNumber : b instanceof color ? interpolateRgb : (c = color(b)) ? (b = c, interpolateRgb) : interpolateString)(a, b);
+  }
+
+  function attrRemove(name) {
+      return function() {
+          this.removeAttribute(name);
+      };
+  }
+  function attrRemoveNS(fullname) {
+      return function() {
+          this.removeAttributeNS(fullname.space, fullname.local);
+      };
+  }
+  function attrConstant(name, interpolate, value1) {
+      var string00, string1 = value1 + "", interpolate0;
+      return function() {
+          var string0 = this.getAttribute(name);
+          return string0 === string1 ? null : string0 === string00 ? interpolate0 : interpolate0 = interpolate(string00 = string0, value1);
+      };
+  }
+  function attrConstantNS(fullname, interpolate, value1) {
+      var string00, string1 = value1 + "", interpolate0;
+      return function() {
+          var string0 = this.getAttributeNS(fullname.space, fullname.local);
+          return string0 === string1 ? null : string0 === string00 ? interpolate0 : interpolate0 = interpolate(string00 = string0, value1);
+      };
+  }
+  function attrFunction(name, interpolate, value) {
+      var string00, string10, interpolate0;
+      return function() {
+          var string0, value1 = value(this), string1;
+          if (value1 == null) return void this.removeAttribute(name);
+          string0 = this.getAttribute(name);
+          string1 = value1 + "";
+          return string0 === string1 ? null : string0 === string00 && string1 === string10 ? interpolate0 : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1));
+      };
+  }
+  function attrFunctionNS(fullname, interpolate, value) {
+      var string00, string10, interpolate0;
+      return function() {
+          var string0, value1 = value(this), string1;
+          if (value1 == null) return void this.removeAttributeNS(fullname.space, fullname.local);
+          string0 = this.getAttributeNS(fullname.space, fullname.local);
+          string1 = value1 + "";
+          return string0 === string1 ? null : string0 === string00 && string1 === string10 ? interpolate0 : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1));
+      };
+  }
+  function transition_attr(name, value) {
+      var fullname = namespace(name), i = fullname === "transform" ? interpolateTransformSvg : interpolate;
+      return this.attrTween(name, typeof value === "function" ? (fullname.local ? attrFunctionNS : attrFunction)(fullname, i, tweenValue(this, "attr." + name, value)) : value == null ? (fullname.local ? attrRemoveNS : attrRemove)(fullname) : (fullname.local ? attrConstantNS : attrConstant)(fullname, i, value));
+  }
+
+  function attrInterpolate(name, i) {
+      return function(t) {
+          this.setAttribute(name, i.call(this, t));
+      };
+  }
+  function attrInterpolateNS(fullname, i) {
+      return function(t) {
+          this.setAttributeNS(fullname.space, fullname.local, i.call(this, t));
+      };
+  }
+  function attrTweenNS(fullname, value) {
+      var t0, i0;
+      function tween() {
+          var i = value.apply(this, arguments);
+          if (i !== i0) t0 = (i0 = i) && attrInterpolateNS(fullname, i);
+          return t0;
+      }
+      tween._value = value;
+      return tween;
+  }
+  function attrTween(name, value) {
+      var t0, i0;
+      function tween() {
+          var i = value.apply(this, arguments);
+          if (i !== i0) t0 = (i0 = i) && attrInterpolate(name, i);
+          return t0;
+      }
+      tween._value = value;
+      return tween;
+  }
+  function transition_attrTween(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;
+      };
+  }
+  function transition_delay(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;
+      };
+  }
+  function transition_duration(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;
+      };
+  }
+  function transition_ease(value) {
+      var id = this._id;
+      return arguments.length ? this.each(easeConstant(id, value)) : get(this.node(), id).ease;
+  }
+
+  function easeVarying(id, value) {
+      return function() {
+          var v = value.apply(this, arguments);
+          if (typeof v !== "function") throw new Error;
+          set(this, id).ease = v;
+      };
+  }
+  function transition_easeVarying(value) {
+      if (typeof value !== "function") throw new Error;
+      return this.each(easeVarying(this._id, value));
+  }
+
+  function transition_filter(match) {
+      if (typeof match !== "function") match = matcher(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);
+  }
+
+  function transition_merge(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;
+      };
+  }
+  function transition_on(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);
+      };
+  }
+  function transition_remove() {
+      return this.on("end.remove", removeFunction(this._id));
+  }
+
+  function transition_select(select) {
+      var name = this._name, id = this._id;
+      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;
+                  schedule(subgroup[i], name, id, i, subgroup, get(node, id));
+              }
+          }
+      }
+      return new Transition(subgroups, this._parents, name, id);
+  }
+
+  function transition_selectAll(select) {
+      var name = this._name, id = this._id;
+      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]) {
+                  for(var children = select.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 = selection.prototype.constructor;
+  function transition_selection() {
+      return new Selection(this._groups, this._parents);
+  }
+
+  function styleNull(name, interpolate) {
+      var string00, string10, interpolate0;
+      return function() {
+          var string0 = styleValue(this, name), string1 = (this.style.removeProperty(name), styleValue(this, name));
+          return string0 === string1 ? null : string0 === string00 && string1 === string10 ? interpolate0 : interpolate0 = interpolate(string00 = string0, string10 = string1);
+      };
+  }
+  function styleRemove(name) {
+      return function() {
+          this.style.removeProperty(name);
+      };
+  }
+  function styleConstant(name, interpolate, value1) {
+      var string00, string1 = value1 + "", interpolate0;
+      return function() {
+          var string0 = styleValue(this, name);
+          return string0 === string1 ? null : string0 === string00 ? interpolate0 : interpolate0 = interpolate(string00 = string0, value1);
+      };
+  }
+  function styleFunction(name, interpolate, value) {
+      var string00, string10, interpolate0;
+      return function() {
+          var string0 = styleValue(this, name), value1 = value(this), string1 = value1 + "";
+          if (value1 == null) string1 = value1 = (this.style.removeProperty(name), styleValue(this, name));
+          return string0 === string1 ? null : string0 === string00 && string1 === string10 ? interpolate0 : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1));
+      };
+  }
+  function styleMaybeRemove(id, name) {
+      var on0, on1, listener0, key = "style." + name, event = "end." + key, remove;
+      return function() {
+          var schedule = set(this, id), on = schedule.on, listener = schedule.value[key] == null ? remove || (remove = styleRemove(name)) : undefined;
+          // 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 || listener0 !== listener) (on1 = (on0 = on).copy()).on(event, listener0 = listener);
+          schedule.on = on1;
+      };
+  }
+  function transition_style(name, value, priority) {
+      var i = (name += "") === "transform" ? interpolateTransformCss : interpolate;
+      return value == null ? this.styleTween(name, styleNull(name, i)).on("end.style." + name, styleRemove(name)) : typeof value === "function" ? this.styleTween(name, styleFunction(name, i, tweenValue(this, "style." + name, value))).each(styleMaybeRemove(this._id, name)) : this.styleTween(name, styleConstant(name, i, value), priority).on("end.style." + name, null);
+  }
+
+  function styleInterpolate(name, i, priority) {
+      return function(t) {
+          this.style.setProperty(name, i.call(this, t), priority);
+      };
+  }
+  function styleTween(name, value, priority) {
+      var t, i0;
+      function tween() {
+          var i = value.apply(this, arguments);
+          if (i !== i0) t = (i0 = i) && styleInterpolate(name, i, priority);
+          return t;
+      }
+      tween._value = value;
+      return tween;
+  }
+  function transition_styleTween(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(value) {
+      return function() {
+          this.textContent = value;
+      };
+  }
+  function textFunction(value) {
+      return function() {
+          var value1 = value(this);
+          this.textContent = value1 == null ? "" : value1;
+      };
+  }
+  function transition_text(value) {
+      return this.tween("text", typeof value === "function" ? textFunction(tweenValue(this, "text", value)) : textConstant(value == null ? "" : value + ""));
+  }
+
+  function textInterpolate(i) {
+      return function(t) {
+          this.textContent = i.call(this, t);
+      };
+  }
+  function textTween(value) {
+      var t0, i0;
+      function tween() {
+          var i = value.apply(this, arguments);
+          if (i !== i0) t0 = (i0 = i) && textInterpolate(i);
+          return t0;
+      }
+      tween._value = value;
+      return tween;
+  }
+  function transition_textTween(value) {
+      var key = "text";
+      if (arguments.length < 1) 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, textTween(value));
+  }
+
+  function transition_transition() {
+      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);
+  }
+
+  function transition_end() {
+      var on0, on1, that = this, id = that._id, size = that.size();
+      return new Promise(function(resolve, reject) {
+          var cancel = {
+              value: reject
+          }, end = {
+              value: function() {
+                  if (--size === 0) resolve();
+              }
+          };
+          that.each(function() {
+              var schedule = set(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();
+                  on1._.cancel.push(cancel);
+                  on1._.interrupt.push(cancel);
+                  on1._.end.push(end);
+              }
+              schedule.on = on1;
+          });
+          // The selection was empty, resolve end immediately
+          if (size === 0) resolve();
+      });
+  }
+
+  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,
+      selectChild: selection_prototype.selectChild,
+      selectChildren: selection_prototype.selectChildren,
+      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,
+      textTween: transition_textTween,
+      remove: transition_remove,
+      tween: transition_tween,
+      delay: transition_delay,
+      duration: transition_duration,
+      ease: transition_ease,
+      easeVarying: transition_easeVarying,
+      end: transition_end,
+      [Symbol.iterator]: selection_prototype[Symbol.iterator]
+  };
+
+  function cubicInOut(t) {
+      return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2;
+  }
+
+  var defaultTiming = {
+      time: null,
+      delay: 0,
+      duration: 250,
+      ease: cubicInOut
+  };
+  function inherit(node, id) {
+      var timing;
+      while(!(timing = node.__transition) || !(timing = timing[id])){
+          if (!(node = node.parentNode)) {
+              throw new Error(`transition ${id} not found`);
+          }
+      }
+      return timing;
+  }
+  function selection_transition(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 elem
+      @desc Manages the enter/update/exit pattern for a single DOM element.
+      @param {String} selector A D3 selector, which must include the tagname and a class and/or ID.
+      @param {Object} params Additional parameters.
+      @param {Boolean} [params.condition = true] Whether or not the element should be rendered (or removed).
+      @param {Object} [params.enter = {}] A collection of key/value pairs that map to attributes to be given on enter.
+      @param {Object} [params.exit = {}] A collection of key/value pairs that map to attributes to be given on exit.
+      @param {D3Selection} [params.parent = d3.select("body")] The parent element for this new element to be appended to.
+      @param {Number} [params.duration = 0] The duration for the d3 transition.
+      @param {Object} [params.update = {}] A collection of key/value pairs that map to attributes to be given on update.
+  */ function elem(selector, p) {
+      // overrides default params
+      p = Object.assign({}, {
+          condition: true,
+          enter: {},
+          exit: {},
+          duration: 0,
+          parent: select("body"),
+          update: {}
+      }, p);
+      const className = /\.([^#]+)/g.exec(selector), id = /#([^.]+)/g.exec(selector), t = transition().duration(p.duration), tag = /^([^.^#]+)/g.exec(selector)[1];
+      const elem = p.parent.selectAll(selector.includes(":") ? selector.split(":")[1] : selector).data(p.condition ? [
+          null
+      ] : []);
+      const enter = elem.enter().append(tag).call(attrize, p.enter);
+      if (id) enter.attr("id", id[1]);
+      if (className) enter.attr("class", className[1]);
+      if (p.duration) elem.exit().transition(t).call(attrize, p.exit).remove();
+      else elem.exit().call(attrize, p.exit).remove();
+      const update = enter.merge(elem);
+      if (p.duration) update.transition(t).call(attrize, p.update);
+      else update.call(attrize, p.update);
+      return update;
+  }
+
+  /**
+   * Strips HTML and "un-escapes" escape characters.
+   * @param {String} input
+   */ function htmlDecode(input) {
+      if (input.replace(/\s+/g, "") === "") return input;
+      const doc = new DOMParser().parseFromString(input.replace(/<[^>]+>/g, ""), "text/html");
+      return doc.documentElement ? doc.documentElement.textContent : input;
+  }
+  /**
+      @function textWidth
+      @desc Given a text string, returns the predicted pixel width of the string when placed into DOM.
+      @param {String|Array} text Can be either a single string or an array of strings to analyze.
+      @param {Object} [style] An object of CSS font styles to apply. Accepts any of the valid [CSS font property](http://www.w3schools.com/cssref/pr_font_font.asp) values.
+  */ function textWidth(text, style) {
+      style = Object.assign({
+          "font-size": 10,
+          "font-family": "sans-serif",
+          "font-style": "normal",
+          "font-weight": 400,
+          "font-variant": "normal"
+      }, style);
+      const context = document.createElement("canvas").getContext("2d");
+      const font = [];
+      font.push(style["font-style"]);
+      font.push(style["font-variant"]);
+      font.push(style["font-weight"]);
+      font.push(typeof style["font-size"] === "string" ? style["font-size"] : `${style["font-size"]}px`);
+      font.push(style["font-family"]);
+      context.font = font.join(" ");
+      if (text instanceof Array) return text.map((t)=>context.measureText(htmlDecode(t)).width);
+      return context.measureText(htmlDecode(text)).width;
+  }
+
+  /**
+      @function trim
+      @desc Cross-browser implementation of [trim](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim).
+      @param {String} str
+  */ function trim(str) {
+      return str.toString().replace(/^\s+|\s+$/g, "");
+  }
+
+  const alpha = "abcdefghiABCDEFGHI_!@#$%^&*()_+1234567890", checked = {}, height = 32;
+  let dejavu, macos, monospace, proportional;
+  /**
+      @function fontExists
+      @desc Given either a single font-family or a list of fonts, returns the name of the first font that can be rendered, or `false` if none are installed on the user's machine.
+      @param {String|Array} font Can be either a valid CSS font-family string (single or comma-separated names) or an Array of string names.
+  */ const fontExists = (font)=>{
+      if (!dejavu) {
+          dejavu = textWidth(alpha, {
+              "font-family": "DejaVuSans",
+              "font-size": height
+          });
+          macos = textWidth(alpha, {
+              "font-family": "-apple-system",
+              "font-size": height
+          });
+          monospace = textWidth(alpha, {
+              "font-family": "monospace",
+              "font-size": height
+          });
+          proportional = textWidth(alpha, {
+              "font-family": "sans-serif",
+              "font-size": height
+          });
+      }
+      if (!(font instanceof Array)) font = font.split(",");
+      font = font.map((f)=>trim(f));
+      for(let i = 0; i < font.length; i++){
+          const fam = font[i];
+          if (checked[fam] || [
+              "-apple-system",
+              "monospace",
+              "sans-serif",
+              "DejaVuSans"
+          ].includes(fam)) return fam;
+          else if (checked[fam] === false) continue;
+          const width = textWidth(alpha, {
+              "font-family": fam,
+              "font-size": height
+          });
+          checked[fam] = width !== monospace;
+          if (checked[fam]) checked[fam] = width !== proportional;
+          if (macos && checked[fam]) checked[fam] = width !== macos;
+          if (dejavu && checked[fam]) checked[fam] = width !== dejavu;
+          if (checked[fam]) return fam;
+      }
+      return false;
+  };
+
+  /**
+    @desc Given an HTMLElement and a "width" or "height" string, this function returns the current calculated size for the DOM element.
+    @private
+  */ function _elementSize(element, s) {
+      if (!element) return undefined;
+      if (element.tagName === undefined || [
+          "BODY",
+          "HTML"
+      ].indexOf(element.tagName) >= 0) {
+          let val = window[`inner${s.charAt(0).toUpperCase() + s.slice(1)}`];
+          const elem = select(element);
+          if (s === "width") {
+              val -= parseFloat(elem.style("margin-left"), 10);
+              val -= parseFloat(elem.style("margin-right"), 10);
+              val -= parseFloat(elem.style("padding-left"), 10);
+              val -= parseFloat(elem.style("padding-right"), 10);
+          } else {
+              val -= parseFloat(elem.style("margin-top"), 10);
+              val -= parseFloat(elem.style("margin-bottom"), 10);
+              val -= parseFloat(elem.style("padding-top"), 10);
+              val -= parseFloat(elem.style("padding-bottom"), 10);
+          }
+          return val;
+      } else {
+          const val = parseFloat(select(element).style(s), 10);
+          if (typeof val === "number" && val > 0) return val;
+          else return _elementSize(element.parentNode, s);
+      }
+  }
+  /**
+      @function getSize
+      @desc Finds the available width and height for a specified HTMLElement, traversing it's parents until it finds something with constrained dimensions. Falls back to the inner dimensions of the browser window if none is found.
+      @param {HTMLElement} elem The HTMLElement to find dimensions for.
+      @private
+  */ function getSize(elem) {
+      return [
+          _elementSize(elem, "width"),
+          _elementSize(elem, "height")
+      ];
+  }
+
+  /**
+    @module inViewport
+    @desc Returns a *Boolean* denoting whether or not a given DOM element is visible in the current window.
+    @param {DOMElement} elem The DOM element to analyze.
+    @param {Number} [buffer = 0] A pixel offset from the edge of the top and bottom of the screen. If a positive value, the element will be deemed visible when it is that many pixels away from entering the viewport. If negative, the element will have to enter the viewport by that many pixels before being deemed visible.
+    @private
+  */ function inViewport(elem, buffer = 0) {
+      const pageX = window.pageXOffset !== undefined ? window.pageXOffset : (document.documentElement || document.body.parentNode || document.body).scrollLeft;
+      const pageY = window.pageYOffset !== undefined ? window.pageYOffset : (document.documentElement || document.body.parentNode || document.body).scrollTop;
+      const bounds = elem.getBoundingClientRect();
+      const height = bounds.height, left = bounds.left + pageX, top = bounds.top + pageY, width = bounds.width;
+      return pageY + window.innerHeight > top + buffer && pageY + buffer < top + height && pageX + window.innerWidth > left + buffer && pageX + buffer < left + width;
+  }
+
+  /**
+   @function parseSides
+   @desc Converts a string of directional CSS shorthand values into an object with the values expanded.
+   @param {String|Number} sides The CSS shorthand string to expand.
+   */ function parseSides(sides) {
+      let values;
+      if (typeof sides === "number") values = [
+          sides
+      ];
+      else values = sides.split(/\s+/);
+      if (values.length === 1) values = [
+          values[0],
+          values[0],
+          values[0],
+          values[0]
+      ];
+      else if (values.length === 2) values = values.concat(values);
+      else if (values.length === 3) values.push(values[1]);
+      return [
+          "top",
+          "right",
+          "bottom",
+          "left"
+      ].reduce((acc, direction, i)=>{
+          const value = parseFloat(values[i]);
+          acc[direction] = value || 0;
+          return acc;
+      }, {});
+  }
+
+  /**
+      @function prefix
+      @desc Returns the appropriate CSS vendor prefix, given the current browser.
+  */ function prefix() {
+      if ("-webkit-transform" in document.body.style) return "-webkit-";
+      else if ("-moz-transform" in document.body.style) return "-moz-";
+      else if ("-ms-transform" in document.body.style) return "-ms-";
+      else if ("-o-transform" in document.body.style) return "-o-";
+      else return "";
+  }
+
+  /**
+      @function rtl
+      @desc Returns `true` if the HTML or body element has either the "dir" HTML attribute or the "direction" CSS property set to "rtl".
+  */ var rtl = (()=>select("html").attr("dir") === "rtl" || select("body").attr("dir") === "rtl" || select("html").style("direction") === "rtl" || select("body").style("direction") === "rtl");
+
+  /**
+      @function stylize
+      @desc Applies each key/value in an object as a style.
+      @param {D3selection} elem The D3 element to apply the styles to.
+      @param {Object} styles An object of key/value style pairs.
+  */ function stylize(e, s = {}) {
+      for(const k in s)if (({}).hasOwnProperty.call(s, k)) e.style(k, s[k]);
+  }
+
+  exports.assign = assign;
+  exports.attrize = attrize;
+  exports.date = date;
+  exports.elem = elem;
+  exports.fontExists = fontExists;
+  exports.getSize = getSize;
+  exports.inViewport = inViewport;
+  exports.isObject = isObject;
+  exports.parseSides = parseSides;
+  exports.prefix = prefix;
+  exports.rtl = rtl;
+  exports.stylize = stylize;
+  exports.textWidth = textWidth;
+
+}));
+//# sourceMappingURL=d3plus-dom.full.js.map