add lisp packages

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/constant.js

@@ -0,0 +1,5 @@
+export default function(x) {
+  return function() {
+    return x;
+  };
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/create.js

@@ -0,0 +1,6 @@
+import creator from "./creator";
+import select from "./select";
+
+export default function(name) {
+  return select(creator(name).call(document.documentElement));
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/creator.js

@@ -0,0 +1,25 @@
+import namespace from "./namespace";
+import {xhtml} from "./namespaces";
+
+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);
+  };
+}
+
+export default function(name) {
+  var fullname = namespace(name);
+  return (fullname.local
+      ? creatorFixed
+      : creatorInherit)(fullname);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/identity.js

@@ -0,0 +1,3 @@
+export default function(x) {
+  return x;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/index.js

@@ -0,0 +1,18 @@
+export {default as create} from "./create";
+export {default as creator} from "./creator";
+export {default as local} from "./local";
+export {default as matcher} from "./matcher";
+export {default as mouse} from "./mouse";
+export {default as namespace} from "./namespace";
+export {default as namespaces} from "./namespaces";
+export {default as clientPoint} from "./point";
+export {default as select} from "./select";
+export {default as selectAll} from "./selectAll";
+export {default as selection} from "./selection/index";
+export {default as selector} from "./selector";
+export {default as selectorAll} from "./selectorAll";
+export {styleValue as style} from "./selection/style";
+export {default as touch} from "./touch";
+export {default as touches} from "./touches";
+export {default as window} from "./window";
+export {event, customEvent} from "./selection/on";

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/local.js

@@ -0,0 +1,27 @@
+var nextId = 0;
+
+export default function local() {
+  return new Local;
+}
+
+function Local() {
+  this._ = "@" + (++nextId).toString(36);
+}
+
+Local.prototype = local.prototype = {
+  constructor: Local,
+  get: function(node) {
+    var id = this._;
+    while (!(id in node)) if (!(node = node.parentNode)) return;
+    return node[id];
+  },
+  set: function(node, value) {
+    return node[this._] = value;
+  },
+  remove: function(node) {
+    return this._ in node && delete node[this._];
+  },
+  toString: function() {
+    return this._;
+  }
+};

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/matcher.js

@@ -0,0 +1,5 @@
+export default function(selector) {
+  return function() {
+    return this.matches(selector);
+  };
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/mouse.js

@@ -0,0 +1,8 @@
+import sourceEvent from "./sourceEvent";
+import point from "./point";
+
+export default function(node) {
+  var event = sourceEvent();
+  if (event.changedTouches) event = event.changedTouches[0];
+  return point(node, event);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/namespace.js

@@ -0,0 +1,7 @@
+import namespaces from "./namespaces";
+
+export default function(name) {
+  var prefix = name += "", i = prefix.indexOf(":");
+  if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1);
+  return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/namespaces.js

@@ -0,0 +1,9 @@
+export var xhtml = "http://www.w3.org/1999/xhtml";
+
+export default {
+  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/"
+};

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/point.js

@@ -0,0 +1,13 @@
+export default function(node, event) {
+  var svg = node.ownerSVGElement || node;
+
+  if (svg.createSVGPoint) {
+    var point = svg.createSVGPoint();
+    point.x = event.clientX, point.y = event.clientY;
+    point = point.matrixTransform(node.getScreenCTM().inverse());
+    return [point.x, point.y];
+  }
+
+  var rect = node.getBoundingClientRect();
+  return [event.clientX - rect.left - node.clientLeft, event.clientY - rect.top - node.clientTop];
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/select.js

@@ -0,0 +1,7 @@
+import {Selection, root} from "./selection/index";
+
+export default function(selector) {
+  return typeof selector === "string"
+      ? new Selection([[document.querySelector(selector)]], [document.documentElement])
+      : new Selection([[selector]], root);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selectAll.js

@@ -0,0 +1,7 @@
+import {Selection, root} from "./selection/index";
+
+export default function(selector) {
+  return typeof selector === "string"
+      ? new Selection([document.querySelectorAll(selector)], [document.documentElement])
+      : new Selection([selector == null ? [] : selector], root);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/append.js

@@ -0,0 +1,8 @@
+import creator from "../creator";
+
+export default function(name) {
+  var create = typeof name === "function" ? name : creator(name);
+  return this.select(function() {
+    return this.appendChild(create.apply(this, arguments));
+  });
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/attr.js

@@ -0,0 +1,57 @@
+import namespace from "../namespace";
+
+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);
+  };
+}
+
+export default function(name, value) {
+  var fullname = namespace(name);
+
+  if (arguments.length < 2) {
+    var node = this.node();
+    return fullname.local
+        ? node.getAttributeNS(fullname.space, fullname.local)
+        : node.getAttribute(fullname);
+  }
+
+  return this.each((value == null
+      ? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === "function"
+      ? (fullname.local ? attrFunctionNS : attrFunction)
+      : (fullname.local ? attrConstantNS : attrConstant)))(fullname, value));
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/call.js

@@ -0,0 +1,6 @@
+export default function() {
+  var callback = arguments[0];
+  arguments[0] = this;
+  callback.apply(null, arguments);
+  return this;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/classed.js

@@ -0,0 +1,75 @@
+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);
+  };
+}
+
+export default function(name, value) {
+  var names = classArray(name + "");
+
+  if (arguments.length < 2) {
+    var list = classList(this.node()), i = -1, n = names.length;
+    while (++i < n) if (!list.contains(names[i])) return false;
+    return true;
+  }
+
+  return this.each((typeof value === "function"
+      ? classedFunction : value
+      ? classedTrue
+      : classedFalse)(names, value));
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/clone.js

@@ -0,0 +1,13 @@
+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;
+}
+
+export default function(deep) {
+  return this.select(deep ? selection_cloneDeep : selection_cloneShallow);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/data.js

@@ -0,0 +1,118 @@
+import {Selection} from "./index";
+import {EnterNode} from "./enter";
+import constant from "../constant";
+
+var keyPrefix = "$"; // Protect against keys like “__proto__”.
+
+function bindIndex(parent, group, enter, update, exit, data) {
+  var i = 0,
+      node,
+      groupLength = group.length,
+      dataLength = data.length;
+
+  // Put any non-null nodes that fit into update.
+  // Put any null nodes into enter.
+  // Put any remaining data into enter.
+  for (; i < dataLength; ++i) {
+    if (node = group[i]) {
+      node.__data__ = data[i];
+      update[i] = node;
+    } else {
+      enter[i] = new EnterNode(parent, data[i]);
+    }
+  }
+
+  // Put any non-null nodes that don’t fit into exit.
+  for (; i < groupLength; ++i) {
+    if (node = group[i]) {
+      exit[i] = node;
+    }
+  }
+}
+
+function bindKey(parent, group, enter, update, exit, data, key) {
+  var i,
+      node,
+      nodeByKeyValue = {},
+      groupLength = group.length,
+      dataLength = data.length,
+      keyValues = new Array(groupLength),
+      keyValue;
+
+  // Compute the key for each node.
+  // If multiple nodes have the same key, the duplicates are added to exit.
+  for (i = 0; i < groupLength; ++i) {
+    if (node = group[i]) {
+      keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group);
+      if (keyValue in nodeByKeyValue) {
+        exit[i] = node;
+      } else {
+        nodeByKeyValue[keyValue] = node;
+      }
+    }
+  }
+
+  // Compute the key for each datum.
+  // If there a node associated with this key, join and add it to update.
+  // If there is not (or the key is a duplicate), add it to enter.
+  for (i = 0; i < dataLength; ++i) {
+    keyValue = keyPrefix + key.call(parent, data[i], i, data);
+    if (node = nodeByKeyValue[keyValue]) {
+      update[i] = node;
+      node.__data__ = data[i];
+      nodeByKeyValue[keyValue] = null;
+    } else {
+      enter[i] = new EnterNode(parent, data[i]);
+    }
+  }
+
+  // Add any remaining nodes that were not bound to data to exit.
+  for (i = 0; i < groupLength; ++i) {
+    if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) {
+      exit[i] = node;
+    }
+  }
+}
+
+export default function(value, key) {
+  if (!value) {
+    data = new Array(this.size()), j = -1;
+    this.each(function(d) { data[++j] = d; });
+    return data;
+  }
+
+  var bind = key ? bindKey : bindIndex,
+      parents = this._parents,
+      groups = this._groups;
+
+  if (typeof value !== "function") value = constant(value);
+
+  for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) {
+    var parent = parents[j],
+        group = groups[j],
+        groupLength = group.length,
+        data = value.call(parent, parent && parent.__data__, j, parents),
+        dataLength = data.length,
+        enterGroup = enter[j] = new Array(dataLength),
+        updateGroup = update[j] = new Array(dataLength),
+        exitGroup = exit[j] = new Array(groupLength);
+
+    bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);
+
+    // Now connect the enter nodes to their following update node, such that
+    // appendChild can insert the materialized enter node before this node,
+    // rather than at the end of the parent node.
+    for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) {
+      if (previous = enterGroup[i0]) {
+        if (i0 >= i1) i1 = i0 + 1;
+        while (!(next = updateGroup[i1]) && ++i1 < dataLength);
+        previous._next = next || null;
+      }
+    }
+  }
+
+  update = new Selection(update, parents);
+  update._enter = enter;
+  update._exit = exit;
+  return update;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/datum.js

@@ -0,0 +1,5 @@
+export default function(value) {
+  return arguments.length
+      ? this.property("__data__", value)
+      : this.node().__data__;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/dispatch.js

@@ -0,0 +1,34 @@
+import defaultView from "../window";
+
+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));
+  };
+}
+
+export default function(type, params) {
+  return this.each((typeof params === "function"
+      ? dispatchFunction
+      : dispatchConstant)(type, params));
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/each.js

@@ -0,0 +1,10 @@
+export default function(callback) {
+
+  for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
+    for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {
+      if (node = group[i]) callback.call(node, node.__data__, i, group);
+    }
+  }
+
+  return this;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/empty.js

@@ -0,0 +1,3 @@
+export default function() {
+  return !this.node();
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/enter.js

@@ -0,0 +1,22 @@
+import sparse from "./sparse";
+import {Selection} from "./index";
+
+export default function() {
+  return new Selection(this._enter || this._groups.map(sparse), this._parents);
+}
+
+export 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); }
+};

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/exit.js

@@ -0,0 +1,6 @@
+import sparse from "./sparse";
+import {Selection} from "./index";
+
+export default function() {
+  return new Selection(this._exit || this._groups.map(sparse), this._parents);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/filter.js

@@ -0,0 +1,16 @@
+import {Selection} from "./index";
+import matcher from "../matcher";
+
+export default function(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(subgroups, this._parents);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/html.js

@@ -0,0 +1,25 @@
+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;
+  };
+}
+
+export default function(value) {
+  return arguments.length
+      ? this.each(value == null
+          ? htmlRemove : (typeof value === "function"
+          ? htmlFunction
+          : htmlConstant)(value))
+      : this.node().innerHTML;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/index.js

@@ -0,0 +1,79 @@
+import selection_select from "./select";
+import selection_selectAll from "./selectAll";
+import selection_filter from "./filter";
+import selection_data from "./data";
+import selection_enter from "./enter";
+import selection_exit from "./exit";
+import selection_join from "./join";
+import selection_merge from "./merge";
+import selection_order from "./order";
+import selection_sort from "./sort";
+import selection_call from "./call";
+import selection_nodes from "./nodes";
+import selection_node from "./node";
+import selection_size from "./size";
+import selection_empty from "./empty";
+import selection_each from "./each";
+import selection_attr from "./attr";
+import selection_style from "./style";
+import selection_property from "./property";
+import selection_classed from "./classed";
+import selection_text from "./text";
+import selection_html from "./html";
+import selection_raise from "./raise";
+import selection_lower from "./lower";
+import selection_append from "./append";
+import selection_insert from "./insert";
+import selection_remove from "./remove";
+import selection_clone from "./clone";
+import selection_datum from "./datum";
+import selection_on from "./on";
+import selection_dispatch from "./dispatch";
+
+export var root = [null];
+
+export function Selection(groups, parents) {
+  this._groups = groups;
+  this._parents = parents;
+}
+
+function selection() {
+  return new Selection([[document.documentElement]], root);
+}
+
+Selection.prototype = selection.prototype = {
+  constructor: Selection,
+  select: selection_select,
+  selectAll: selection_selectAll,
+  filter: selection_filter,
+  data: selection_data,
+  enter: selection_enter,
+  exit: selection_exit,
+  join: selection_join,
+  merge: selection_merge,
+  order: selection_order,
+  sort: selection_sort,
+  call: selection_call,
+  nodes: selection_nodes,
+  node: selection_node,
+  size: selection_size,
+  empty: selection_empty,
+  each: selection_each,
+  attr: selection_attr,
+  style: selection_style,
+  property: selection_property,
+  classed: selection_classed,
+  text: selection_text,
+  html: selection_html,
+  raise: selection_raise,
+  lower: selection_lower,
+  append: selection_append,
+  insert: selection_insert,
+  remove: selection_remove,
+  clone: selection_clone,
+  datum: selection_datum,
+  on: selection_on,
+  dispatch: selection_dispatch
+};
+
+export default selection;

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/insert.js

@@ -0,0 +1,14 @@
+import creator from "../creator";
+import selector from "../selector";
+
+function constantNull() {
+  return null;
+}
+
+export default function(name, before) {
+  var create = typeof name === "function" ? name : creator(name),
+      select = before == null ? constantNull : typeof before === "function" ? before : selector(before);
+  return this.select(function() {
+    return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null);
+  });
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/join.js

@@ -0,0 +1,7 @@
+export default function(onenter, onupdate, onexit) {
+  var enter = this.enter(), update = this, exit = this.exit();
+  enter = typeof onenter === "function" ? onenter(enter) : enter.append(onenter + "");
+  if (onupdate != null) update = onupdate(update);
+  if (onexit == null) exit.remove(); else onexit(exit);
+  return enter && update ? enter.merge(update).order() : update;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/lower.js

@@ -0,0 +1,7 @@
+function lower() {
+  if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild);
+}
+
+export default function() {
+  return this.each(lower);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/merge.js

@@ -0,0 +1,18 @@
+import {Selection} from "./index";
+
+export default function(selection) {
+
+  for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {
+    for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {
+      if (node = group0[i] || group1[i]) {
+        merge[i] = node;
+      }
+    }
+  }
+
+  for (; j < m0; ++j) {
+    merges[j] = groups0[j];
+  }
+
+  return new Selection(merges, this._parents);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/node.js

@@ -0,0 +1,11 @@
+export default function() {
+
+  for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
+    for (var group = groups[j], i = 0, n = group.length; i < n; ++i) {
+      var node = group[i];
+      if (node) return node;
+    }
+  }
+
+  return null;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/nodes.js

@@ -0,0 +1,5 @@
+export default function() {
+  var nodes = new Array(this.size()), i = -1;
+  this.each(function() { nodes[++i] = this; });
+  return nodes;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/on.js

@@ -0,0 +1,107 @@
+var filterEvents = {};
+
+export var event = null;
+
+if (typeof document !== "undefined") {
+  var element = document.documentElement;
+  if (!("onmouseenter" in element)) {
+    filterEvents = {mouseenter: "mouseover", mouseleave: "mouseout"};
+  }
+}
+
+function filterContextListener(listener, index, group) {
+  listener = contextListener(listener, index, group);
+  return function(event) {
+    var related = event.relatedTarget;
+    if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) {
+      listener.call(this, event);
+    }
+  };
+}
+
+function contextListener(listener, index, group) {
+  return function(event1) {
+    var event0 = event; // Events can be reentrant (e.g., focus).
+    event = event1;
+    try {
+      listener.call(this, this.__data__, index, group);
+    } finally {
+      event = event0;
+    }
+  };
+}
+
+function parseTypenames(typenames) {
+  return typenames.trim().split(/^|\s+/).map(function(t) {
+    var name = "", i = t.indexOf(".");
+    if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);
+    return {type: t, name: name};
+  });
+}
+
+function onRemove(typename) {
+  return function() {
+    var on = this.__on;
+    if (!on) return;
+    for (var j = 0, i = -1, m = on.length, o; j < m; ++j) {
+      if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {
+        this.removeEventListener(o.type, o.listener, o.capture);
+      } else {
+        on[++i] = o;
+      }
+    }
+    if (++i) on.length = i;
+    else delete this.__on;
+  };
+}
+
+function onAdd(typename, value, capture) {
+  var wrap = filterEvents.hasOwnProperty(typename.type) ? filterContextListener : contextListener;
+  return function(d, i, group) {
+    var on = this.__on, o, listener = wrap(value, i, group);
+    if (on) for (var j = 0, m = on.length; j < m; ++j) {
+      if ((o = on[j]).type === typename.type && o.name === typename.name) {
+        this.removeEventListener(o.type, o.listener, o.capture);
+        this.addEventListener(o.type, o.listener = listener, o.capture = capture);
+        o.value = value;
+        return;
+      }
+    }
+    this.addEventListener(typename.type, listener, capture);
+    o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture};
+    if (!on) this.__on = [o];
+    else on.push(o);
+  };
+}
+
+export default function(typename, value, capture) {
+  var typenames = parseTypenames(typename + ""), i, n = typenames.length, t;
+
+  if (arguments.length < 2) {
+    var on = this.node().__on;
+    if (on) for (var j = 0, m = on.length, o; j < m; ++j) {
+      for (i = 0, o = on[j]; i < n; ++i) {
+        if ((t = typenames[i]).type === o.type && t.name === o.name) {
+          return o.value;
+        }
+      }
+    }
+    return;
+  }
+
+  on = value ? onAdd : onRemove;
+  if (capture == null) capture = false;
+  for (i = 0; i < n; ++i) this.each(on(typenames[i], value, capture));
+  return this;
+}
+
+export function customEvent(event1, listener, that, args) {
+  var event0 = event;
+  event1.sourceEvent = event;
+  event = event1;
+  try {
+    return listener.apply(that, args);
+  } finally {
+    event = event0;
+  }
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/order.js

@@ -0,0 +1,13 @@
+export default function() {
+
+  for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) {
+    for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) {
+      if (node = group[i]) {
+        if (next && node.compareDocumentPosition(next) ^ 4) next.parentNode.insertBefore(node, next);
+        next = node;
+      }
+    }
+  }
+
+  return this;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/property.js

@@ -0,0 +1,28 @@
+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;
+  };
+}
+
+export default function(name, value) {
+  return arguments.length > 1
+      ? this.each((value == null
+          ? propertyRemove : typeof value === "function"
+          ? propertyFunction
+          : propertyConstant)(name, value))
+      : this.node()[name];
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/raise.js

@@ -0,0 +1,7 @@
+function raise() {
+  if (this.nextSibling) this.parentNode.appendChild(this);
+}
+
+export default function() {
+  return this.each(raise);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/remove.js

@@ -0,0 +1,8 @@
+function remove() {
+  var parent = this.parentNode;
+  if (parent) parent.removeChild(this);
+}
+
+export default function() {
+  return this.each(remove);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/select.js

@@ -0,0 +1,17 @@
+import {Selection} from "./index";
+import selector from "../selector";
+
+export default function(select) {
+  if (typeof select !== "function") select = selector(select);
+
+  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
+    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {
+      if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {
+        if ("__data__" in node) subnode.__data__ = node.__data__;
+        subgroup[i] = subnode;
+      }
+    }
+  }
+
+  return new Selection(subgroups, this._parents);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/selectAll.js

@@ -0,0 +1,17 @@
+import {Selection} from "./index";
+import selectorAll from "../selectorAll";
+
+export default function(select) {
+  if (typeof select !== "function") select = selectorAll(select);
+
+  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {
+    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
+      if (node = group[i]) {
+        subgroups.push(select.call(node, node.__data__, i, group));
+        parents.push(node);
+      }
+    }
+  }
+
+  return new Selection(subgroups, parents);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/size.js

@@ -0,0 +1,5 @@
+export default function() {
+  var size = 0;
+  this.each(function() { ++size; });
+  return size;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/sort.js

@@ -0,0 +1,24 @@
+import {Selection} from "./index";
+
+export default function(compare) {
+  if (!compare) compare = ascending;
+
+  function compareNode(a, b) {
+    return a && b ? compare(a.__data__, b.__data__) : !a - !b;
+  }
+
+  for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) {
+    for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) {
+      if (node = group[i]) {
+        sortgroup[i] = node;
+      }
+    }
+    sortgroup.sort(compareNode);
+  }
+
+  return new Selection(sortgroups, this._parents).order();
+}
+
+function ascending(a, b) {
+  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/sparse.js

@@ -0,0 +1,3 @@
+export default function(update) {
+  return new Array(update.length);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/style.js

@@ -0,0 +1,35 @@
+import defaultView from "../window";
+
+function styleRemove(name) {
+  return function() {
+    this.style.removeProperty(name);
+  };
+}
+
+function styleConstant(name, value, priority) {
+  return function() {
+    this.style.setProperty(name, value, priority);
+  };
+}
+
+function styleFunction(name, value, priority) {
+  return function() {
+    var v = value.apply(this, arguments);
+    if (v == null) this.style.removeProperty(name);
+    else this.style.setProperty(name, v, priority);
+  };
+}
+
+export default function(name, value, priority) {
+  return arguments.length > 1
+      ? this.each((value == null
+            ? styleRemove : typeof value === "function"
+            ? styleFunction
+            : styleConstant)(name, value, priority == null ? "" : priority))
+      : styleValue(this.node(), name);
+}
+
+export function styleValue(node, name) {
+  return node.style.getPropertyValue(name)
+      || defaultView(node).getComputedStyle(node, null).getPropertyValue(name);
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selection/text.js

@@ -0,0 +1,25 @@
+function textRemove() {
+  this.textContent = "";
+}
+
+function textConstant(value) {
+  return function() {
+    this.textContent = value;
+  };
+}
+
+function textFunction(value) {
+  return function() {
+    var v = value.apply(this, arguments);
+    this.textContent = v == null ? "" : v;
+  };
+}
+
+export default function(value) {
+  return arguments.length
+      ? this.each(value == null
+          ? textRemove : (typeof value === "function"
+          ? textFunction
+          : textConstant)(value))
+      : this.node().textContent;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selector.js

@@ -0,0 +1,7 @@
+function none() {}
+
+export default function(selector) {
+  return selector == null ? none : function() {
+    return this.querySelector(selector);
+  };
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/selectorAll.js

@@ -0,0 +1,9 @@
+function empty() {
+  return [];
+}
+
+export default function(selector) {
+  return selector == null ? empty : function() {
+    return this.querySelectorAll(selector);
+  };
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/sourceEvent.js

@@ -0,0 +1,7 @@
+import {event} from "./selection/on";
+
+export default function() {
+  var current = event, source;
+  while (source = current.sourceEvent) current = source;
+  return current;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/touch.js

@@ -0,0 +1,14 @@
+import sourceEvent from "./sourceEvent";
+import point from "./point";
+
+export default function(node, touches, identifier) {
+  if (arguments.length < 3) identifier = touches, touches = sourceEvent().changedTouches;
+
+  for (var i = 0, n = touches ? touches.length : 0, touch; i < n; ++i) {
+    if ((touch = touches[i]).identifier === identifier) {
+      return point(node, touch);
+    }
+  }
+
+  return null;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/touches.js

@@ -0,0 +1,12 @@
+import sourceEvent from "./sourceEvent";
+import point from "./point";
+
+export default function(node, touches) {
+  if (touches == null) touches = sourceEvent().touches;
+
+  for (var i = 0, n = touches ? touches.length : 0, points = new Array(n); i < n; ++i) {
+    points[i] = point(node, touches[i]);
+  }
+
+  return points;
+}

lisp/emacs-application-framework/app/mermaid/node_modules/d3-selection/src/window.js

@@ -0,0 +1,5 @@
+export default function(node) {
+  return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node
+      || (node.document && node) // node is a Window
+      || node.defaultView; // node is a Document
+}