@fecp/designer 5.6.6 → 5.6.8

package/lib/node_modules/d3-scale/src/init.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function initRange(domain, range) {
+  switch (arguments.length) {
+    case 0:
+      break;
+    case 1:
+      this.range(domain);
+      break;
+    default:
+      this.range(range).domain(domain);
+      break;
+  }
+  return this;
+}
+exports.initRange = initRange;

package/lib/node_modules/d3-scale/src/linear.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const continuous = require("./continuous.js");
+const init = require("./init.js");
+const tickFormat = require("./tickFormat.js");
+const ticks = require("../../d3-array/src/ticks.js");
+function linearish(scale) {
+  var domain = scale.domain;
+  scale.ticks = function(count) {
+    var d = domain();
+    return ticks.default(d[0], d[d.length - 1], count == null ? 10 : count);
+  };
+  scale.tickFormat = function(count, specifier) {
+    var d = domain();
+    return tickFormat.default(d[0], d[d.length - 1], count == null ? 10 : count, specifier);
+  };
+  scale.nice = function(count) {
+    if (count == null) count = 10;
+    var d = domain();
+    var i0 = 0;
+    var i1 = d.length - 1;
+    var start = d[i0];
+    var stop = d[i1];
+    var prestep;
+    var step;
+    var maxIter = 10;
+    if (stop < start) {
+      step = start, start = stop, stop = step;
+      step = i0, i0 = i1, i1 = step;
+    }
+    while (maxIter-- > 0) {
+      step = ticks.tickIncrement(start, stop, count);
+      if (step === prestep) {
+        d[i0] = start;
+        d[i1] = stop;
+        return domain(d);
+      } else if (step > 0) {
+        start = Math.floor(start / step) * step;
+        stop = Math.ceil(stop / step) * step;
+      } else if (step < 0) {
+        start = Math.ceil(start * step) / step;
+        stop = Math.floor(stop * step) / step;
+      } else {
+        break;
+      }
+      prestep = step;
+    }
+    return scale;
+  };
+  return scale;
+}
+function linear() {
+  var scale = continuous.default();
+  scale.copy = function() {
+    return continuous.copy(scale, linear());
+  };
+  init.initRange.apply(scale, arguments);
+  return linearish(scale);
+}
+exports.default = linear;
+exports.linearish = linearish;

package/lib/node_modules/d3-scale/src/nice.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function nice(domain, interval) {
+  domain = domain.slice();
+  var i0 = 0, i1 = domain.length - 1, x0 = domain[i0], x1 = domain[i1], t;
+  if (x1 < x0) {
+    t = i0, i0 = i1, i1 = t;
+    t = x0, x0 = x1, x1 = t;
+  }
+  domain[i0] = interval.floor(x0);
+  domain[i1] = interval.ceil(x1);
+  return domain;
+}
+exports.default = nice;

package/lib/node_modules/d3-scale/src/number.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function number(x) {
+  return +x;
+}
+exports.default = number;

package/lib/node_modules/d3-scale/src/ordinal.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const init = require("./init.js");
+const index = require("../../d3-array/node_modules/internmap/src/index.js");
+const implicit = Symbol("implicit");
+function ordinal() {
+  var index$1 = new index.InternMap(), domain = [], range = [], unknown = implicit;
+  function scale(d) {
+    let i = index$1.get(d);
+    if (i === void 0) {
+      if (unknown !== implicit) return unknown;
+      index$1.set(d, i = domain.push(d) - 1);
+    }
+    return range[i % range.length];
+  }
+  scale.domain = function(_) {
+    if (!arguments.length) return domain.slice();
+    domain = [], index$1 = new index.InternMap();
+    for (const value of _) {
+      if (index$1.has(value)) continue;
+      index$1.set(value, domain.push(value) - 1);
+    }
+    return scale;
+  };
+  scale.range = function(_) {
+    return arguments.length ? (range = Array.from(_), scale) : range.slice();
+  };
+  scale.unknown = function(_) {
+    return arguments.length ? (unknown = _, scale) : unknown;
+  };
+  scale.copy = function() {
+    return ordinal(domain, range).unknown(unknown);
+  };
+  init.initRange.apply(scale, arguments);
+  return scale;
+}
+exports.default = ordinal;
+exports.implicit = implicit;

package/lib/node_modules/d3-scale/src/tickFormat.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const ticks = require("../../d3-array/src/ticks.js");
+const formatSpecifier = require("../../d3-format/src/formatSpecifier.js");
+const precisionFixed = require("../../d3-format/src/precisionFixed.js");
+const precisionRound = require("../../d3-format/src/precisionRound.js");
+const precisionPrefix = require("../../d3-format/src/precisionPrefix.js");
+const defaultLocale = require("../../d3-format/src/defaultLocale.js");
+function tickFormat(start, stop, count, specifier) {
+  var step = ticks.tickStep(start, stop, count), precision;
+  specifier = formatSpecifier.default(specifier == null ? ",f" : specifier);
+  switch (specifier.type) {
+    case "s": {
+      var value = Math.max(Math.abs(start), Math.abs(stop));
+      if (specifier.precision == null && !isNaN(precision = precisionPrefix.default(step, value))) specifier.precision = precision;
+      return defaultLocale.formatPrefix(specifier, value);
+    }
+    case "":
+    case "e":
+    case "g":
+    case "p":
+    case "r": {
+      if (specifier.precision == null && !isNaN(precision = precisionRound.default(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e");
+      break;
+    }
+    case "f":
+    case "%": {
+      if (specifier.precision == null && !isNaN(precision = precisionFixed.default(step))) specifier.precision = precision - (specifier.type === "%") * 2;
+      break;
+    }
+  }
+  return defaultLocale.format(specifier);
+}
+exports.default = tickFormat;

package/lib/node_modules/d3-scale/src/time.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const continuous = require("./continuous.js");
+const init = require("./init.js");
+const nice = require("./nice.js");
+const defaultLocale = require("../../d3-time-format/src/defaultLocale.js");
+const second = require("../../d3-time/src/second.js");
+const minute = require("../../d3-time/src/minute.js");
+const hour = require("../../d3-time/src/hour.js");
+const day = require("../../d3-time/src/day.js");
+const week = require("../../d3-time/src/week.js");
+const month = require("../../d3-time/src/month.js");
+const year = require("../../d3-time/src/year.js");
+const ticks = require("../../d3-time/src/ticks.js");
+function date(t) {
+  return new Date(t);
+}
+function number(t) {
+  return t instanceof Date ? +t : +/* @__PURE__ */ new Date(+t);
+}
+function calendar(ticks2, tickInterval, year2, month2, week2, day2, hour2, minute2, second2, format) {
+  var scale = continuous.default(), invert = scale.invert, domain = scale.domain;
+  var formatMillisecond = format(".%L"), formatSecond = format(":%S"), formatMinute = format("%I:%M"), formatHour = format("%I %p"), formatDay = format("%a %d"), formatWeek = format("%b %d"), formatMonth = format("%B"), formatYear = format("%Y");
+  function tickFormat(date2) {
+    return (second2(date2) < date2 ? formatMillisecond : minute2(date2) < date2 ? formatSecond : hour2(date2) < date2 ? formatMinute : day2(date2) < date2 ? formatHour : month2(date2) < date2 ? week2(date2) < date2 ? formatDay : formatWeek : year2(date2) < date2 ? formatMonth : formatYear)(date2);
+  }
+  scale.invert = function(y) {
+    return new Date(invert(y));
+  };
+  scale.domain = function(_) {
+    return arguments.length ? domain(Array.from(_, number)) : domain().map(date);
+  };
+  scale.ticks = function(interval) {
+    var d = domain();
+    return ticks2(d[0], d[d.length - 1], interval == null ? 10 : interval);
+  };
+  scale.tickFormat = function(count, specifier) {
+    return specifier == null ? tickFormat : format(specifier);
+  };
+  scale.nice = function(interval) {
+    var d = domain();
+    if (!interval || typeof interval.range !== "function") interval = tickInterval(d[0], d[d.length - 1], interval == null ? 10 : interval);
+    return interval ? domain(nice.default(d, interval)) : scale;
+  };
+  scale.copy = function() {
+    return continuous.copy(scale, calendar(ticks2, tickInterval, year2, month2, week2, day2, hour2, minute2, second2, format));
+  };
+  return scale;
+}
+function time() {
+  return init.initRange.apply(calendar(ticks.timeTicks, ticks.timeTickInterval, year.timeYear, month.timeMonth, week.timeSunday, day.timeDay, hour.timeHour, minute.timeMinute, second.second, defaultLocale.timeFormat).domain([new Date(2e3, 0, 1), new Date(2e3, 0, 2)]), arguments);
+}
+exports.calendar = calendar;
+exports.default = time;

package/lib/node_modules/d3-scale-chromatic/src/categorical/Tableau10.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const colors = require("../colors.js");
+const d3schemeTableau10 = colors.default("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab");
+exports.default = d3schemeTableau10;

package/lib/node_modules/d3-scale-chromatic/src/colors.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function colors(specifier) {
+  var n = specifier.length / 6 | 0, colors2 = new Array(n), i = 0;
+  while (i < n) colors2[i] = "#" + specifier.slice(i * 6, ++i * 6);
+  return colors2;
+}
+exports.default = colors;

package/lib/node_modules/d3-selection/src/array.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function array(x) {
+  return x == null ? [] : Array.isArray(x) ? x : Array.from(x);
+}
+exports.default = array;

package/lib/node_modules/d3-selection/src/constant.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function constant(x) {
+  return function() {
+    return x;
+  };
+}
+exports.default = constant;

package/lib/node_modules/d3-selection/src/creator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const namespace = require("./namespace.js");
+const namespaces = require("./namespaces.js");
+function creatorInherit(name) {
+  return function() {
+    var document = this.ownerDocument, uri = this.namespaceURI;
+    return uri === namespaces.xhtml && document.documentElement.namespaceURI === namespaces.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.default(name);
+  return (fullname.local ? creatorFixed : creatorInherit)(fullname);
+}
+exports.default = creator;

package/lib/node_modules/d3-selection/src/matcher.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function matcher(selector) {
+  return function() {
+    return this.matches(selector);
+  };
+}
+function childMatcher(selector) {
+  return function(node) {
+    return node.matches(selector);
+  };
+}
+exports.childMatcher = childMatcher;
+exports.default = matcher;

package/lib/node_modules/d3-selection/src/namespace.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const namespaces = require("./namespaces.js");
+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.default.hasOwnProperty(prefix) ? { space: namespaces.default[prefix], local: name } : name;
+}
+exports.default = namespace;

package/lib/node_modules/d3-selection/src/namespaces.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var xhtml = "http://www.w3.org/1999/xhtml";
+const namespaces = {
+  svg: "http://www.w3.org/2000/svg",
+  xhtml,
+  xlink: "http://www.w3.org/1999/xlink",
+  xml: "http://www.w3.org/XML/1998/namespace",
+  xmlns: "http://www.w3.org/2000/xmlns/"
+};
+exports.default = namespaces;
+exports.xhtml = xhtml;

package/lib/node_modules/d3-selection/src/select.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("./selection/index.js");
+function select(selector) {
+  return typeof selector === "string" ? new index.Selection([[document.querySelector(selector)]], [document.documentElement]) : new index.Selection([[selector]], index.root);
+}
+exports.default = select;

package/lib/node_modules/d3-selection/src/selection/append.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const creator = require("../creator.js");
+function selection_append(name) {
+  var create = typeof name === "function" ? name : creator.default(name);
+  return this.select(function() {
+    return this.appendChild(create.apply(this, arguments));
+  });
+}
+exports.default = selection_append;

package/lib/node_modules/d3-selection/src/selection/attr.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const namespace = require("../namespace.js");
+function attrRemove(name) {
+  return function() {
+    this.removeAttribute(name);
+  };
+}
+function attrRemoveNS(fullname) {
+  return function() {
+    this.removeAttributeNS(fullname.space, fullname.local);
+  };
+}
+function attrConstant(name, value) {
+  return function() {
+    this.setAttribute(name, value);
+  };
+}
+function attrConstantNS(fullname, value) {
+  return function() {
+    this.setAttributeNS(fullname.space, fullname.local, value);
+  };
+}
+function attrFunction(name, value) {
+  return function() {
+    var v = value.apply(this, arguments);
+    if (v == null) this.removeAttribute(name);
+    else this.setAttribute(name, v);
+  };
+}
+function attrFunctionNS(fullname, value) {
+  return function() {
+    var v = value.apply(this, arguments);
+    if (v == null) this.removeAttributeNS(fullname.space, fullname.local);
+    else this.setAttributeNS(fullname.space, fullname.local, v);
+  };
+}
+function selection_attr(name, value) {
+  var fullname = namespace.default(name);
+  if (arguments.length < 2) {
+    var node = this.node();
+    return fullname.local ? node.getAttributeNS(fullname.space, fullname.local) : node.getAttribute(fullname);
+  }
+  return this.each((value == null ? fullname.local ? attrRemoveNS : attrRemove : typeof value === "function" ? fullname.local ? attrFunctionNS : attrFunction : fullname.local ? attrConstantNS : attrConstant)(fullname, value));
+}
+exports.default = selection_attr;

package/lib/node_modules/d3-selection/src/selection/call.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function selection_call() {
+  var callback = arguments[0];
+  arguments[0] = this;
+  callback.apply(null, arguments);
+  return this;
+}
+exports.default = selection_call;

package/lib/node_modules/d3-selection/src/selection/classed.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+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));
+}
+exports.default = selection_classed;

package/lib/node_modules/d3-selection/src/selection/clone.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+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);
+}
+exports.default = selection_clone;

package/lib/node_modules/d3-selection/src/selection/data.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("./index.js");
+const enter = require("./enter.js");
+const constant = require("../constant.js");
+function bindIndex(parent, group, enter$1, update, exit, data) {
+  var i = 0, node, groupLength = group.length, dataLength = data.length;
+  for (; i < dataLength; ++i) {
+    if (node = group[i]) {
+      node.__data__ = data[i];
+      update[i] = node;
+    } else {
+      enter$1[i] = new enter.EnterNode(parent, data[i]);
+    }
+  }
+  for (; i < groupLength; ++i) {
+    if (node = group[i]) {
+      exit[i] = node;
+    }
+  }
+}
+function bindKey(parent, group, enter$1, update, exit, data, key) {
+  var i, node, nodeByKeyValue = /* @__PURE__ */ new Map(), groupLength = group.length, dataLength = data.length, keyValues = new Array(groupLength), keyValue;
+  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);
+      }
+    }
+  }
+  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$1[i] = new enter.EnterNode(parent, data[i]);
+    }
+  }
+  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.default(value);
+  for (var m = groups.length, update = new Array(m), enter2 = 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 = enter2[j] = new Array(dataLength), updateGroup = update[j] = new Array(dataLength), exitGroup = exit[j] = new Array(groupLength);
+    bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);
+    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 index.Selection(update, parents);
+  update._enter = enter2;
+  update._exit = exit;
+  return update;
+}
+function arraylike(data) {
+  return typeof data === "object" && "length" in data ? data : Array.from(data);
+}
+exports.default = selection_data;

package/lib/node_modules/d3-selection/src/selection/datum.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function selection_datum(value) {
+  return arguments.length ? this.property("__data__", value) : this.node().__data__;
+}
+exports.default = selection_datum;

package/lib/node_modules/d3-selection/src/selection/dispatch.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const window = require("../window.js");
+function dispatchEvent(node, type, params) {
+  var window$1 = window.default(node), event = window$1.CustomEvent;
+  if (typeof event === "function") {
+    event = new event(type, params);
+  } else {
+    event = window$1.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));
+}
+exports.default = selection_dispatch;

package/lib/node_modules/d3-selection/src/selection/each.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+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;
+}
+exports.default = selection_each;

package/lib/node_modules/d3-selection/src/selection/empty.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function selection_empty() {
+  return !this.node();
+}
+exports.default = selection_empty;

package/lib/node_modules/d3-selection/src/selection/enter.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const sparse = require("./sparse.js");
+const index = require("./index.js");
+function selection_enter() {
+  return new index.Selection(this._enter || this._groups.map(sparse.default), 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);
+  }
+};
+exports.EnterNode = EnterNode;
+exports.default = selection_enter;

package/lib/node_modules/d3-selection/src/selection/exit.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const sparse = require("./sparse.js");
+const index = require("./index.js");
+function selection_exit() {
+  return new index.Selection(this._exit || this._groups.map(sparse.default), this._parents);
+}
+exports.default = selection_exit;