markmap-view 0.2.3 → 0.2.7

package/dist/index.js

@@ -1,4 +1,4 @@
-/*! markmap-view v0.2.3 | MIT License */
+/*! markmap-view v0.2.7 | MIT License */
 (function (exports, d3) {
 'use strict';
 
@@ -6,11 +6,11 @@ function _interopNamespace(e) {
 if (e && e.__esModule) return e;
 var n = Object.create(null);
 if (e) {
-Object.keys(e).forEach(function (k) {
+for (var k in e) {
 n[k] = e[k];
-});
 }
-n['default'] = e;
+}
+n["default"] = e;
 return Object.freeze(n);
 }
 
@@ -34,52 +34,11 @@ function _extends$1() {
   return _extends$1.apply(this, arguments);
 }
 
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-
-  return self;
-}
-
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
-  }
-}
-
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  return Constructor;
-}
-
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-
-  return _setPrototypeOf(o, p);
-}
-
-function _inheritsLoose(subClass, superClass) {
-  subClass.prototype = Object.create(superClass.prototype);
-  subClass.prototype.constructor = subClass;
-  _setPrototypeOf(subClass, superClass);
-}
-
 function count(node) {
   var sum = 0,
       children = node.children,
       i = children && children.length;
-  if (!i) sum = 1;else while (--i >= 0) {
-    sum += children[i].value;
-  }
+  if (!i) sum = 1;else while (--i >= 0) sum += children[i].value;
   node.value = sum;
 }
 
@@ -153,9 +112,7 @@ function node_sum (value) {
         children = node.children,
         i = children && children.length;
 
-    while (--i >= 0) {
-      sum += children[i].value;
-    }
+    while (--i >= 0) sum += children[i].value;
 
     node.value = sum;
   });
@@ -293,9 +250,7 @@ function copyData(node) {
 function computeHeight(node) {
   var height = 0;
 
-  do {
-    node.height = height;
-  } while ((node = node.parent) && node.height < ++height);
+  do node.height = height; while ((node = node.parent) && node.height < ++height);
 }
 function Node(data) {
   this.data = data;
@@ -318,15 +273,90 @@ Node.prototype = hierarchy.prototype = {
   copy: node_copy
 };
 
-var version = "2.1.1";
+var name = "d3-flextree";
+var version$1 = "2.1.2";
+var main = "build/d3-flextree.js";
+var module = "index";
+var author = {
+	name: "Chris Maloney",
+	url: "http://chrismaloney.org"
+};
+var description = "Flexible tree layout algorithm that allows for variable node sizes.";
+var keywords = [
+	"d3",
+	"d3-module",
+	"layout",
+	"tree",
+	"hierarchy",
+	"d3-hierarchy",
+	"plugin",
+	"d3-plugin",
+	"infovis",
+	"visualization",
+	"2d"
+];
+var homepage = "https://github.com/klortho/d3-flextree";
+var license = "WTFPL";
+var repository = {
+	type: "git",
+	url: "https://github.com/klortho/d3-flextree.git"
+};
+var scripts = {
+	clean: "rm -rf build demo test",
+	"build:demo": "rollup -c --environment BUILD:demo",
+	"build:dev": "rollup -c --environment BUILD:dev",
+	"build:prod": "rollup -c --environment BUILD:prod",
+	"build:test": "rollup -c --environment BUILD:test",
+	build: "rollup -c",
+	lint: "eslint index.js src",
+	"test:main": "node test/bundle.js",
+	"test:browser": "node test/browser-tests.js",
+	test: "npm-run-all test:*",
+	prepare: "npm-run-all clean build lint test"
+};
+var dependencies = {
+	"d3-hierarchy": "^1.1.5"
+};
+var devDependencies = {
+	"babel-plugin-external-helpers": "^6.22.0",
+	"babel-preset-es2015-rollup": "^3.0.0",
+	d3: "^4.13.0",
+	"d3-selection-multi": "^1.0.1",
+	eslint: "^4.19.1",
+	jsdom: "^11.6.2",
+	"npm-run-all": "^4.1.2",
+	rollup: "^0.55.3",
+	"rollup-plugin-babel": "^2.7.1",
+	"rollup-plugin-commonjs": "^8.0.2",
+	"rollup-plugin-copy": "^0.2.3",
+	"rollup-plugin-json": "^2.3.0",
+	"rollup-plugin-node-resolve": "^3.0.2",
+	"rollup-plugin-uglify": "^3.0.0",
+	"uglify-es": "^3.3.9"
+};
+var packageInfo = {
+	name: name,
+	version: version$1,
+	main: main,
+	module: module,
+	"jsnext:main": "index",
+	author: author,
+	description: description,
+	keywords: keywords,
+	homepage: homepage,
+	license: license,
+	repository: repository,
+	scripts: scripts,
+	dependencies: dependencies,
+	devDependencies: devDependencies
+};
 
-var defaults = Object.freeze({
-  children: function children(data) {
-    return data.children;
-  },
-  nodeSize: function nodeSize(node) {
-    return node.data.size;
-  },
+const {
+  version
+} = packageInfo;
+const defaults = Object.freeze({
+  children: data => data.children,
+  nodeSize: node => node.data.size,
   spacing: 0
 }); // Create a layout function with customizable options. Per D3-style, the
 // options can be set at any time using setter methods. The layout function
@@ -334,244 +364,192 @@ var defaults = Object.freeze({
 // time it is called.
 
 function flextree(options) {
-  var opts = Object.assign({}, defaults, options);
+  const opts = Object.assign({}, defaults, options);
 
   function accessor(name) {
-    var opt = opts[name];
-    return typeof opt === 'function' ? opt : function () {
-      return opt;
-    };
+    const opt = opts[name];
+    return typeof opt === 'function' ? opt : () => opt;
   }
 
   function layout(tree) {
-    var wtree = wrap(getWrapper(), tree, function (node) {
-      return node.children;
-    });
+    const wtree = wrap(getWrapper(), tree, node => node.children);
     wtree.update();
     return wtree.data;
   }
 
   function getFlexNode() {
-    var nodeSize = accessor('nodeSize');
+    const nodeSize = accessor('nodeSize');
+    const spacing = accessor('spacing');
+    return class FlexNode extends hierarchy.prototype.constructor {
+      constructor(data) {
+        super(data);
+      }
 
-    var _spacing = accessor('spacing');
+      copy() {
+        const c = wrap(this.constructor, this, node => node.children);
+        c.each(node => node.data = node.data.data);
+        return c;
+      }
 
-    return /*#__PURE__*/function (_hierarchy$prototype$) {
-      _inheritsLoose(FlexNode, _hierarchy$prototype$);
+      get size() {
+        return nodeSize(this);
+      }
 
-      function FlexNode(data) {
-        return _hierarchy$prototype$.call(this, data) || this;
+      spacing(oNode) {
+        return spacing(this, oNode);
       }
 
-      var _proto = FlexNode.prototype;
+      get nodes() {
+        return this.descendants();
+      }
 
-      _proto.copy = function copy() {
-        var c = wrap(this.constructor, this, function (node) {
-          return node.children;
-        });
-        c.each(function (node) {
-          return node.data = node.data.data;
-        });
-        return c;
-      };
+      get xSize() {
+        return this.size[0];
+      }
 
-      _proto.spacing = function spacing(oNode) {
-        return _spacing(this, oNode);
-      };
+      get ySize() {
+        return this.size[1];
+      }
+
+      get top() {
+        return this.y;
+      }
+
+      get bottom() {
+        return this.y + this.ySize;
+      }
+
+      get left() {
+        return this.x - this.xSize / 2;
+      }
+
+      get right() {
+        return this.x + this.xSize / 2;
+      }
+
+      get root() {
+        const ancs = this.ancestors();
+        return ancs[ancs.length - 1];
+      }
+
+      get numChildren() {
+        return this.hasChildren ? this.children.length : 0;
+      }
+
+      get hasChildren() {
+        return !this.noChildren;
+      }
+
+      get noChildren() {
+        return this.children === null;
+      }
+
+      get firstChild() {
+        return this.hasChildren ? this.children[0] : null;
+      }
+
+      get lastChild() {
+        return this.hasChildren ? this.children[this.numChildren - 1] : null;
+      }
+
+      get extents() {
+        return (this.children || []).reduce((acc, kid) => FlexNode.maxExtents(acc, kid.extents), this.nodeExtents);
+      }
+
+      get nodeExtents() {
+        return {
+          top: this.top,
+          bottom: this.bottom,
+          left: this.left,
+          right: this.right
+        };
+      }
 
-      FlexNode.maxExtents = function maxExtents(e0, e1) {
+      static maxExtents(e0, e1) {
         return {
           top: Math.min(e0.top, e1.top),
           bottom: Math.max(e0.bottom, e1.bottom),
           left: Math.min(e0.left, e1.left),
           right: Math.max(e0.right, e1.right)
         };
-      };
-
-      _createClass(FlexNode, [{
-        key: "size",
-        get: function get() {
-          return nodeSize(this);
-        }
-      }, {
-        key: "nodes",
-        get: function get() {
-          return this.descendants();
-        }
-      }, {
-        key: "xSize",
-        get: function get() {
-          return this.size[0];
-        }
-      }, {
-        key: "ySize",
-        get: function get() {
-          return this.size[1];
-        }
-      }, {
-        key: "top",
-        get: function get() {
-          return this.y;
-        }
-      }, {
-        key: "bottom",
-        get: function get() {
-          return this.y + this.ySize;
-        }
-      }, {
-        key: "left",
-        get: function get() {
-          return this.x - this.xSize / 2;
-        }
-      }, {
-        key: "right",
-        get: function get() {
-          return this.x + this.xSize / 2;
-        }
-      }, {
-        key: "root",
-        get: function get() {
-          var ancs = this.ancestors();
-          return ancs[ancs.length - 1];
-        }
-      }, {
-        key: "numChildren",
-        get: function get() {
-          return this.hasChildren ? this.children.length : 0;
-        }
-      }, {
-        key: "hasChildren",
-        get: function get() {
-          return !this.noChildren;
-        }
-      }, {
-        key: "noChildren",
-        get: function get() {
-          return this.children === null;
-        }
-      }, {
-        key: "firstChild",
-        get: function get() {
-          return this.hasChildren ? this.children[0] : null;
-        }
-      }, {
-        key: "lastChild",
-        get: function get() {
-          return this.hasChildren ? this.children[this.numChildren - 1] : null;
-        }
-      }, {
-        key: "extents",
-        get: function get() {
-          return (this.children || []).reduce(function (acc, kid) {
-            return FlexNode.maxExtents(acc, kid.extents);
-          }, this.nodeExtents);
-        }
-      }, {
-        key: "nodeExtents",
-        get: function get() {
-          return {
-            top: this.top,
-            bottom: this.bottom,
-            left: this.left,
-            right: this.right
-          };
-        }
-      }]);
+      }
 
-      return FlexNode;
-    }(hierarchy.prototype.constructor);
+    };
   }
 
   function getWrapper() {
-    var FlexNode = getFlexNode();
-    var nodeSize = accessor('nodeSize');
-
-    var _spacing2 = accessor('spacing');
-
-    return /*#__PURE__*/function (_FlexNode) {
-      _inheritsLoose(_class, _FlexNode);
-
-      function _class(data) {
-        var _this;
-
-        _this = _FlexNode.call(this, data) || this;
-        Object.assign(_assertThisInitialized(_this), {
+    const FlexNode = getFlexNode();
+    const nodeSize = accessor('nodeSize');
+    const spacing = accessor('spacing');
+    return class extends FlexNode {
+      constructor(data) {
+        super(data);
+        Object.assign(this, {
           x: 0,
           y: 0,
           relX: 0,
           prelim: 0,
           shift: 0,
           change: 0,
-          lExt: _assertThisInitialized(_this),
+          lExt: this,
           lExtRelX: 0,
           lThr: null,
-          rExt: _assertThisInitialized(_this),
+          rExt: this,
           rExtRelX: 0,
           rThr: null
         });
-        return _this;
       }
 
-      var _proto2 = _class.prototype;
+      get size() {
+        return nodeSize(this.data);
+      }
 
-      _proto2.spacing = function spacing(oNode) {
-        return _spacing2(this.data, oNode.data);
-      };
+      spacing(oNode) {
+        return spacing(this.data, oNode.data);
+      }
+
+      get x() {
+        return this.data.x;
+      }
+
+      set x(v) {
+        this.data.x = v;
+      }
 
-      _proto2.update = function update() {
+      get y() {
+        return this.data.y;
+      }
+
+      set y(v) {
+        this.data.y = v;
+      }
+
+      update() {
         layoutChildren(this);
         resolveX(this);
         return this;
-      };
-
-      _createClass(_class, [{
-        key: "size",
-        get: function get() {
-          return nodeSize(this.data);
-        }
-      }, {
-        key: "x",
-        get: function get() {
-          return this.data.x;
-        },
-        set: function set(v) {
-          this.data.x = v;
-        }
-      }, {
-        key: "y",
-        get: function get() {
-          return this.data.y;
-        },
-        set: function set(v) {
-          this.data.y = v;
-        }
-      }]);
+      }
 
-      return _class;
-    }(FlexNode);
+    };
   }
 
   function wrap(FlexClass, treeData, children) {
-    var _wrap = function _wrap(data, parent) {
-      var node = new FlexClass(data);
+    const _wrap = (data, parent) => {
+      const node = new FlexClass(data);
       Object.assign(node, {
-        parent: parent,
+        parent,
         depth: parent === null ? 0 : parent.depth + 1,
         height: 0,
         length: 1
       });
-      var kidsData = children(data) || [];
-      node.children = kidsData.length === 0 ? null : kidsData.map(function (kd) {
-        return _wrap(kd, node);
-      });
+      const kidsData = children(data) || [];
+      node.children = kidsData.length === 0 ? null : kidsData.map(kd => _wrap(kd, node));
 
       if (node.children) {
-        Object.assign(node, node.children.reduce(function (hl, kid) {
-          return {
-            height: Math.max(hl.height, kid.height + 1),
-            length: hl.length + kid.length
-          };
-        }, node));
+        Object.assign(node, node.children.reduce((hl, kid) => ({
+          height: Math.max(hl.height, kid.height + 1),
+          length: hl.length + kid.length
+        }), node));
       }
 
       return node;
@@ -581,57 +559,57 @@ function flextree(options) {
   }
 
   Object.assign(layout, {
-    nodeSize: function nodeSize(arg) {
+    nodeSize(arg) {
       return arguments.length ? (opts.nodeSize = arg, layout) : opts.nodeSize;
     },
-    spacing: function spacing(arg) {
+
+    spacing(arg) {
       return arguments.length ? (opts.spacing = arg, layout) : opts.spacing;
     },
-    children: function children(arg) {
+
+    children(arg) {
       return arguments.length ? (opts.children = arg, layout) : opts.children;
     },
-    hierarchy: function hierarchy(treeData, children) {
-      var kids = typeof children === 'undefined' ? opts.children : children;
+
+    hierarchy(treeData, children) {
+      const kids = typeof children === 'undefined' ? opts.children : children;
       return wrap(getFlexNode(), treeData, kids);
     },
-    dump: function dump(tree) {
-      var nodeSize = accessor('nodeSize');
-
-      var _dump = function _dump(i0) {
-        return function (node) {
-          var i1 = i0 + '  ';
-          var i2 = i0 + '    ';
-          var x = node.x,
-              y = node.y;
-          var size = nodeSize(node);
-          var kids = node.children || [];
-          var kdumps = kids.length === 0 ? ' ' : "," + i1 + "children: [" + i2 + kids.map(_dump(i2)).join(i2) + i1 + "]," + i0;
-          return "{ size: [" + size.join(', ') + "]," + i1 + "x: " + x + ", y: " + y + kdumps + "},";
-        };
+
+    dump(tree) {
+      const nodeSize = accessor('nodeSize');
+
+      const _dump = i0 => node => {
+        const i1 = i0 + '  ';
+        const i2 = i0 + '    ';
+        const {
+          x,
+          y
+        } = node;
+        const size = nodeSize(node);
+        const kids = node.children || [];
+        const kdumps = kids.length === 0 ? ' ' : `,${i1}children: [${i2}${kids.map(_dump(i2)).join(i2)}${i1}],${i0}`;
+        return `{ size: [${size.join(', ')}],${i1}x: ${x}, y: ${y}${kdumps}},`;
       };
 
       return _dump('\n')(tree);
     }
+
   });
   return layout;
 }
 flextree.version = version;
 
-var layoutChildren = function layoutChildren(w, y) {
-  if (y === void 0) {
-    y = 0;
-  }
-
+const layoutChildren = (w, y = 0) => {
   w.y = y;
-  (w.children || []).reduce(function (acc, kid) {
-    var i = acc[0],
-        lastLows = acc[1];
+  (w.children || []).reduce((acc, kid) => {
+    const [i, lastLows] = acc;
     layoutChildren(kid, w.y + w.ySize); // The lowest vertical coordinate while extreme nodes still point
     // in current subtree.
 
-    var lowY = (i === 0 ? kid.lExt : kid.rExt).bottom;
+    const lowY = (i === 0 ? kid.lExt : kid.rExt).bottom;
     if (i !== 0) separate(w, i, lastLows);
-    var lows = updateLows(lowY, i, lastLows);
+    const lows = updateLows(lowY, i, lastLows);
     return [i + 1, lows];
   }, [0, null]);
   shiftChange(w);
@@ -643,7 +621,7 @@ var layoutChildren = function layoutChildren(w, y) {
 // to its parent.
 
 
-var resolveX = function resolveX(w, prevSum, parentX) {
+const resolveX = (w, prevSum, parentX) => {
   // A call to resolveX without arguments is assumed to be for the root of
   // the tree. This will set the root's x-coord to zero.
   if (typeof prevSum === 'undefined') {
@@ -651,24 +629,21 @@ var resolveX = function resolveX(w, prevSum, parentX) {
     parentX = 0;
   }
 
-  var sum = prevSum + w.relX;
+  const sum = prevSum + w.relX;
   w.relX = sum + w.prelim - parentX;
   w.prelim = 0;
   w.x = parentX + w.relX;
-  (w.children || []).forEach(function (k) {
-    return resolveX(k, sum, w.x);
-  });
+  (w.children || []).forEach(k => resolveX(k, sum, w.x));
   return w;
 }; // Process shift and change for all children, to add intermediate spacing to
 // each child's modifier.
 
 
-var shiftChange = function shiftChange(w) {
-  (w.children || []).reduce(function (acc, child) {
-    var lastShiftSum = acc[0],
-        lastChangeSum = acc[1];
-    var shiftSum = lastShiftSum + child.shift;
-    var changeSum = lastChangeSum + shiftSum + child.change;
+const shiftChange = w => {
+  (w.children || []).reduce((acc, child) => {
+    const [lastShiftSum, lastChangeSum] = acc;
+    const shiftSum = lastShiftSum + child.shift;
+    const changeSum = lastChangeSum + shiftSum + child.change;
     child.relX += changeSum;
     return [shiftSum, changeSum];
   }, [0, 0]);
@@ -677,21 +652,21 @@ var shiftChange = function shiftChange(w) {
 /* eslint-disable complexity */
 
 
-var separate = function separate(w, i, lows) {
-  var lSib = w.children[i - 1];
-  var curSubtree = w.children[i];
-  var rContour = lSib;
-  var rSumMods = lSib.relX;
-  var lContour = curSubtree;
-  var lSumMods = curSubtree.relX;
-  var isFirst = true;
+const separate = (w, i, lows) => {
+  const lSib = w.children[i - 1];
+  const curSubtree = w.children[i];
+  let rContour = lSib;
+  let rSumMods = lSib.relX;
+  let lContour = curSubtree;
+  let lSumMods = curSubtree.relX;
+  let isFirst = true;
 
   while (rContour && lContour) {
     if (rContour.bottom > lows.lowY) lows = lows.next; // How far to the left of the right side of rContour is the left side
     // of lContour? First compute the center-to-center distance, then add
     // the "spacing"
 
-    var dist = rSumMods + rContour.prelim - (lSumMods + lContour.prelim) + rContour.xSize / 2 + lContour.xSize / 2 + rContour.spacing(lContour);
+    const dist = rSumMods + rContour.prelim - (lSumMods + lContour.prelim) + rContour.xSize / 2 + lContour.xSize / 2 + rContour.spacing(lContour);
 
     if (dist > 0 || dist < 0 && isFirst) {
       lSumMods += dist; // Move subtree by changing relX.
@@ -702,8 +677,8 @@ var separate = function separate(w, i, lows) {
 
     isFirst = false; // Advance highest node(s) and sum(s) of modifiers
 
-    var rightBottom = rContour.bottom;
-    var leftBottom = lContour.bottom;
+    const rightBottom = rContour.bottom;
+    const leftBottom = lContour.bottom;
 
     if (rightBottom <= leftBottom) {
       rContour = nextRContour(rContour);
@@ -725,39 +700,39 @@ var separate = function separate(w, i, lows) {
 // Move subtree by changing relX.
 
 
-var moveSubtree = function moveSubtree(subtree, distance) {
+const moveSubtree = (subtree, distance) => {
   subtree.relX += distance;
   subtree.lExtRelX += distance;
   subtree.rExtRelX += distance;
 };
 
-var distributeExtra = function distributeExtra(w, curSubtreeI, leftSibI, dist) {
-  var curSubtree = w.children[curSubtreeI];
-  var n = curSubtreeI - leftSibI; // Are there intermediate children?
+const distributeExtra = (w, curSubtreeI, leftSibI, dist) => {
+  const curSubtree = w.children[curSubtreeI];
+  const n = curSubtreeI - leftSibI; // Are there intermediate children?
 
   if (n > 1) {
-    var delta = dist / n;
+    const delta = dist / n;
     w.children[leftSibI + 1].shift += delta;
     curSubtree.shift -= delta;
     curSubtree.change -= dist - delta;
   }
 };
 
-var nextLContour = function nextLContour(w) {
+const nextLContour = w => {
   return w.hasChildren ? w.firstChild : w.lThr;
 };
 
-var nextRContour = function nextRContour(w) {
+const nextRContour = w => {
   return w.hasChildren ? w.lastChild : w.rThr;
 };
 
-var setLThr = function setLThr(w, i, lContour, lSumMods) {
-  var firstChild = w.firstChild;
-  var lExt = firstChild.lExt;
-  var curSubtree = w.children[i];
+const setLThr = (w, i, lContour, lSumMods) => {
+  const firstChild = w.firstChild;
+  const lExt = firstChild.lExt;
+  const curSubtree = w.children[i];
   lExt.lThr = lContour; // Change relX so that the sum of modifier after following thread is correct.
 
-  var diff = lSumMods - lContour.relX - firstChild.lExtRelX;
+  const diff = lSumMods - lContour.relX - firstChild.lExtRelX;
   lExt.relX += diff; // Change preliminary x coordinate so that the node does not move.
 
   lExt.prelim -= diff; // Update extreme node and its sum of modifiers.
@@ -767,12 +742,12 @@ var setLThr = function setLThr(w, i, lContour, lSumMods) {
 }; // Mirror image of setLThr.
 
 
-var setRThr = function setRThr(w, i, rContour, rSumMods) {
-  var curSubtree = w.children[i];
-  var rExt = curSubtree.rExt;
-  var lSib = w.children[i - 1];
+const setRThr = (w, i, rContour, rSumMods) => {
+  const curSubtree = w.children[i];
+  const rExt = curSubtree.rExt;
+  const lSib = w.children[i - 1];
   rExt.rThr = rContour;
-  var diff = rSumMods - rContour.relX - curSubtree.rExtRelX;
+  const diff = rSumMods - rContour.relX - curSubtree.rExtRelX;
   rExt.relX += diff;
   rExt.prelim -= diff;
   curSubtree.rExt = lSib.rExt;
@@ -780,13 +755,13 @@ var setRThr = function setRThr(w, i, rContour, rSumMods) {
 }; // Position root between children, taking into account their modifiers
 
 
-var positionRoot = function positionRoot(w) {
+const positionRoot = w => {
   if (w.hasChildren) {
-    var k0 = w.firstChild;
-    var kf = w.lastChild;
-    var prelim = (k0.prelim + k0.relX - k0.xSize / 2 + kf.relX + kf.prelim + kf.xSize / 2) / 2;
+    const k0 = w.firstChild;
+    const kf = w.lastChild;
+    const prelim = (k0.prelim + k0.relX - k0.xSize / 2 + kf.relX + kf.prelim + kf.xSize / 2) / 2;
     Object.assign(w, {
-      prelim: prelim,
+      prelim,
       lExt: k0.lExt,
       lExtRelX: k0.lExtRelX,
       rExt: kf.rExt,
@@ -797,21 +772,19 @@ var positionRoot = function positionRoot(w) {
 // lowest vertical coordinate.
 
 
-var updateLows = function updateLows(lowY, index, lastLows) {
+const updateLows = (lowY, index, lastLows) => {
   // Remove siblings that are hidden by the new subtree.
-  while (lastLows !== null && lowY >= lastLows.lowY) {
-    lastLows = lastLows.next;
-  } // Prepend the new subtree.
+  while (lastLows !== null && lowY >= lastLows.lowY) lastLows = lastLows.next; // Prepend the new subtree.
 
 
   return {
-    lowY: lowY,
-    index: index,
+    lowY,
+    index,
     next: lastLows
   };
 };
 
-/*! markmap-common v0.1.4 | MIT License */
+/*! markmap-common v0.1.6 | MIT License */
 class Hook {
   constructor() {
     this.listeners = [];
@@ -1049,13 +1022,6 @@ function createViewHooks() {
 const refreshHook = new Hook();
 class Markmap {
   constructor(svg, opts) {
-    this.options = void 0;
-    this.state = void 0;
-    this.svg = void 0;
-    this.styleNode = void 0;
-    this.g = void 0;
-    this.zoom = void 0;
-    this.viewHooks = void 0;
     this.revokers = [];
     ['handleZoom', 'handleClick'].forEach(key => {
       this[key] = this[key].bind(this);
@@ -1196,9 +1162,8 @@ ${this.getStyleContent()}
   }
 
   setData(data, opts) {
-    if (!data) data = _extends$1({}, this.state.data);
-    this.state.data = data;
-    this.initializeData(data);
+    if (data) this.state.data = data;
+    this.initializeData(this.state.data);
     if (opts) this.setOptions(opts);
     this.renderData();
   }
@@ -1271,9 +1236,9 @@ ${this.getStyleContent()}
     const foreignObject = nodeMerge.selectAll(childSelector('foreignObject')).data(d => [d], d => d.data.p.k).join(enter => {
       const fo = enter.append('foreignObject').attr('class', `${id}-fo`).attr('x', paddingX).attr('y', 0).style('opacity', 0).attr('height', d => d.xSize).on('mousedown', stopPropagation).on('dblclick', stopPropagation);
       fo.append('xhtml:div').select(function select(d) {
-        const node = d.data.p.el.cloneNode(true);
-        this.replaceWith(node);
-        return node;
+        const clone = d.data.p.el.cloneNode(true);
+        this.replaceWith(clone);
+        return clone;
       }).attr('xmlns', 'http://www.w3.org/1999/xhtml');
       return fo;
     }, update => update, exit => exit.remove()).attr('width', d => Math.max(0, d.ySizeInner - paddingX * 2));
@@ -1430,4 +1395,4 @@ exports.loadCSS = loadCSS;
 exports.loadJS = loadJS;
 exports.refreshHook = refreshHook;
 
-}(this.markmap = this.markmap || {}, d3));
+})(this.markmap = this.markmap || {}, d3);