@fluentui/react-charting 4.23.7 → 4.23.9

package/dist/react-charting.js

@@ -3115,6 +3115,1720 @@ __webpack_require__.r(__webpack_exports__);
 });
 
 
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/accessors.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "optional", function() { return optional; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "required", function() { return required; });
+function optional(f) {
+  return f == null ? null : required(f);
+}
+
+function required(f) {
+  if (typeof f !== "function") throw new Error;
+  return f;
+}
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/array.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "shuffle", function() { return shuffle; });
+/* harmony default export */ __webpack_exports__["default"] = (function(x) {
+  return typeof x === "object" && "length" in x
+    ? x // Array, TypedArray, NodeList, array-like
+    : Array.from(x); // Map, Set, iterable, string, or anything else
+});
+
+function shuffle(array) {
+  var m = array.length,
+      t,
+      i;
+
+  while (m) {
+    i = Math.random() * m-- | 0;
+    t = array[m];
+    array[m] = array[i];
+    array[i] = t;
+  }
+
+  return array;
+}
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/cluster.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+function defaultSeparation(a, b) {
+  return a.parent === b.parent ? 1 : 2;
+}
+
+function meanX(children) {
+  return children.reduce(meanXReduce, 0) / children.length;
+}
+
+function meanXReduce(x, c) {
+  return x + c.x;
+}
+
+function maxY(children) {
+  return 1 + children.reduce(maxYReduce, 0);
+}
+
+function maxYReduce(y, c) {
+  return Math.max(y, c.y);
+}
+
+function leafLeft(node) {
+  var children;
+  while (children = node.children) node = children[0];
+  return node;
+}
+
+function leafRight(node) {
+  var children;
+  while (children = node.children) node = children[children.length - 1];
+  return node;
+}
+
+/* harmony default export */ __webpack_exports__["default"] = (function() {
+  var separation = defaultSeparation,
+      dx = 1,
+      dy = 1,
+      nodeSize = false;
+
+  function cluster(root) {
+    var previousNode,
+        x = 0;
+
+    // First walk, computing the initial x & y values.
+    root.eachAfter(function(node) {
+      var children = node.children;
+      if (children) {
+        node.x = meanX(children);
+        node.y = maxY(children);
+      } else {
+        node.x = previousNode ? x += separation(node, previousNode) : 0;
+        node.y = 0;
+        previousNode = node;
+      }
+    });
+
+    var left = leafLeft(root),
+        right = leafRight(root),
+        x0 = left.x - separation(left, right) / 2,
+        x1 = right.x + separation(right, left) / 2;
+
+    // Second walk, normalizing x & y to the desired size.
+    return root.eachAfter(nodeSize ? function(node) {
+      node.x = (node.x - root.x) * dx;
+      node.y = (root.y - node.y) * dy;
+    } : function(node) {
+      node.x = (node.x - x0) / (x1 - x0) * dx;
+      node.y = (1 - (root.y ? node.y / root.y : 1)) * dy;
+    });
+  }
+
+  cluster.separation = function(x) {
+    return arguments.length ? (separation = x, cluster) : separation;
+  };
+
+  cluster.size = function(x) {
+    return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? null : [dx, dy]);
+  };
+
+  cluster.nodeSize = function(x) {
+    return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? [dx, dy] : null);
+  };
+
+  return cluster;
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/constant.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "constantZero", function() { return constantZero; });
+function constantZero() {
+  return 0;
+}
+
+/* harmony default export */ __webpack_exports__["default"] = (function(x) {
+  return function() {
+    return x;
+  };
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/hierarchy/ancestors.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function() {
+  var node = this, nodes = [node];
+  while (node = node.parent) {
+    nodes.push(node);
+  }
+  return nodes;
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/hierarchy/count.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+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;
+  node.value = sum;
+}
+
+/* harmony default export */ __webpack_exports__["default"] = (function() {
+  return this.eachAfter(count);
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/hierarchy/descendants.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function() {
+  return Array.from(this);
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/hierarchy/each.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function(callback, that) {
+  let index = -1;
+  for (const node of this) {
+    callback.call(that, node, ++index, this);
+  }
+  return this;
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/hierarchy/eachAfter.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function(callback, that) {
+  var node = this, nodes = [node], next = [], children, i, n, index = -1;
+  while (node = nodes.pop()) {
+    next.push(node);
+    if (children = node.children) {
+      for (i = 0, n = children.length; i < n; ++i) {
+        nodes.push(children[i]);
+      }
+    }
+  }
+  while (node = next.pop()) {
+    callback.call(that, node, ++index, this);
+  }
+  return this;
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/hierarchy/eachBefore.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function(callback, that) {
+  var node = this, nodes = [node], children, i, index = -1;
+  while (node = nodes.pop()) {
+    callback.call(that, node, ++index, this);
+    if (children = node.children) {
+      for (i = children.length - 1; i >= 0; --i) {
+        nodes.push(children[i]);
+      }
+    }
+  }
+  return this;
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/hierarchy/find.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function(callback, that) {
+  let index = -1;
+  for (const node of this) {
+    if (callback.call(that, node, ++index, this)) {
+      return node;
+    }
+  }
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/hierarchy/index.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return hierarchy; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "computeHeight", function() { return computeHeight; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Node", function() { return Node; });
+/* harmony import */ var _count_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/count.js");
+/* harmony import */ var _each_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/each.js");
+/* harmony import */ var _eachBefore_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/eachBefore.js");
+/* harmony import */ var _eachAfter_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/eachAfter.js");
+/* harmony import */ var _find_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/find.js");
+/* harmony import */ var _sum_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/sum.js");
+/* harmony import */ var _sort_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/sort.js");
+/* harmony import */ var _path_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/path.js");
+/* harmony import */ var _ancestors_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/ancestors.js");
+/* harmony import */ var _descendants_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/descendants.js");
+/* harmony import */ var _leaves_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/leaves.js");
+/* harmony import */ var _links_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/links.js");
+/* harmony import */ var _iterator_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/iterator.js");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function hierarchy(data, children) {
+  if (data instanceof Map) {
+    data = [undefined, data];
+    if (children === undefined) children = mapChildren;
+  } else if (children === undefined) {
+    children = objectChildren;
+  }
+
+  var root = new Node(data),
+      node,
+      nodes = [root],
+      child,
+      childs,
+      i,
+      n;
+
+  while (node = nodes.pop()) {
+    if ((childs = children(node.data)) && (n = (childs = Array.from(childs)).length)) {
+      node.children = childs;
+      for (i = n - 1; i >= 0; --i) {
+        nodes.push(child = childs[i] = new Node(childs[i]));
+        child.parent = node;
+        child.depth = node.depth + 1;
+      }
+    }
+  }
+
+  return root.eachBefore(computeHeight);
+}
+
+function node_copy() {
+  return hierarchy(this).eachBefore(copyData);
+}
+
+function objectChildren(d) {
+  return d.children;
+}
+
+function mapChildren(d) {
+  return Array.isArray(d) ? d[1] : null;
+}
+
+function copyData(node) {
+  if (node.data.value !== undefined) node.value = node.data.value;
+  node.data = node.data.data;
+}
+
+function computeHeight(node) {
+  var height = 0;
+  do node.height = height;
+  while ((node = node.parent) && (node.height < ++height));
+}
+
+function Node(data) {
+  this.data = data;
+  this.depth =
+  this.height = 0;
+  this.parent = null;
+}
+
+Node.prototype = hierarchy.prototype = {
+  constructor: Node,
+  count: _count_js__WEBPACK_IMPORTED_MODULE_0__["default"],
+  each: _each_js__WEBPACK_IMPORTED_MODULE_1__["default"],
+  eachAfter: _eachAfter_js__WEBPACK_IMPORTED_MODULE_3__["default"],
+  eachBefore: _eachBefore_js__WEBPACK_IMPORTED_MODULE_2__["default"],
+  find: _find_js__WEBPACK_IMPORTED_MODULE_4__["default"],
+  sum: _sum_js__WEBPACK_IMPORTED_MODULE_5__["default"],
+  sort: _sort_js__WEBPACK_IMPORTED_MODULE_6__["default"],
+  path: _path_js__WEBPACK_IMPORTED_MODULE_7__["default"],
+  ancestors: _ancestors_js__WEBPACK_IMPORTED_MODULE_8__["default"],
+  descendants: _descendants_js__WEBPACK_IMPORTED_MODULE_9__["default"],
+  leaves: _leaves_js__WEBPACK_IMPORTED_MODULE_10__["default"],
+  links: _links_js__WEBPACK_IMPORTED_MODULE_11__["default"],
+  copy: node_copy,
+  [Symbol.iterator]: _iterator_js__WEBPACK_IMPORTED_MODULE_12__["default"]
+};
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/hierarchy/iterator.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function*() {
+  var node = this, current, next = [node], children, i, n;
+  do {
+    current = next.reverse(), next = [];
+    while (node = current.pop()) {
+      yield node;
+      if (children = node.children) {
+        for (i = 0, n = children.length; i < n; ++i) {
+          next.push(children[i]);
+        }
+      }
+    }
+  } while (next.length);
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/hierarchy/leaves.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function() {
+  var leaves = [];
+  this.eachBefore(function(node) {
+    if (!node.children) {
+      leaves.push(node);
+    }
+  });
+  return leaves;
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/hierarchy/links.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function() {
+  var root = this, links = [];
+  root.each(function(node) {
+    if (node !== root) { // Don’t include the root’s parent, if any.
+      links.push({source: node.parent, target: node});
+    }
+  });
+  return links;
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/hierarchy/path.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function(end) {
+  var start = this,
+      ancestor = leastCommonAncestor(start, end),
+      nodes = [start];
+  while (start !== ancestor) {
+    start = start.parent;
+    nodes.push(start);
+  }
+  var k = nodes.length;
+  while (end !== ancestor) {
+    nodes.splice(k, 0, end);
+    end = end.parent;
+  }
+  return nodes;
+});
+
+function leastCommonAncestor(a, b) {
+  if (a === b) return a;
+  var aNodes = a.ancestors(),
+      bNodes = b.ancestors(),
+      c = null;
+  a = aNodes.pop();
+  b = bNodes.pop();
+  while (a === b) {
+    c = a;
+    a = aNodes.pop();
+    b = bNodes.pop();
+  }
+  return c;
+}
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/hierarchy/sort.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function(compare) {
+  return this.eachBefore(function(node) {
+    if (node.children) {
+      node.children.sort(compare);
+    }
+  });
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/hierarchy/sum.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function(value) {
+  return this.eachAfter(function(node) {
+    var sum = +value(node.data) || 0,
+        children = node.children,
+        i = children && children.length;
+    while (--i >= 0) sum += children[i].value;
+    node.value = sum;
+  });
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/index.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _cluster_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/d3-hierarchy/src/cluster.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "cluster", function() { return _cluster_js__WEBPACK_IMPORTED_MODULE_0__["default"]; });
+
+/* harmony import */ var _hierarchy_index_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/index.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "hierarchy", function() { return _hierarchy_index_js__WEBPACK_IMPORTED_MODULE_1__["default"]; });
+
+/* harmony import */ var _pack_index_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../../node_modules/d3-hierarchy/src/pack/index.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "pack", function() { return _pack_index_js__WEBPACK_IMPORTED_MODULE_2__["default"]; });
+
+/* harmony import */ var _pack_siblings_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("../../node_modules/d3-hierarchy/src/pack/siblings.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "packSiblings", function() { return _pack_siblings_js__WEBPACK_IMPORTED_MODULE_3__["default"]; });
+
+/* harmony import */ var _pack_enclose_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("../../node_modules/d3-hierarchy/src/pack/enclose.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "packEnclose", function() { return _pack_enclose_js__WEBPACK_IMPORTED_MODULE_4__["default"]; });
+
+/* harmony import */ var _partition_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("../../node_modules/d3-hierarchy/src/partition.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "partition", function() { return _partition_js__WEBPACK_IMPORTED_MODULE_5__["default"]; });
+
+/* harmony import */ var _stratify_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("../../node_modules/d3-hierarchy/src/stratify.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stratify", function() { return _stratify_js__WEBPACK_IMPORTED_MODULE_6__["default"]; });
+
+/* harmony import */ var _tree_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__("../../node_modules/d3-hierarchy/src/tree.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tree", function() { return _tree_js__WEBPACK_IMPORTED_MODULE_7__["default"]; });
+
+/* harmony import */ var _treemap_index_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/index.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemap", function() { return _treemap_index_js__WEBPACK_IMPORTED_MODULE_8__["default"]; });
+
+/* harmony import */ var _treemap_binary_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/binary.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapBinary", function() { return _treemap_binary_js__WEBPACK_IMPORTED_MODULE_9__["default"]; });
+
+/* harmony import */ var _treemap_dice_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/dice.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapDice", function() { return _treemap_dice_js__WEBPACK_IMPORTED_MODULE_10__["default"]; });
+
+/* harmony import */ var _treemap_slice_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/slice.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapSlice", function() { return _treemap_slice_js__WEBPACK_IMPORTED_MODULE_11__["default"]; });
+
+/* harmony import */ var _treemap_sliceDice_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/sliceDice.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapSliceDice", function() { return _treemap_sliceDice_js__WEBPACK_IMPORTED_MODULE_12__["default"]; });
+
+/* harmony import */ var _treemap_squarify_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/squarify.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapSquarify", function() { return _treemap_squarify_js__WEBPACK_IMPORTED_MODULE_13__["default"]; });
+
+/* harmony import */ var _treemap_resquarify_js__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/resquarify.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapResquarify", function() { return _treemap_resquarify_js__WEBPACK_IMPORTED_MODULE_14__["default"]; });
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/pack/enclose.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _array_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/d3-hierarchy/src/array.js");
+
+
+/* harmony default export */ __webpack_exports__["default"] = (function(circles) {
+  var i = 0, n = (circles = Object(_array_js__WEBPACK_IMPORTED_MODULE_0__["shuffle"])(Array.from(circles))).length, B = [], p, e;
+
+  while (i < n) {
+    p = circles[i];
+    if (e && enclosesWeak(e, p)) ++i;
+    else e = encloseBasis(B = extendBasis(B, p)), i = 0;
+  }
+
+  return e;
+});
+
+function extendBasis(B, p) {
+  var i, j;
+
+  if (enclosesWeakAll(p, B)) return [p];
+
+  // If we get here then B must have at least one element.
+  for (i = 0; i < B.length; ++i) {
+    if (enclosesNot(p, B[i])
+        && enclosesWeakAll(encloseBasis2(B[i], p), B)) {
+      return [B[i], p];
+    }
+  }
+
+  // If we get here then B must have at least two elements.
+  for (i = 0; i < B.length - 1; ++i) {
+    for (j = i + 1; j < B.length; ++j) {
+      if (enclosesNot(encloseBasis2(B[i], B[j]), p)
+          && enclosesNot(encloseBasis2(B[i], p), B[j])
+          && enclosesNot(encloseBasis2(B[j], p), B[i])
+          && enclosesWeakAll(encloseBasis3(B[i], B[j], p), B)) {
+        return [B[i], B[j], p];
+      }
+    }
+  }
+
+  // If we get here then something is very wrong.
+  throw new Error;
+}
+
+function enclosesNot(a, b) {
+  var dr = a.r - b.r, dx = b.x - a.x, dy = b.y - a.y;
+  return dr < 0 || dr * dr < dx * dx + dy * dy;
+}
+
+function enclosesWeak(a, b) {
+  var dr = a.r - b.r + Math.max(a.r, b.r, 1) * 1e-9, dx = b.x - a.x, dy = b.y - a.y;
+  return dr > 0 && dr * dr > dx * dx + dy * dy;
+}
+
+function enclosesWeakAll(a, B) {
+  for (var i = 0; i < B.length; ++i) {
+    if (!enclosesWeak(a, B[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function encloseBasis(B) {
+  switch (B.length) {
+    case 1: return encloseBasis1(B[0]);
+    case 2: return encloseBasis2(B[0], B[1]);
+    case 3: return encloseBasis3(B[0], B[1], B[2]);
+  }
+}
+
+function encloseBasis1(a) {
+  return {
+    x: a.x,
+    y: a.y,
+    r: a.r
+  };
+}
+
+function encloseBasis2(a, b) {
+  var x1 = a.x, y1 = a.y, r1 = a.r,
+      x2 = b.x, y2 = b.y, r2 = b.r,
+      x21 = x2 - x1, y21 = y2 - y1, r21 = r2 - r1,
+      l = Math.sqrt(x21 * x21 + y21 * y21);
+  return {
+    x: (x1 + x2 + x21 / l * r21) / 2,
+    y: (y1 + y2 + y21 / l * r21) / 2,
+    r: (l + r1 + r2) / 2
+  };
+}
+
+function encloseBasis3(a, b, c) {
+  var x1 = a.x, y1 = a.y, r1 = a.r,
+      x2 = b.x, y2 = b.y, r2 = b.r,
+      x3 = c.x, y3 = c.y, r3 = c.r,
+      a2 = x1 - x2,
+      a3 = x1 - x3,
+      b2 = y1 - y2,
+      b3 = y1 - y3,
+      c2 = r2 - r1,
+      c3 = r3 - r1,
+      d1 = x1 * x1 + y1 * y1 - r1 * r1,
+      d2 = d1 - x2 * x2 - y2 * y2 + r2 * r2,
+      d3 = d1 - x3 * x3 - y3 * y3 + r3 * r3,
+      ab = a3 * b2 - a2 * b3,
+      xa = (b2 * d3 - b3 * d2) / (ab * 2) - x1,
+      xb = (b3 * c2 - b2 * c3) / ab,
+      ya = (a3 * d2 - a2 * d3) / (ab * 2) - y1,
+      yb = (a2 * c3 - a3 * c2) / ab,
+      A = xb * xb + yb * yb - 1,
+      B = 2 * (r1 + xa * xb + ya * yb),
+      C = xa * xa + ya * ya - r1 * r1,
+      r = -(A ? (B + Math.sqrt(B * B - 4 * A * C)) / (2 * A) : C / B);
+  return {
+    x: x1 + xa + xb * r,
+    y: y1 + ya + yb * r,
+    r: r
+  };
+}
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/pack/index.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _siblings_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/d3-hierarchy/src/pack/siblings.js");
+/* harmony import */ var _accessors_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/d3-hierarchy/src/accessors.js");
+/* harmony import */ var _constant_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../../node_modules/d3-hierarchy/src/constant.js");
+
+
+
+
+function defaultRadius(d) {
+  return Math.sqrt(d.value);
+}
+
+/* harmony default export */ __webpack_exports__["default"] = (function() {
+  var radius = null,
+      dx = 1,
+      dy = 1,
+      padding = _constant_js__WEBPACK_IMPORTED_MODULE_2__["constantZero"];
+
+  function pack(root) {
+    root.x = dx / 2, root.y = dy / 2;
+    if (radius) {
+      root.eachBefore(radiusLeaf(radius))
+          .eachAfter(packChildren(padding, 0.5))
+          .eachBefore(translateChild(1));
+    } else {
+      root.eachBefore(radiusLeaf(defaultRadius))
+          .eachAfter(packChildren(_constant_js__WEBPACK_IMPORTED_MODULE_2__["constantZero"], 1))
+          .eachAfter(packChildren(padding, root.r / Math.min(dx, dy)))
+          .eachBefore(translateChild(Math.min(dx, dy) / (2 * root.r)));
+    }
+    return root;
+  }
+
+  pack.radius = function(x) {
+    return arguments.length ? (radius = Object(_accessors_js__WEBPACK_IMPORTED_MODULE_1__["optional"])(x), pack) : radius;
+  };
+
+  pack.size = function(x) {
+    return arguments.length ? (dx = +x[0], dy = +x[1], pack) : [dx, dy];
+  };
+
+  pack.padding = function(x) {
+    return arguments.length ? (padding = typeof x === "function" ? x : Object(_constant_js__WEBPACK_IMPORTED_MODULE_2__["default"])(+x), pack) : padding;
+  };
+
+  return pack;
+});
+
+function radiusLeaf(radius) {
+  return function(node) {
+    if (!node.children) {
+      node.r = Math.max(0, +radius(node) || 0);
+    }
+  };
+}
+
+function packChildren(padding, k) {
+  return function(node) {
+    if (children = node.children) {
+      var children,
+          i,
+          n = children.length,
+          r = padding(node) * k || 0,
+          e;
+
+      if (r) for (i = 0; i < n; ++i) children[i].r += r;
+      e = Object(_siblings_js__WEBPACK_IMPORTED_MODULE_0__["packEnclose"])(children);
+      if (r) for (i = 0; i < n; ++i) children[i].r -= r;
+      node.r = e + r;
+    }
+  };
+}
+
+function translateChild(k) {
+  return function(node) {
+    var parent = node.parent;
+    node.r *= k;
+    if (parent) {
+      node.x = parent.x + k * node.x;
+      node.y = parent.y + k * node.y;
+    }
+  };
+}
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/pack/siblings.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "packEnclose", function() { return packEnclose; });
+/* harmony import */ var _array_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/d3-hierarchy/src/array.js");
+/* harmony import */ var _enclose_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/d3-hierarchy/src/pack/enclose.js");
+
+
+
+function place(b, a, c) {
+  var dx = b.x - a.x, x, a2,
+      dy = b.y - a.y, y, b2,
+      d2 = dx * dx + dy * dy;
+  if (d2) {
+    a2 = a.r + c.r, a2 *= a2;
+    b2 = b.r + c.r, b2 *= b2;
+    if (a2 > b2) {
+      x = (d2 + b2 - a2) / (2 * d2);
+      y = Math.sqrt(Math.max(0, b2 / d2 - x * x));
+      c.x = b.x - x * dx - y * dy;
+      c.y = b.y - x * dy + y * dx;
+    } else {
+      x = (d2 + a2 - b2) / (2 * d2);
+      y = Math.sqrt(Math.max(0, a2 / d2 - x * x));
+      c.x = a.x + x * dx - y * dy;
+      c.y = a.y + x * dy + y * dx;
+    }
+  } else {
+    c.x = a.x + c.r;
+    c.y = a.y;
+  }
+}
+
+function intersects(a, b) {
+  var dr = a.r + b.r - 1e-6, dx = b.x - a.x, dy = b.y - a.y;
+  return dr > 0 && dr * dr > dx * dx + dy * dy;
+}
+
+function score(node) {
+  var a = node._,
+      b = node.next._,
+      ab = a.r + b.r,
+      dx = (a.x * b.r + b.x * a.r) / ab,
+      dy = (a.y * b.r + b.y * a.r) / ab;
+  return dx * dx + dy * dy;
+}
+
+function Node(circle) {
+  this._ = circle;
+  this.next = null;
+  this.previous = null;
+}
+
+function packEnclose(circles) {
+  if (!(n = (circles = Object(_array_js__WEBPACK_IMPORTED_MODULE_0__["default"])(circles)).length)) return 0;
+
+  var a, b, c, n, aa, ca, i, j, k, sj, sk;
+
+  // Place the first circle.
+  a = circles[0], a.x = 0, a.y = 0;
+  if (!(n > 1)) return a.r;
+
+  // Place the second circle.
+  b = circles[1], a.x = -b.r, b.x = a.r, b.y = 0;
+  if (!(n > 2)) return a.r + b.r;
+
+  // Place the third circle.
+  place(b, a, c = circles[2]);
+
+  // Initialize the front-chain using the first three circles a, b and c.
+  a = new Node(a), b = new Node(b), c = new Node(c);
+  a.next = c.previous = b;
+  b.next = a.previous = c;
+  c.next = b.previous = a;
+
+  // Attempt to place each remaining circle…
+  pack: for (i = 3; i < n; ++i) {
+    place(a._, b._, c = circles[i]), c = new Node(c);
+
+    // Find the closest intersecting circle on the front-chain, if any.
+    // “Closeness” is determined by linear distance along the front-chain.
+    // “Ahead” or “behind” is likewise determined by linear distance.
+    j = b.next, k = a.previous, sj = b._.r, sk = a._.r;
+    do {
+      if (sj <= sk) {
+        if (intersects(j._, c._)) {
+          b = j, a.next = b, b.previous = a, --i;
+          continue pack;
+        }
+        sj += j._.r, j = j.next;
+      } else {
+        if (intersects(k._, c._)) {
+          a = k, a.next = b, b.previous = a, --i;
+          continue pack;
+        }
+        sk += k._.r, k = k.previous;
+      }
+    } while (j !== k.next);
+
+    // Success! Insert the new circle c between a and b.
+    c.previous = a, c.next = b, a.next = b.previous = b = c;
+
+    // Compute the new closest circle pair to the centroid.
+    aa = score(a);
+    while ((c = c.next) !== b) {
+      if ((ca = score(c)) < aa) {
+        a = c, aa = ca;
+      }
+    }
+    b = a.next;
+  }
+
+  // Compute the enclosing circle of the front chain.
+  a = [b._], c = b; while ((c = c.next) !== b) a.push(c._); c = Object(_enclose_js__WEBPACK_IMPORTED_MODULE_1__["default"])(a);
+
+  // Translate the circles to put the enclosing circle around the origin.
+  for (i = 0; i < n; ++i) a = circles[i], a.x -= c.x, a.y -= c.y;
+
+  return c.r;
+}
+
+/* harmony default export */ __webpack_exports__["default"] = (function(circles) {
+  packEnclose(circles);
+  return circles;
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/partition.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _treemap_round_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/round.js");
+/* harmony import */ var _treemap_dice_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/dice.js");
+
+
+
+/* harmony default export */ __webpack_exports__["default"] = (function() {
+  var dx = 1,
+      dy = 1,
+      padding = 0,
+      round = false;
+
+  function partition(root) {
+    var n = root.height + 1;
+    root.x0 =
+    root.y0 = padding;
+    root.x1 = dx;
+    root.y1 = dy / n;
+    root.eachBefore(positionNode(dy, n));
+    if (round) root.eachBefore(_treemap_round_js__WEBPACK_IMPORTED_MODULE_0__["default"]);
+    return root;
+  }
+
+  function positionNode(dy, n) {
+    return function(node) {
+      if (node.children) {
+        Object(_treemap_dice_js__WEBPACK_IMPORTED_MODULE_1__["default"])(node, node.x0, dy * (node.depth + 1) / n, node.x1, dy * (node.depth + 2) / n);
+      }
+      var x0 = node.x0,
+          y0 = node.y0,
+          x1 = node.x1 - padding,
+          y1 = node.y1 - padding;
+      if (x1 < x0) x0 = x1 = (x0 + x1) / 2;
+      if (y1 < y0) y0 = y1 = (y0 + y1) / 2;
+      node.x0 = x0;
+      node.y0 = y0;
+      node.x1 = x1;
+      node.y1 = y1;
+    };
+  }
+
+  partition.round = function(x) {
+    return arguments.length ? (round = !!x, partition) : round;
+  };
+
+  partition.size = function(x) {
+    return arguments.length ? (dx = +x[0], dy = +x[1], partition) : [dx, dy];
+  };
+
+  partition.padding = function(x) {
+    return arguments.length ? (padding = +x, partition) : padding;
+  };
+
+  return partition;
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/stratify.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _accessors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/d3-hierarchy/src/accessors.js");
+/* harmony import */ var _hierarchy_index_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/index.js");
+
+
+
+var preroot = {depth: -1},
+    ambiguous = {};
+
+function defaultId(d) {
+  return d.id;
+}
+
+function defaultParentId(d) {
+  return d.parentId;
+}
+
+/* harmony default export */ __webpack_exports__["default"] = (function() {
+  var id = defaultId,
+      parentId = defaultParentId;
+
+  function stratify(data) {
+    var nodes = Array.from(data),
+        n = nodes.length,
+        d,
+        i,
+        root,
+        parent,
+        node,
+        nodeId,
+        nodeKey,
+        nodeByKey = new Map;
+
+    for (i = 0; i < n; ++i) {
+      d = nodes[i], node = nodes[i] = new _hierarchy_index_js__WEBPACK_IMPORTED_MODULE_1__["Node"](d);
+      if ((nodeId = id(d, i, data)) != null && (nodeId += "")) {
+        nodeKey = node.id = nodeId;
+        nodeByKey.set(nodeKey, nodeByKey.has(nodeKey) ? ambiguous : node);
+      }
+      if ((nodeId = parentId(d, i, data)) != null && (nodeId += "")) {
+        node.parent = nodeId;
+      }
+    }
+
+    for (i = 0; i < n; ++i) {
+      node = nodes[i];
+      if (nodeId = node.parent) {
+        parent = nodeByKey.get(nodeId);
+        if (!parent) throw new Error("missing: " + nodeId);
+        if (parent === ambiguous) throw new Error("ambiguous: " + nodeId);
+        if (parent.children) parent.children.push(node);
+        else parent.children = [node];
+        node.parent = parent;
+      } else {
+        if (root) throw new Error("multiple roots");
+        root = node;
+      }
+    }
+
+    if (!root) throw new Error("no root");
+    root.parent = preroot;
+    root.eachBefore(function(node) { node.depth = node.parent.depth + 1; --n; }).eachBefore(_hierarchy_index_js__WEBPACK_IMPORTED_MODULE_1__["computeHeight"]);
+    root.parent = null;
+    if (n > 0) throw new Error("cycle");
+
+    return root;
+  }
+
+  stratify.id = function(x) {
+    return arguments.length ? (id = Object(_accessors_js__WEBPACK_IMPORTED_MODULE_0__["required"])(x), stratify) : id;
+  };
+
+  stratify.parentId = function(x) {
+    return arguments.length ? (parentId = Object(_accessors_js__WEBPACK_IMPORTED_MODULE_0__["required"])(x), stratify) : parentId;
+  };
+
+  return stratify;
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/tree.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _hierarchy_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/d3-hierarchy/src/hierarchy/index.js");
+
+
+function defaultSeparation(a, b) {
+  return a.parent === b.parent ? 1 : 2;
+}
+
+// function radialSeparation(a, b) {
+//   return (a.parent === b.parent ? 1 : 2) / a.depth;
+// }
+
+// This function is used to traverse the left contour of a subtree (or
+// subforest). It returns the successor of v on this contour. This successor is
+// either given by the leftmost child of v or by the thread of v. The function
+// returns null if and only if v is on the highest level of its subtree.
+function nextLeft(v) {
+  var children = v.children;
+  return children ? children[0] : v.t;
+}
+
+// This function works analogously to nextLeft.
+function nextRight(v) {
+  var children = v.children;
+  return children ? children[children.length - 1] : v.t;
+}
+
+// Shifts the current subtree rooted at w+. This is done by increasing
+// prelim(w+) and mod(w+) by shift.
+function moveSubtree(wm, wp, shift) {
+  var change = shift / (wp.i - wm.i);
+  wp.c -= change;
+  wp.s += shift;
+  wm.c += change;
+  wp.z += shift;
+  wp.m += shift;
+}
+
+// All other shifts, applied to the smaller subtrees between w- and w+, are
+// performed by this function. To prepare the shifts, we have to adjust
+// change(w+), shift(w+), and change(w-).
+function executeShifts(v) {
+  var shift = 0,
+      change = 0,
+      children = v.children,
+      i = children.length,
+      w;
+  while (--i >= 0) {
+    w = children[i];
+    w.z += shift;
+    w.m += shift;
+    shift += w.s + (change += w.c);
+  }
+}
+
+// If vi-’s ancestor is a sibling of v, returns vi-’s ancestor. Otherwise,
+// returns the specified (default) ancestor.
+function nextAncestor(vim, v, ancestor) {
+  return vim.a.parent === v.parent ? vim.a : ancestor;
+}
+
+function TreeNode(node, i) {
+  this._ = node;
+  this.parent = null;
+  this.children = null;
+  this.A = null; // default ancestor
+  this.a = this; // ancestor
+  this.z = 0; // prelim
+  this.m = 0; // mod
+  this.c = 0; // change
+  this.s = 0; // shift
+  this.t = null; // thread
+  this.i = i; // number
+}
+
+TreeNode.prototype = Object.create(_hierarchy_index_js__WEBPACK_IMPORTED_MODULE_0__["Node"].prototype);
+
+function treeRoot(root) {
+  var tree = new TreeNode(root, 0),
+      node,
+      nodes = [tree],
+      child,
+      children,
+      i,
+      n;
+
+  while (node = nodes.pop()) {
+    if (children = node._.children) {
+      node.children = new Array(n = children.length);
+      for (i = n - 1; i >= 0; --i) {
+        nodes.push(child = node.children[i] = new TreeNode(children[i], i));
+        child.parent = node;
+      }
+    }
+  }
+
+  (tree.parent = new TreeNode(null, 0)).children = [tree];
+  return tree;
+}
+
+// Node-link tree diagram using the Reingold-Tilford "tidy" algorithm
+/* harmony default export */ __webpack_exports__["default"] = (function() {
+  var separation = defaultSeparation,
+      dx = 1,
+      dy = 1,
+      nodeSize = null;
+
+  function tree(root) {
+    var t = treeRoot(root);
+
+    // Compute the layout using Buchheim et al.’s algorithm.
+    t.eachAfter(firstWalk), t.parent.m = -t.z;
+    t.eachBefore(secondWalk);
+
+    // If a fixed node size is specified, scale x and y.
+    if (nodeSize) root.eachBefore(sizeNode);
+
+    // If a fixed tree size is specified, scale x and y based on the extent.
+    // Compute the left-most, right-most, and depth-most nodes for extents.
+    else {
+      var left = root,
+          right = root,
+          bottom = root;
+      root.eachBefore(function(node) {
+        if (node.x < left.x) left = node;
+        if (node.x > right.x) right = node;
+        if (node.depth > bottom.depth) bottom = node;
+      });
+      var s = left === right ? 1 : separation(left, right) / 2,
+          tx = s - left.x,
+          kx = dx / (right.x + s + tx),
+          ky = dy / (bottom.depth || 1);
+      root.eachBefore(function(node) {
+        node.x = (node.x + tx) * kx;
+        node.y = node.depth * ky;
+      });
+    }
+
+    return root;
+  }
+
+  // Computes a preliminary x-coordinate for v. Before that, FIRST WALK is
+  // applied recursively to the children of v, as well as the function
+  // APPORTION. After spacing out the children by calling EXECUTE SHIFTS, the
+  // node v is placed to the midpoint of its outermost children.
+  function firstWalk(v) {
+    var children = v.children,
+        siblings = v.parent.children,
+        w = v.i ? siblings[v.i - 1] : null;
+    if (children) {
+      executeShifts(v);
+      var midpoint = (children[0].z + children[children.length - 1].z) / 2;
+      if (w) {
+        v.z = w.z + separation(v._, w._);
+        v.m = v.z - midpoint;
+      } else {
+        v.z = midpoint;
+      }
+    } else if (w) {
+      v.z = w.z + separation(v._, w._);
+    }
+    v.parent.A = apportion(v, w, v.parent.A || siblings[0]);
+  }
+
+  // Computes all real x-coordinates by summing up the modifiers recursively.
+  function secondWalk(v) {
+    v._.x = v.z + v.parent.m;
+    v.m += v.parent.m;
+  }
+
+  // The core of the algorithm. Here, a new subtree is combined with the
+  // previous subtrees. Threads are used to traverse the inside and outside
+  // contours of the left and right subtree up to the highest common level. The
+  // vertices used for the traversals are vi+, vi-, vo-, and vo+, where the
+  // superscript o means outside and i means inside, the subscript - means left
+  // subtree and + means right subtree. For summing up the modifiers along the
+  // contour, we use respective variables si+, si-, so-, and so+. Whenever two
+  // nodes of the inside contours conflict, we compute the left one of the
+  // greatest uncommon ancestors using the function ANCESTOR and call MOVE
+  // SUBTREE to shift the subtree and prepare the shifts of smaller subtrees.
+  // Finally, we add a new thread (if necessary).
+  function apportion(v, w, ancestor) {
+    if (w) {
+      var vip = v,
+          vop = v,
+          vim = w,
+          vom = vip.parent.children[0],
+          sip = vip.m,
+          sop = vop.m,
+          sim = vim.m,
+          som = vom.m,
+          shift;
+      while (vim = nextRight(vim), vip = nextLeft(vip), vim && vip) {
+        vom = nextLeft(vom);
+        vop = nextRight(vop);
+        vop.a = v;
+        shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);
+        if (shift > 0) {
+          moveSubtree(nextAncestor(vim, v, ancestor), v, shift);
+          sip += shift;
+          sop += shift;
+        }
+        sim += vim.m;
+        sip += vip.m;
+        som += vom.m;
+        sop += vop.m;
+      }
+      if (vim && !nextRight(vop)) {
+        vop.t = vim;
+        vop.m += sim - sop;
+      }
+      if (vip && !nextLeft(vom)) {
+        vom.t = vip;
+        vom.m += sip - som;
+        ancestor = v;
+      }
+    }
+    return ancestor;
+  }
+
+  function sizeNode(node) {
+    node.x *= dx;
+    node.y = node.depth * dy;
+  }
+
+  tree.separation = function(x) {
+    return arguments.length ? (separation = x, tree) : separation;
+  };
+
+  tree.size = function(x) {
+    return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], tree) : (nodeSize ? null : [dx, dy]);
+  };
+
+  tree.nodeSize = function(x) {
+    return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], tree) : (nodeSize ? [dx, dy] : null);
+  };
+
+  return tree;
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/treemap/binary.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function(parent, x0, y0, x1, y1) {
+  var nodes = parent.children,
+      i, n = nodes.length,
+      sum, sums = new Array(n + 1);
+
+  for (sums[0] = sum = i = 0; i < n; ++i) {
+    sums[i + 1] = sum += nodes[i].value;
+  }
+
+  partition(0, n, parent.value, x0, y0, x1, y1);
+
+  function partition(i, j, value, x0, y0, x1, y1) {
+    if (i >= j - 1) {
+      var node = nodes[i];
+      node.x0 = x0, node.y0 = y0;
+      node.x1 = x1, node.y1 = y1;
+      return;
+    }
+
+    var valueOffset = sums[i],
+        valueTarget = (value / 2) + valueOffset,
+        k = i + 1,
+        hi = j - 1;
+
+    while (k < hi) {
+      var mid = k + hi >>> 1;
+      if (sums[mid] < valueTarget) k = mid + 1;
+      else hi = mid;
+    }
+
+    if ((valueTarget - sums[k - 1]) < (sums[k] - valueTarget) && i + 1 < k) --k;
+
+    var valueLeft = sums[k] - valueOffset,
+        valueRight = value - valueLeft;
+
+    if ((x1 - x0) > (y1 - y0)) {
+      var xk = value ? (x0 * valueRight + x1 * valueLeft) / value : x1;
+      partition(i, k, valueLeft, x0, y0, xk, y1);
+      partition(k, j, valueRight, xk, y0, x1, y1);
+    } else {
+      var yk = value ? (y0 * valueRight + y1 * valueLeft) / value : y1;
+      partition(i, k, valueLeft, x0, y0, x1, yk);
+      partition(k, j, valueRight, x0, yk, x1, y1);
+    }
+  }
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/treemap/dice.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function(parent, x0, y0, x1, y1) {
+  var nodes = parent.children,
+      node,
+      i = -1,
+      n = nodes.length,
+      k = parent.value && (x1 - x0) / parent.value;
+
+  while (++i < n) {
+    node = nodes[i], node.y0 = y0, node.y1 = y1;
+    node.x0 = x0, node.x1 = x0 += node.value * k;
+  }
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/treemap/index.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _round_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/round.js");
+/* harmony import */ var _squarify_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/squarify.js");
+/* harmony import */ var _accessors_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../../node_modules/d3-hierarchy/src/accessors.js");
+/* harmony import */ var _constant_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("../../node_modules/d3-hierarchy/src/constant.js");
+
+
+
+
+
+/* harmony default export */ __webpack_exports__["default"] = (function() {
+  var tile = _squarify_js__WEBPACK_IMPORTED_MODULE_1__["default"],
+      round = false,
+      dx = 1,
+      dy = 1,
+      paddingStack = [0],
+      paddingInner = _constant_js__WEBPACK_IMPORTED_MODULE_3__["constantZero"],
+      paddingTop = _constant_js__WEBPACK_IMPORTED_MODULE_3__["constantZero"],
+      paddingRight = _constant_js__WEBPACK_IMPORTED_MODULE_3__["constantZero"],
+      paddingBottom = _constant_js__WEBPACK_IMPORTED_MODULE_3__["constantZero"],
+      paddingLeft = _constant_js__WEBPACK_IMPORTED_MODULE_3__["constantZero"];
+
+  function treemap(root) {
+    root.x0 =
+    root.y0 = 0;
+    root.x1 = dx;
+    root.y1 = dy;
+    root.eachBefore(positionNode);
+    paddingStack = [0];
+    if (round) root.eachBefore(_round_js__WEBPACK_IMPORTED_MODULE_0__["default"]);
+    return root;
+  }
+
+  function positionNode(node) {
+    var p = paddingStack[node.depth],
+        x0 = node.x0 + p,
+        y0 = node.y0 + p,
+        x1 = node.x1 - p,
+        y1 = node.y1 - p;
+    if (x1 < x0) x0 = x1 = (x0 + x1) / 2;
+    if (y1 < y0) y0 = y1 = (y0 + y1) / 2;
+    node.x0 = x0;
+    node.y0 = y0;
+    node.x1 = x1;
+    node.y1 = y1;
+    if (node.children) {
+      p = paddingStack[node.depth + 1] = paddingInner(node) / 2;
+      x0 += paddingLeft(node) - p;
+      y0 += paddingTop(node) - p;
+      x1 -= paddingRight(node) - p;
+      y1 -= paddingBottom(node) - p;
+      if (x1 < x0) x0 = x1 = (x0 + x1) / 2;
+      if (y1 < y0) y0 = y1 = (y0 + y1) / 2;
+      tile(node, x0, y0, x1, y1);
+    }
+  }
+
+  treemap.round = function(x) {
+    return arguments.length ? (round = !!x, treemap) : round;
+  };
+
+  treemap.size = function(x) {
+    return arguments.length ? (dx = +x[0], dy = +x[1], treemap) : [dx, dy];
+  };
+
+  treemap.tile = function(x) {
+    return arguments.length ? (tile = Object(_accessors_js__WEBPACK_IMPORTED_MODULE_2__["required"])(x), treemap) : tile;
+  };
+
+  treemap.padding = function(x) {
+    return arguments.length ? treemap.paddingInner(x).paddingOuter(x) : treemap.paddingInner();
+  };
+
+  treemap.paddingInner = function(x) {
+    return arguments.length ? (paddingInner = typeof x === "function" ? x : Object(_constant_js__WEBPACK_IMPORTED_MODULE_3__["default"])(+x), treemap) : paddingInner;
+  };
+
+  treemap.paddingOuter = function(x) {
+    return arguments.length ? treemap.paddingTop(x).paddingRight(x).paddingBottom(x).paddingLeft(x) : treemap.paddingTop();
+  };
+
+  treemap.paddingTop = function(x) {
+    return arguments.length ? (paddingTop = typeof x === "function" ? x : Object(_constant_js__WEBPACK_IMPORTED_MODULE_3__["default"])(+x), treemap) : paddingTop;
+  };
+
+  treemap.paddingRight = function(x) {
+    return arguments.length ? (paddingRight = typeof x === "function" ? x : Object(_constant_js__WEBPACK_IMPORTED_MODULE_3__["default"])(+x), treemap) : paddingRight;
+  };
+
+  treemap.paddingBottom = function(x) {
+    return arguments.length ? (paddingBottom = typeof x === "function" ? x : Object(_constant_js__WEBPACK_IMPORTED_MODULE_3__["default"])(+x), treemap) : paddingBottom;
+  };
+
+  treemap.paddingLeft = function(x) {
+    return arguments.length ? (paddingLeft = typeof x === "function" ? x : Object(_constant_js__WEBPACK_IMPORTED_MODULE_3__["default"])(+x), treemap) : paddingLeft;
+  };
+
+  return treemap;
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/treemap/resquarify.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _dice_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/dice.js");
+/* harmony import */ var _slice_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/slice.js");
+/* harmony import */ var _squarify_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/squarify.js");
+
+
+
+
+/* harmony default export */ __webpack_exports__["default"] = ((function custom(ratio) {
+
+  function resquarify(parent, x0, y0, x1, y1) {
+    if ((rows = parent._squarify) && (rows.ratio === ratio)) {
+      var rows,
+          row,
+          nodes,
+          i,
+          j = -1,
+          n,
+          m = rows.length,
+          value = parent.value;
+
+      while (++j < m) {
+        row = rows[j], nodes = row.children;
+        for (i = row.value = 0, n = nodes.length; i < n; ++i) row.value += nodes[i].value;
+        if (row.dice) Object(_dice_js__WEBPACK_IMPORTED_MODULE_0__["default"])(row, x0, y0, x1, value ? y0 += (y1 - y0) * row.value / value : y1);
+        else Object(_slice_js__WEBPACK_IMPORTED_MODULE_1__["default"])(row, x0, y0, value ? x0 += (x1 - x0) * row.value / value : x1, y1);
+        value -= row.value;
+      }
+    } else {
+      parent._squarify = rows = Object(_squarify_js__WEBPACK_IMPORTED_MODULE_2__["squarifyRatio"])(ratio, parent, x0, y0, x1, y1);
+      rows.ratio = ratio;
+    }
+  }
+
+  resquarify.ratio = function(x) {
+    return custom((x = +x) > 1 ? x : 1);
+  };
+
+  return resquarify;
+})(_squarify_js__WEBPACK_IMPORTED_MODULE_2__["phi"]));
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/treemap/round.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function(node) {
+  node.x0 = Math.round(node.x0);
+  node.y0 = Math.round(node.y0);
+  node.x1 = Math.round(node.x1);
+  node.y1 = Math.round(node.y1);
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/treemap/slice.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = (function(parent, x0, y0, x1, y1) {
+  var nodes = parent.children,
+      node,
+      i = -1,
+      n = nodes.length,
+      k = parent.value && (y1 - y0) / parent.value;
+
+  while (++i < n) {
+    node = nodes[i], node.x0 = x0, node.x1 = x1;
+    node.y0 = y0, node.y1 = y0 += node.value * k;
+  }
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/treemap/sliceDice.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _dice_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/dice.js");
+/* harmony import */ var _slice_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/slice.js");
+
+
+
+/* harmony default export */ __webpack_exports__["default"] = (function(parent, x0, y0, x1, y1) {
+  (parent.depth & 1 ? _slice_js__WEBPACK_IMPORTED_MODULE_1__["default"] : _dice_js__WEBPACK_IMPORTED_MODULE_0__["default"])(parent, x0, y0, x1, y1);
+});
+
+
+/***/ }),
+
+/***/ "../../node_modules/d3-hierarchy/src/treemap/squarify.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "phi", function() { return phi; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "squarifyRatio", function() { return squarifyRatio; });
+/* harmony import */ var _dice_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/dice.js");
+/* harmony import */ var _slice_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/d3-hierarchy/src/treemap/slice.js");
+
+
+
+var phi = (1 + Math.sqrt(5)) / 2;
+
+function squarifyRatio(ratio, parent, x0, y0, x1, y1) {
+  var rows = [],
+      nodes = parent.children,
+      row,
+      nodeValue,
+      i0 = 0,
+      i1 = 0,
+      n = nodes.length,
+      dx, dy,
+      value = parent.value,
+      sumValue,
+      minValue,
+      maxValue,
+      newRatio,
+      minRatio,
+      alpha,
+      beta;
+
+  while (i0 < n) {
+    dx = x1 - x0, dy = y1 - y0;
+
+    // Find the next non-empty node.
+    do sumValue = nodes[i1++].value; while (!sumValue && i1 < n);
+    minValue = maxValue = sumValue;
+    alpha = Math.max(dy / dx, dx / dy) / (value * ratio);
+    beta = sumValue * sumValue * alpha;
+    minRatio = Math.max(maxValue / beta, beta / minValue);
+
+    // Keep adding nodes while the aspect ratio maintains or improves.
+    for (; i1 < n; ++i1) {
+      sumValue += nodeValue = nodes[i1].value;
+      if (nodeValue < minValue) minValue = nodeValue;
+      if (nodeValue > maxValue) maxValue = nodeValue;
+      beta = sumValue * sumValue * alpha;
+      newRatio = Math.max(maxValue / beta, beta / minValue);
+      if (newRatio > minRatio) { sumValue -= nodeValue; break; }
+      minRatio = newRatio;
+    }
+
+    // Position and record the row orientation.
+    rows.push(row = {value: sumValue, dice: dx < dy, children: nodes.slice(i0, i1)});
+    if (row.dice) Object(_dice_js__WEBPACK_IMPORTED_MODULE_0__["default"])(row, x0, y0, x1, value ? y0 += dy * sumValue / value : y1);
+    else Object(_slice_js__WEBPACK_IMPORTED_MODULE_1__["default"])(row, x0, y0, value ? x0 += dx * sumValue / value : x1, y1);
+    value -= sumValue, i0 = i1;
+  }
+
+  return rows;
+}
+
+/* harmony default export */ __webpack_exports__["default"] = ((function custom(ratio) {
+
+  function squarify(parent, x0, y0, x1, y1) {
+    squarifyRatio(ratio, parent, x0, y0, x1, y1);
+  }
+
+  squarify.ratio = function(x) {
+    return custom((x = +x) > 1 ? x : 1);
+  };
+
+  return squarify;
+})(phi));
+
+
 /***/ }),
 
 /***/ "../../node_modules/d3-interpolate/src/array.js":
@@ -12577,6 +14291,23 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+/***/ }),
+
+/***/ "../../packages/charting/lib/TreeChart.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _components_TreeChart_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../packages/charting/lib/components/TreeChart/index.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TreeChart", function() { return _components_TreeChart_index__WEBPACK_IMPORTED_MODULE_0__["TreeChart"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "NodesComposition", function() { return _components_TreeChart_index__WEBPACK_IMPORTED_MODULE_0__["NodesComposition"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TreeTraverse", function() { return _components_TreeChart_index__WEBPACK_IMPORTED_MODULE_0__["TreeTraverse"]; });
+
+
+
+
 /***/ }),
 
 /***/ "../../packages/charting/lib/Utilities.js":
@@ -18384,6 +20115,438 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+/***/ }),
+
+/***/ "../../packages/charting/lib/components/TreeChart/TreeChart.base.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TreeChartBase", function() { return TreeChartBase; });
+/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/tslib/tslib.es6.js");
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("react");
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var d3_hierarchy__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../../node_modules/d3-hierarchy/src/index.js");
+/* harmony import */ var office_ui_fabric_react_lib_Utilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("../../packages/office-ui-fabric-react/lib/Utilities.js");
+/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("../../node_modules/d3-selection/index.js");
+/* harmony import */ var _fluentui_react_focus__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("../../packages/react-focus/lib/index.js");
+/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("../../node_modules/d3-array/index.js");
+
+
+
+
+
+
+
+var getClassNames = Object(office_ui_fabric_react_lib_Utilities__WEBPACK_IMPORTED_MODULE_3__["classNamesFunction"])();
+// Create a parent class for common tree components
+var StandardTree = /** @class */ (function () {
+    function StandardTree(treeData, styleClassNames, _nodeElements, _linkElements) {
+        if (_nodeElements === void 0) { _nodeElements = []; }
+        if (_linkElements === void 0) { _linkElements = []; }
+        this._nodeElements = [];
+        this._linkElements = [];
+        this.treeData = treeData;
+        this.styleClassNames = styleClassNames;
+        this._nodeElements = _nodeElements;
+        this._linkElements = _linkElements;
+    }
+    StandardTree.prototype.truncateText = function (text, rectangleWidth, padding, styleClass) {
+        var truncatedText = '';
+        var words = text.split(/\s+/).reverse();
+        var word = '';
+        var tspan = Object(d3_selection__WEBPACK_IMPORTED_MODULE_4__["select"])('.svgTree')
+            .append('text')
+            .attr('class', 'tempText')
+            .append('tspan')
+            .text(null);
+        if (styleClass) {
+            tspan.attr('class', styleClass);
+        }
+        var line = [];
+        while ((word = words.pop())) {
+            line.push(word);
+            tspan.text(line.join(' ') + ' ');
+            if (tspan.node() !== null) {
+                var w = tspan.node().getComputedTextLength();
+                if (w > rectangleWidth - padding) {
+                    line.pop();
+                    line.push('...');
+                    break;
+                }
+            }
+        }
+        truncatedText = line.join(' ') + ' ';
+        tspan.text(null);
+        Object(d3_selection__WEBPACK_IMPORTED_MODULE_4__["selectAll"])('.tempText').remove();
+        return truncatedText;
+    };
+    // Append node elements
+    // nodeId to create unique key
+    StandardTree.prototype.addNodeShapetoSVG = function (name, subname, bodytext, metricName, xCenterCoordinate, yCoordinate, fillColor, rectangleWidth, rectangleHeight, nodeId, parentInfo) {
+        var ariaLabel = "nodeId: " + nodeId + " \nnodeMainText: " + name + "\nsubText " + subname + " " + parentInfo;
+        var xCoordinate = xCenterCoordinate - rectangleWidth / 2;
+        if (metricName || nodeId !== 0 || !bodytext) {
+            this._nodeElements.push(react__WEBPACK_IMPORTED_MODULE_1__["createElement"]("rect", { width: rectangleWidth, height: rectangleHeight, x: xCoordinate, y: yCoordinate, tabIndex: 0, role: 'text', "data-is-focusable": true, "aria-label": ariaLabel, className: this.styleClassNames.rectNode, stroke: fillColor, key: "" + nodeId + this.styleClassNames.rectNode }));
+        }
+        if (subname) {
+            subname = this.truncateText(subname, rectangleWidth, rectangleWidth / 4, this.styleClassNames.rectSubText);
+        }
+        if (bodytext) {
+            bodytext = this.truncateText(bodytext, rectangleWidth, rectangleWidth / 4, this.styleClassNames.rectBodyText);
+        }
+        if (metricName) {
+            metricName = this.truncateText(metricName, rectangleWidth, rectangleWidth / 4, this.styleClassNames.rectMetricText);
+        }
+        name = this.truncateText(name, rectangleWidth, rectangleWidth / 4, this.styleClassNames.rectText);
+        // Text position y = y + rectHeight/2, 2 is ratio for depth
+        // Text position x = x + rectWidth/2, 2 is ratio for length
+        // Sub-text position x = x + rectWidth/2, 2 is ratio for length
+        var subValue = metricName ? (react__WEBPACK_IMPORTED_MODULE_1__["createElement"]("tspan", { className: this.styleClassNames.rectMetricText, dy: "1.4em", x: xCoordinate + rectangleWidth / 2 }, metricName)) : bodytext ? (react__WEBPACK_IMPORTED_MODULE_1__["createElement"](react__WEBPACK_IMPORTED_MODULE_1__["Fragment"], null,
+            react__WEBPACK_IMPORTED_MODULE_1__["createElement"]("tspan", { className: this.styleClassNames.rectSubText, dy: "1.4em", x: xCoordinate + rectangleWidth / 2 }, subname),
+            react__WEBPACK_IMPORTED_MODULE_1__["createElement"]("tspan", { className: this.styleClassNames.rectBodyText, dy: "1.4em", x: xCoordinate + rectangleWidth / 2 }, bodytext))) : (react__WEBPACK_IMPORTED_MODULE_1__["createElement"]("tspan", { className: this.styleClassNames.rectSubText, dy: "1.4em", x: xCoordinate + rectangleWidth / 2 }, subname));
+        if (!subname && !metricName && !bodytext) {
+            this._nodeElements.push(react__WEBPACK_IMPORTED_MODULE_1__["createElement"]("text", { textAnchor: "middle", className: this.styleClassNames.rectMetricText, dy: yCoordinate + rectangleHeight / 1.6, x: xCoordinate + rectangleWidth / 2, key: "" + nodeId + this.styleClassNames.rectText }, name));
+        }
+        else {
+            this._nodeElements.push(react__WEBPACK_IMPORTED_MODULE_1__["createElement"]("text", { textAnchor: "middle", className: metricName ? this.styleClassNames.rectSubText : this.styleClassNames.rectText, dy: metricName ? yCoordinate + rectangleHeight / 2.5 : yCoordinate + rectangleHeight / 2, x: xCoordinate + rectangleWidth / 2, key: "" + nodeId + this.styleClassNames.rectText },
+                name,
+                subValue));
+        }
+    };
+    // Create a rectangular path from parent to the child nodes
+    StandardTree.prototype.createPathLink = function (parentX, parentY, childX, childY, leaf, rectWidth, rectHeight, gap, childXMax) {
+        // gap adds ratio for parent.y to child.y
+        var path = "M" + (childX - rectWidth / 2) + "," + (childY - gap) + " H" + (childXMax + rectWidth / 2) + " M" + parentX + "," + (childY - gap) + "\n    V" + (parentY + rectHeight + gap / 2);
+        var leafpath = "M" + parentX + "," + (parentY + rectHeight + gap / 2) + " V" + (parentY + gap * 5) + "\n    H" + (parentX - rectWidth / 2) + " H" + (parentX + rectWidth / 2);
+        // based on the type of node return leafpath or path element
+        return leaf ? leafpath : path;
+    };
+    // Append path link element
+    StandardTree.prototype.addLinktoSVG = function (nodeId, parentX, parentY, childX, childY, leaf, rectWidth, rectHeight, gap, childXMax) {
+        if (childXMax === void 0) { childXMax = 0; }
+        this._linkElements.push(react__WEBPACK_IMPORTED_MODULE_1__["createElement"]("path", { className: this.styleClassNames.link, d: this.createPathLink(parentX, parentY, childX, childY, leaf, rectWidth, rectHeight, gap, childXMax), key: "" + nodeId + this.styleClassNames.link }));
+    };
+    return StandardTree;
+}());
+// Create child class to Add Tree component based on treeHeight
+var LayeredTree = /** @class */ (function (_super) {
+    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__extends"])(LayeredTree, _super);
+    function LayeredTree(treeData, composition, styleClassNames, _nodeElements, _linkElements, _treeTraversal) {
+        if (_nodeElements === void 0) { _nodeElements = []; }
+        if (_linkElements === void 0) { _linkElements = []; }
+        var _this = _super.call(this, treeData, styleClassNames, _nodeElements, _linkElements) || this;
+        _this.composition = composition;
+        _this._treeTraversal = _treeTraversal;
+        return _this;
+    }
+    LayeredTree.prototype.createTree = function (givenLayoutWidth, screenWidth) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        givenLayoutWidth = givenLayoutWidth < 65 ? 65 : givenLayoutWidth > 90 ? 90 : givenLayoutWidth;
+        var layoutWidth = givenLayoutWidth || 75;
+        var root = Object(d3_hierarchy__WEBPACK_IMPORTED_MODULE_2__["hierarchy"])(this.treeData, function (d) {
+            return d.children;
+        });
+        // Find tree Height
+        var treeHeight = ((_a = root) === null || _a === void 0 ? void 0 : _a.height) + 1;
+        // Create tree layout, width: layoutWidth, height: layoutWidth/1.5 and add node separation
+        var treeChart = Object(d3_hierarchy__WEBPACK_IMPORTED_MODULE_2__["tree"])()
+            .nodeSize([layoutWidth, layoutWidth / 1.5])
+            .separation(function (a, b) {
+            return a.parent === root && b.parent === root ? 3.5 : 1;
+        });
+        // Assigns the x and y position for the nodes
+        var treeData = treeChart(root);
+        // Compute the new tree layout.
+        var nodes = treeData.descendants();
+        // Normalize for fixed-depth and width
+        // Normalise y coordinate by depth of each node by a factor of 130
+        // Normalise x coordinate by start coordinate 0 with screenSize/3
+        nodes.forEach(function (d) {
+            d.y = d.depth === 0 ? 10 : d.depth * 130;
+            d.x += screenWidth / 2;
+        });
+        // <------------------ Traversal section ------------------>
+        // Create tree data structure
+        var treeDataStructure = [];
+        var TreeID = 0;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        var createTreeDataStructure = function (d) {
+            var _a, _b;
+            d.id = TreeID;
+            treeDataStructure.push({
+                id: TreeID,
+                children: d.children,
+                dataName: d.data.name,
+                subName: d.data.subname,
+                bodyText: d.data.bodytext,
+                metricName: (_a = d.data) === null || _a === void 0 ? void 0 : _a.metric,
+                fill: d.data.fill,
+                x: d.x,
+                y: d.y,
+                parentID: (_b = d.parent) === null || _b === void 0 ? void 0 : _b.id,
+            });
+            TreeID++;
+        };
+        this._treeTraversal === 0
+            ? root.each(function (d) {
+                createTreeDataStructure(d);
+            })
+            : root.eachBefore(function (d) {
+                createTreeDataStructure(d);
+            });
+        var rectWidth = layoutWidth * 3;
+        var rectHeight = rectWidth / 3.45;
+        var gap = 20;
+        var parentSet = new Set();
+        for (var _i = 0, treeDataStructure_1 = treeDataStructure; _i < treeDataStructure_1.length; _i++) {
+            var d = treeDataStructure_1[_i];
+            var parentInfo = d.id === 0
+                ? 'Root Node'
+                : "Parent info parentId: " + d.parentID + "\n      " + treeDataStructure[d.parentID].dataName + "\n      " + treeDataStructure[d.parentID].subName;
+            // check for leaf nodes
+            if (!d.children && !parentSet.has(d.parentID) && treeHeight === 3) {
+                var compactNodeWidth = (rectWidth - gap) / 2;
+                var compactNodeHeight = rectHeight;
+                parentSet.add(d.parentID);
+                // <------------------ Links section ------------------>
+                this.addLinktoSVG(d.id, treeDataStructure[d.parentID].x, treeDataStructure[d.parentID].y, treeDataStructure[d.id].x, treeDataStructure[d.id].y, true, rectWidth, rectHeight, gap);
+                // <------------------ Nodes section ------------------>
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                var children = (_b = treeDataStructure[d.parentID]) === null || _b === void 0 ? void 0 : _b.children;
+                var compactNodeCenterX1 = ((_c = treeDataStructure[d.parentID]) === null || _c === void 0 ? void 0 : _c.x) - compactNodeWidth / 2 - gap / 2;
+                var compactNodeCenterX2 = ((_d = treeDataStructure[d.parentID]) === null || _d === void 0 ? void 0 : _d.x) + compactNodeWidth / 2 + gap / 2;
+                var longNodeCenterX = (_e = treeDataStructure[d.parentID]) === null || _e === void 0 ? void 0 : _e.x;
+                var dy = (_f = children[0]) === null || _f === void 0 ? void 0 : _f.y;
+                for (var itr = 0; itr < children.length; ++itr) {
+                    var child = children[itr];
+                    // Given Composition
+                    if (this.composition !== undefined) {
+                        // For compact compostion
+                        if (this.composition === 0) {
+                            this.addNodeShapetoSVG(child.data.name, child.data.subname, child.data.bodytext, child.data.metricName, 
+                            // If the leaf node count is 1 ,
+                            //irrespective of provided composition we should always use long composition
+                            itr % 2 === 0 ? (children.length === 1 ? longNodeCenterX : compactNodeCenterX1) : compactNodeCenterX2, dy, child.data.fill, children.length === 1 ? rectWidth : compactNodeWidth, rectHeight, child.id, parentInfo);
+                            if (itr % 2 === 1) {
+                                dy += compactNodeHeight + gap;
+                            }
+                        }
+                        // For long compostion
+                        else {
+                            this.addNodeShapetoSVG(child.data.name, child.data.subname, child.data.bodytext, child.data.metricName, longNodeCenterX, dy, child.data.fill, rectWidth, rectHeight, child.id, parentInfo);
+                            dy += compactNodeHeight + gap;
+                        }
+                    }
+                    // Automatic Node Composition
+                    else {
+                        if (children.length > 2) {
+                            this.addNodeShapetoSVG(child.data.name, child.data.subname, child.data.bodytext, child.data.metricName, itr % 2 === 0 ? compactNodeCenterX1 : compactNodeCenterX2, dy, child.data.fill, children.length === 1 ? rectWidth : compactNodeWidth, rectHeight, child.id, parentInfo);
+                            if (itr % 2 === 1) {
+                                dy += compactNodeHeight + gap;
+                            }
+                        }
+                        else {
+                            this.addNodeShapetoSVG(child.data.name, child.data.subname, child.data.bodytext, child.data.metricName, longNodeCenterX, dy, child.data.fill, rectWidth, rectHeight, child.id, parentInfo);
+                            dy += compactNodeHeight + gap;
+                        }
+                    }
+                }
+            }
+            if (d.children || treeHeight <= 2) {
+                // <------------------ Nodes section ------------------>
+                // Since the height <=2 we will be using long compositon.
+                this.addNodeShapetoSVG(d.dataName, d.subName, d.bodyText, d.metricName, d.x, d.y, d.fill, rectWidth, rectHeight, d.id, parentInfo);
+                // <------------------ Links section ------------------>
+                if (d.id === 0 && d.children) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    var children = (_g = treeDataStructure[d.id]) === null || _g === void 0 ? void 0 : _g.children;
+                    var childXMin = Object(d3_array__WEBPACK_IMPORTED_MODULE_6__["min"])(children, function (child) { return child.x; });
+                    var childXMax = Object(d3_array__WEBPACK_IMPORTED_MODULE_6__["max"])(children, function (child) { return child.x; });
+                    this.addLinktoSVG(d.id, d.x, d.y, childXMin, d.children[0].y, false, rectWidth, rectHeight, gap, childXMax);
+                }
+            }
+        }
+    };
+    return LayeredTree;
+}(StandardTree));
+var TreeChartBase = /** @class */ (function (_super) {
+    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__extends"])(TreeChartBase, _super);
+    function TreeChartBase(props) {
+        var _a;
+        var _this = _super.call(this, props) || this;
+        _this._nodeElements = [];
+        _this._linkElements = [];
+        _this._margin = { top: 30, right: 20, bottom: 30, left: 50 };
+        _this._width = _this.props.width || 1500;
+        _this._height = _this.props.height || 700;
+        _this._treeData = _this.props.treeData;
+        _this._composition = (_a = _this.props) === null || _a === void 0 ? void 0 : _a.composition;
+        _this._treeTraversal = _this.props.treeTraversal;
+        _this.state = {
+            _width: _this._width,
+            _height: _this._height,
+        };
+        return _this;
+    }
+    TreeChartBase.prototype.componentDidMount = function () {
+        var _a = this.props, theme = _a.theme, className = _a.className, styles = _a.styles;
+        // Get classNames to create component styling
+        this._classNames = getClassNames(styles, {
+            theme: theme,
+            className: className,
+        });
+        // Call createTreeChart function in componentDidMount
+        this.createTreeChart();
+        this.setState({
+            _width: this.props.width || 1500,
+            _height: this.props.height || 700,
+        });
+    };
+    TreeChartBase.prototype.componentDidUpdate = function (prevProps) {
+        if (prevProps.layoutWidth !== this.props.layoutWidth) {
+            var svgText = Object(d3_selection__WEBPACK_IMPORTED_MODULE_4__["selectAll"])('text');
+            var svgRect = Object(d3_selection__WEBPACK_IMPORTED_MODULE_4__["selectAll"])('rect');
+            var svgLink = Object(d3_selection__WEBPACK_IMPORTED_MODULE_4__["selectAll"])('path');
+            if (this._nodeElements.length === 0 && this._linkElements.length === 0) {
+                svgText.remove();
+                svgRect.remove();
+                svgLink.remove();
+            }
+            this.createTreeChart();
+        }
+    };
+    TreeChartBase.prototype.createTreeChart = function () {
+        var nodeElements = [];
+        var linkElements = [];
+        // Instantiate inherited class and call createTree function for the object
+        var treeObject = new LayeredTree(this._treeData, this._composition, this._classNames, nodeElements, linkElements, this._treeTraversal);
+        var width = this.state._width - this._margin.left - this._margin.right;
+        treeObject.createTree(this.props.layoutWidth, width);
+        this._nodeElements = nodeElements;
+        this._linkElements = linkElements;
+    };
+    TreeChartBase.prototype.render = function () {
+        var _a;
+        return (react__WEBPACK_IMPORTED_MODULE_1__["createElement"](_fluentui_react_focus__WEBPACK_IMPORTED_MODULE_5__["FocusZone"], null,
+            react__WEBPACK_IMPORTED_MODULE_1__["createElement"]("div", { className: (_a = this._classNames) === null || _a === void 0 ? void 0 : _a.root },
+                react__WEBPACK_IMPORTED_MODULE_1__["createElement"]("svg", { className: "svgTree", width: this.state._width - this._margin.left - this._margin.right, height: this.state._height - this._margin.top - this._margin.bottom },
+                    react__WEBPACK_IMPORTED_MODULE_1__["createElement"]("g", { className: "svgNode" }, this._nodeElements.map(function (element) { return element; })),
+                    react__WEBPACK_IMPORTED_MODULE_1__["createElement"]("g", { className: "svgLink" }, this._linkElements.map(function (element) { return element; }))))));
+    };
+    return TreeChartBase;
+}(react__WEBPACK_IMPORTED_MODULE_1__["Component"]));
+
+
+
+/***/ }),
+
+/***/ "../../packages/charting/lib/components/TreeChart/TreeChart.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TreeChart", function() { return TreeChart; });
+/* harmony import */ var office_ui_fabric_react_lib_Utilities__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../packages/office-ui-fabric-react/lib/Utilities.js");
+/* harmony import */ var _TreeChart_base__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../packages/charting/lib/components/TreeChart/TreeChart.base.js");
+/* harmony import */ var _TreeChart_styles__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../../packages/charting/lib/components/TreeChart/TreeChart.styles.js");
+
+
+
+var TreeChart = Object(office_ui_fabric_react_lib_Utilities__WEBPACK_IMPORTED_MODULE_0__["styled"])(_TreeChart_base__WEBPACK_IMPORTED_MODULE_1__["TreeChartBase"], _TreeChart_styles__WEBPACK_IMPORTED_MODULE_2__["getStyles"]);
+
+
+/***/ }),
+
+/***/ "../../packages/charting/lib/components/TreeChart/TreeChart.styles.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getStyles", function() { return getStyles; });
+/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/tslib/tslib.es6.js");
+
+var getStyles = function (props) {
+    return {
+        root: [
+            props.theme.spacing,
+            'ms-TreeChart',
+            props.className,
+            {
+                overflow: 'scroll',
+            },
+        ],
+        link: {
+            fill: 'none',
+            stroke: '#A1A1A1',
+            strokeWidth: '2px',
+        },
+        rectNode: {
+            strokeWidth: '2px',
+            fill: 'white',
+            padding: '10px',
+            rx: '2px',
+        },
+        rectText: Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__assign"])({ fill: 'black' }, props.theme.fonts.large),
+        rectSubText: Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__assign"])({ fill: '#484644' }, props.theme.fonts.medium),
+        rectBodyText: Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__assign"])({ fill: '#808080' }, props.theme.fonts.xSmall),
+        rectMetricText: Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__assign"])({ fill: '#000000' }, props.theme.fonts.xLarge),
+    };
+};
+
+
+/***/ }),
+
+/***/ "../../packages/charting/lib/components/TreeChart/TreeChart.types.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "NodesComposition", function() { return NodesComposition; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TreeTraverse", function() { return TreeTraverse; });
+var NodesComposition;
+(function (NodesComposition) {
+    /**
+     * NodeComposition enum val for long: number = 1
+     */
+    NodesComposition[NodesComposition["long"] = 1] = "long";
+    /**
+     * NodeComposition enum val for compact: number = 0
+     */
+    NodesComposition[NodesComposition["compact"] = 0] = "compact";
+})(NodesComposition || (NodesComposition = {}));
+var TreeTraverse;
+(function (TreeTraverse) {
+    /**
+     * TreeTraverse enum val for preOrder: number = 1
+     */
+    TreeTraverse[TreeTraverse["preOrder"] = 1] = "preOrder";
+    /**
+     * TreeTraverse enum val for levelOrder: number = 0
+     */
+    TreeTraverse[TreeTraverse["levelOrder"] = 0] = "levelOrder";
+})(TreeTraverse || (TreeTraverse = {}));
+
+
+/***/ }),
+
+/***/ "../../packages/charting/lib/components/TreeChart/index.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _TreeChart__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../packages/charting/lib/components/TreeChart/TreeChart.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TreeChart", function() { return _TreeChart__WEBPACK_IMPORTED_MODULE_0__["TreeChart"]; });
+
+/* harmony import */ var _TreeChart_types__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../packages/charting/lib/components/TreeChart/TreeChart.types.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "NodesComposition", function() { return _TreeChart_types__WEBPACK_IMPORTED_MODULE_1__["NodesComposition"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TreeTraverse", function() { return _TreeChart_types__WEBPACK_IMPORTED_MODULE_1__["TreeTraverse"]; });
+
+
+
+
+
 /***/ }),
 
 /***/ "../../packages/charting/lib/components/VerticalBarChart/VerticalBarChart.base.js":
@@ -19666,7 +21829,15 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _HeatMapChart__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__("../../packages/charting/lib/HeatMapChart.js");
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HeatMapChart", function() { return _HeatMapChart__WEBPACK_IMPORTED_MODULE_12__["HeatMapChart"]; });
 
-/* harmony import */ var _version__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__("../../packages/charting/lib/version.js");
+/* harmony import */ var _TreeChart__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__("../../packages/charting/lib/TreeChart.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TreeChart", function() { return _TreeChart__WEBPACK_IMPORTED_MODULE_13__["TreeChart"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "NodesComposition", function() { return _TreeChart__WEBPACK_IMPORTED_MODULE_13__["NodesComposition"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TreeTraverse", function() { return _TreeChart__WEBPACK_IMPORTED_MODULE_13__["TreeTraverse"]; });
+
+/* harmony import */ var _version__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__("../../packages/charting/lib/version.js");
+
 
 
 
@@ -20773,7 +22944,7 @@ __webpack_require__.r(__webpack_exports__);
 // Do not modify this file; it is generated as part of publish.
 // The checked in version is a placeholder only and will not be updated.
 
-Object(_uifabric_set_version__WEBPACK_IMPORTED_MODULE_0__["setVersion"])('@uifabric/charting', '4.23.6');
+Object(_uifabric_set_version__WEBPACK_IMPORTED_MODULE_0__["setVersion"])('@uifabric/charting', '4.23.8');
 
 
 /***/ }),
@@ -22088,7 +24259,7 @@ __webpack_require__.r(__webpack_exports__);
 // Do not modify this file; it is generated as part of publish.
 // The checked in version is a placeholder only and will not be updated.
 
-Object(_uifabric_set_version__WEBPACK_IMPORTED_MODULE_0__["setVersion"])('@uifabric/foundation', '7.10.11');
+Object(_uifabric_set_version__WEBPACK_IMPORTED_MODULE_0__["setVersion"])('@uifabric/foundation', '7.10.12');
 
 
 /***/ }),
@@ -24615,7 +26786,7 @@ __webpack_require__.r(__webpack_exports__);
 // Do not modify this file; it is generated as part of publish.
 // The checked in version is a placeholder only and will not be updated.
 
-Object(_uifabric_set_version__WEBPACK_IMPORTED_MODULE_0__["setVersion"])('@uifabric/icons', '7.8.6');
+Object(_uifabric_set_version__WEBPACK_IMPORTED_MODULE_0__["setVersion"])('@uifabric/icons', '7.9.1');
 
 
 /***/ }),
@@ -27711,6 +29882,8 @@ __webpack_require__.r(__webpack_exports__);
 
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "createTheme", function() { return _uifabric_styling__WEBPACK_IMPORTED_MODULE_1__["createTheme"]; });
 
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "initializeThemeInCustomizations", function() { return _uifabric_styling__WEBPACK_IMPORTED_MODULE_1__["initializeThemeInCustomizations"]; });
+
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "registerOnThemeChangeCallback", function() { return _uifabric_styling__WEBPACK_IMPORTED_MODULE_1__["registerOnThemeChangeCallback"]; });
 
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "removeOnThemeChangeCallback", function() { return _uifabric_styling__WEBPACK_IMPORTED_MODULE_1__["removeOnThemeChangeCallback"]; });
@@ -28279,6 +30452,19 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+/***/ }),
+
+/***/ "../../packages/office-ui-fabric-react/lib/Viewport.js":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _utilities_decorators_withViewport__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../packages/office-ui-fabric-react/lib/utilities/decorators/withViewport.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "withViewport", function() { return _utilities_decorators_withViewport__WEBPACK_IMPORTED_MODULE_0__["withViewport"]; });
+
+
+
+
 /***/ }),
 
 /***/ "../../packages/office-ui-fabric-react/lib/WindowProvider.js":
@@ -78846,6 +81032,8 @@ __webpack_require__.r(__webpack_exports__);
 
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "createTheme", function() { return _Styling__WEBPACK_IMPORTED_MODULE_77__["createTheme"]; });
 
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "initializeThemeInCustomizations", function() { return _Styling__WEBPACK_IMPORTED_MODULE_77__["initializeThemeInCustomizations"]; });
+
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "registerOnThemeChangeCallback", function() { return _Styling__WEBPACK_IMPORTED_MODULE_77__["registerOnThemeChangeCallback"]; });
 
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "removeOnThemeChangeCallback", function() { return _Styling__WEBPACK_IMPORTED_MODULE_77__["removeOnThemeChangeCallback"]; });
@@ -79318,16 +81506,17 @@ __webpack_require__.r(__webpack_exports__);
 
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "createMergedRef", function() { return _Utilities__WEBPACK_IMPORTED_MODULE_85__["createMergedRef"]; });
 
-/* harmony import */ var _WindowProvider__WEBPACK_IMPORTED_MODULE_86__ = __webpack_require__("../../packages/office-ui-fabric-react/lib/WindowProvider.js");
-/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "WindowContext", function() { return _WindowProvider__WEBPACK_IMPORTED_MODULE_86__["WindowContext"]; });
+/* harmony import */ var _Viewport__WEBPACK_IMPORTED_MODULE_86__ = __webpack_require__("../../packages/office-ui-fabric-react/lib/Viewport.js");
+/* empty/unused harmony star reexport *//* harmony import */ var _WindowProvider__WEBPACK_IMPORTED_MODULE_87__ = __webpack_require__("../../packages/office-ui-fabric-react/lib/WindowProvider.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "WindowContext", function() { return _WindowProvider__WEBPACK_IMPORTED_MODULE_87__["WindowContext"]; });
 
-/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "useWindow", function() { return _WindowProvider__WEBPACK_IMPORTED_MODULE_86__["useWindow"]; });
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "useWindow", function() { return _WindowProvider__WEBPACK_IMPORTED_MODULE_87__["useWindow"]; });
 
-/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "useDocument", function() { return _WindowProvider__WEBPACK_IMPORTED_MODULE_86__["useDocument"]; });
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "useDocument", function() { return _WindowProvider__WEBPACK_IMPORTED_MODULE_87__["useDocument"]; });
 
-/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "WindowProvider", function() { return _WindowProvider__WEBPACK_IMPORTED_MODULE_86__["WindowProvider"]; });
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "WindowProvider", function() { return _WindowProvider__WEBPACK_IMPORTED_MODULE_87__["WindowProvider"]; });
 
-/* harmony import */ var _version__WEBPACK_IMPORTED_MODULE_87__ = __webpack_require__("../../packages/office-ui-fabric-react/lib/version.js");
+/* harmony import */ var _version__WEBPACK_IMPORTED_MODULE_88__ = __webpack_require__("../../packages/office-ui-fabric-react/lib/version.js");
 
 
 
@@ -79418,6 +81607,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
 
 
 /***/ }),
@@ -84030,7 +86220,7 @@ __webpack_require__.r(__webpack_exports__);
 // Do not modify this file; it is generated as part of publish.
 // The checked in version is a placeholder only and will not be updated.
 
-Object(_uifabric_set_version__WEBPACK_IMPORTED_MODULE_0__["setVersion"])('office-ui-fabric-react', '7.198.0');
+Object(_uifabric_set_version__WEBPACK_IMPORTED_MODULE_0__["setVersion"])('office-ui-fabric-react', '7.198.2');
 
 
 /***/ }),
@@ -85213,7 +87403,7 @@ __webpack_require__.r(__webpack_exports__);
 // Do not modify this file; it is generated as part of publish.
 // The checked in version is a placeholder only and will not be updated.
 
-Object(_uifabric_set_version__WEBPACK_IMPORTED_MODULE_0__["setVersion"])('@fluentui/react-focus', '7.18.12');
+Object(_uifabric_set_version__WEBPACK_IMPORTED_MODULE_0__["setVersion"])('@fluentui/react-focus', '7.18.13');
 
 
 /***/ }),
@@ -86237,6 +88427,8 @@ __webpack_require__.r(__webpack_exports__);
 
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "createTheme", function() { return _styles_index__WEBPACK_IMPORTED_MODULE_1__["createTheme"]; });
 
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "initializeThemeInCustomizations", function() { return _styles_index__WEBPACK_IMPORTED_MODULE_1__["initializeThemeInCustomizations"]; });
+
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "registerOnThemeChangeCallback", function() { return _styles_index__WEBPACK_IMPORTED_MODULE_1__["registerOnThemeChangeCallback"]; });
 
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "removeOnThemeChangeCallback", function() { return _styles_index__WEBPACK_IMPORTED_MODULE_1__["removeOnThemeChangeCallback"]; });
@@ -86322,15 +88514,11 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "mergeStyles", function() { return _MergeStyles__WEBPACK_IMPORTED_MODULE_3__["mergeStyles"]; });
 
 /* harmony import */ var _version__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("../../packages/styling/lib/version.js");
-/* harmony import */ var _styles_theme__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("../../packages/styling/lib/styles/theme.js");
 
 
 
 
 
-// Ensure theme is initialized when this package is referenced.
-
-Object(_styles_theme__WEBPACK_IMPORTED_MODULE_5__["initializeThemeInCustomizations"])();
 
 
 /***/ }),
@@ -87037,6 +89225,8 @@ __webpack_require__.r(__webpack_exports__);
 
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "createTheme", function() { return _theme__WEBPACK_IMPORTED_MODULE_10__["createTheme"]; });
 
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "initializeThemeInCustomizations", function() { return _theme__WEBPACK_IMPORTED_MODULE_10__["initializeThemeInCustomizations"]; });
+
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "registerOnThemeChangeCallback", function() { return _theme__WEBPACK_IMPORTED_MODULE_10__["registerOnThemeChangeCallback"]; });
 
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "removeOnThemeChangeCallback", function() { return _theme__WEBPACK_IMPORTED_MODULE_10__["removeOnThemeChangeCallback"]; });
@@ -87208,6 +89398,7 @@ function initializeThemeInCustomizations() {
         _uifabric_utilities__WEBPACK_IMPORTED_MODULE_1__["Customizations"].applySettings((_a = {}, _a[ThemeSettingName] = _theme, _a));
     }
 }
+// Ensure theme is initialized when this package is referenced.
 initializeThemeInCustomizations();
 /**
  * Gets the theme object
@@ -87608,7 +89799,7 @@ __webpack_require__.r(__webpack_exports__);
 // Do not modify this file; it is generated as part of publish.
 // The checked in version is a placeholder only and will not be updated.
 
-Object(_uifabric_set_version__WEBPACK_IMPORTED_MODULE_0__["setVersion"])('@uifabric/styling', '7.22.3');
+Object(_uifabric_set_version__WEBPACK_IMPORTED_MODULE_0__["setVersion"])('@uifabric/styling', '7.23.0');
 
 
 /***/ }),
@@ -95343,6 +97534,12 @@ __webpack_require__.r(__webpack_exports__);
 
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HeatMapChart", function() { return _uifabric_charting__WEBPACK_IMPORTED_MODULE_1__["HeatMapChart"]; });
 
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TreeChart", function() { return _uifabric_charting__WEBPACK_IMPORTED_MODULE_1__["TreeChart"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "NodesComposition", function() { return _uifabric_charting__WEBPACK_IMPORTED_MODULE_1__["NodesComposition"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TreeTraverse", function() { return _uifabric_charting__WEBPACK_IMPORTED_MODULE_1__["TreeTraverse"]; });
+