From e2aefda183de4f1c1256d97f7ce09f8bee5477db Mon Sep 17 00:00:00 2001
From: "Christopher Lott (cl778h)" <clott@research.att.com>
Date: Tue, 9 May 2017 14:24:20 -0400
Subject: [ONAP-rebase] Rebase as 1.1.0-SNAPSHOT

Consolidate into a single maven project; no more separate model and client jars.

Change-Id: Ibbba982250b74c0dfd09ee1c65c0fb6c158dd632
Signed-off-by: Christopher Lott <cl778h@att.com>
Signed-off-by: Christopher Lott (cl778h) <clott@research.att.com>
---
 .../webapp/app/fusion/external/d3/js/d3.layout.js  | 908 ---------------------
 1 file changed, 908 deletions(-)
 delete mode 100644 dcae_dmaapbc_webapp/src/main/webapp/app/fusion/external/d3/js/d3.layout.js

(limited to 'dcae_dmaapbc_webapp/src/main/webapp/app/fusion/external/d3/js/d3.layout.js')

diff --git a/dcae_dmaapbc_webapp/src/main/webapp/app/fusion/external/d3/js/d3.layout.js b/dcae_dmaapbc_webapp/src/main/webapp/app/fusion/external/d3/js/d3.layout.js
deleted file mode 100644
index abc5ebe..0000000
--- a/dcae_dmaapbc_webapp/src/main/webapp/app/fusion/external/d3/js/d3.layout.js
+++ /dev/null
@@ -1,908 +0,0 @@
-(function(){d3.layout = {};
-d3.layout.chord = function() {
-  var chord = {},
-      chords,
-      groups,
-      matrix,
-      n,
-      padding = 0,
-      sortGroups,
-      sortSubgroups,
-      sortChords;
-
-  function relayout() {
-    var subgroups = {},
-        groupSums = [],
-        groupIndex = d3.range(n),
-        subgroupIndex = [],
-        k,
-        x,
-        x0,
-        i,
-        j;
-
-    chords = [];
-    groups = [];
-
-    // Compute the sum.
-    k = 0, i = -1; while (++i < n) {
-      x = 0, j = -1; while (++j < n) {
-        x += matrix[i][j];
-      }
-      groupSums.push(x);
-      subgroupIndex.push(d3.range(n));
-      k += x;
-    }
-
-    // Sort groups…
-    if (sortGroups) {
-      groupIndex.sort(function(a, b) {
-        return sortGroups(groupSums[a], groupSums[b]);
-      });
-    }
-
-    // Sort subgroups…
-    if (sortSubgroups) {
-      subgroupIndex.forEach(function(d, i) {
-        d.sort(function(a, b) {
-          return sortSubgroups(matrix[i][a], matrix[i][b]);
-        });
-      });
-    }
-
-    // Convert the sum to scaling factor for [0, 2pi].
-    // TODO Allow start and end angle to be specified.
-    // TODO Allow padding to be specified as percentage?
-    k = (2 * Math.PI - padding * n) / k;
-
-    // Compute the start and end angle for each group and subgroup.
-    x = 0, i = -1; while (++i < n) {
-      x0 = x, j = -1; while (++j < n) {
-        var di = groupIndex[i],
-            dj = subgroupIndex[i][j],
-            v = matrix[di][dj];
-        subgroups[di + "-" + dj] = {
-          index: di,
-          subindex: dj,
-          startAngle: x,
-          endAngle: x += v * k,
-          value: v
-        };
-      }
-      groups.push({
-        index: di,
-        startAngle: x0,
-        endAngle: x,
-        value: (x - x0) / k
-      });
-      x += padding;
-    }
-
-    // Generate chords for each (non-empty) subgroup-subgroup link.
-    i = -1; while (++i < n) {
-      j = i - 1; while (++j < n) {
-        var source = subgroups[i + "-" + j],
-            target = subgroups[j + "-" + i];
-        if (source.value || target.value) {
-          chords.push({
-            source: source,
-            target: target
-          })
-        }
-      }
-    }
-
-    if (sortChords) resort();
-  }
-
-  function resort() {
-    chords.sort(function(a, b) {
-      a = Math.min(a.source.value, a.target.value);
-      b = Math.min(b.source.value, b.target.value);
-      return sortChords(a, b);
-    });
-  }
-
-  chord.matrix = function(x) {
-    if (!arguments.length) return matrix;
-    n = (matrix = x) && matrix.length;
-    chords = groups = null;
-    return chord;
-  };
-
-  chord.padding = function(x) {
-    if (!arguments.length) return padding;
-    padding = x;
-    chords = groups = null;
-    return chord;
-  };
-
-  chord.sortGroups = function(x) {
-    if (!arguments.length) return sortGroups;
-    sortGroups = x;
-    chords = groups = null;
-    return chord;
-  };
-
-  chord.sortSubgroups = function(x) {
-    if (!arguments.length) return sortSubgroups;
-    sortSubgroups = x;
-    chords = null;
-    return chord;
-  };
-
-  chord.sortChords = function(x) {
-    if (!arguments.length) return sortChords;
-    sortChords = x;
-    if (chords) resort();
-    return chord;
-  };
-
-  chord.chords = function() {
-    if (!chords) relayout();
-    return chords;
-  };
-
-  chord.groups = function() {
-    if (!groups) relayout();
-    return groups;
-  };
-
-  return chord;
-};
-// A rudimentary force layout using Gauss-Seidel.
-d3.layout.force = function() {
-  var force = {},
-      event = d3.dispatch("tick"),
-      size = [1, 1],
-      alpha = .5,
-      distance = 30,
-      interval,
-      nodes,
-      links,
-      distances;
-
-  function tick() {
-    var n = distances.length,
-        i, // current index
-        o, // current link
-        s, // current source
-        t, // current target
-        l, // current distance
-        x, // x-distance
-        y; // y-distance
-
-    // gauss-seidel relaxation
-    for (i = 0; i < n; ++i) {
-      o = distances[i];
-      s = o.source;
-      t = o.target;
-      x = t.x - s.x;
-      y = t.y - s.y;
-      if (l = Math.sqrt(x * x + y * y)) {
-        l = alpha / (o.distance * o.distance) * (l - distance * o.distance) / l;
-        x *= l;
-        y *= l;
-        if (!t.fixed) {
-          t.x -= x;
-          t.y -= y;
-        }
-        if (!s.fixed) {
-          s.x += x;
-          s.y += y;
-        }
-      }
-    }
-
-    event.tick.dispatch({type: "tick"});
-
-    // simulated annealing, basically
-    return (alpha *= .99) < .005;
-  }
-
-  force.on = function(type, listener) {
-    event[type].add(listener);
-    return force;
-  };
-
-  force.nodes = function(x) {
-    if (!arguments.length) return nodes;
-    nodes = x;
-    return force;
-  };
-
-  force.links = function(x) {
-    if (!arguments.length) return links;
-    links = x;
-    return force;
-  };
-
-  force.size = function(x) {
-    if (!arguments.length) return size;
-    size = x;
-    return force;
-  };
-
-  force.distance = function(d) {
-    if (!arguments.length) return distance;
-    distance = d;
-    return force;
-  };
-
-  force.start = function() {
-    var i,
-        j,
-        k,
-        n = nodes.length,
-        m = links.length,
-        w = size[0],
-        h = size[1],
-        o;
-
-    var paths = [];
-    for (i = 0; i < n; ++i) {
-      o = nodes[i];
-      o.x = o.x || Math.random() * w;
-      o.y = o.y || Math.random() * h;
-      o.fixed = 0;
-      paths[i] = [];
-      for (j = 0; j < n; ++j) {
-        paths[i][j] = Infinity;
-      }
-      paths[i][i] = 0;
-    }
-
-    for (i = 0; i < m; ++i) {
-      o = links[i];
-      paths[o.source][o.target] = 1;
-      paths[o.target][o.source] = 1;
-      o.source = nodes[o.source];
-      o.target = nodes[o.target];
-    }
-
-    // Floyd-Warshall
-    for (k = 0; k < n; ++k) {
-      for (i = 0; i < n; ++i) {
-        for (j = 0; j < n; ++j) {
-          paths[i][j] = Math.min(paths[i][j], paths[i][k] + paths[k][j]);
-        }
-      }
-    }
-
-    distances = [];
-    for (i = 0; i < n; ++i) {
-      for (j = i + 1; j < n; ++j) {
-        distances.push({
-          source: nodes[i],
-          target: nodes[j],
-          distance: paths[i][j] * paths[i][j]
-        });
-      }
-    }
-
-    distances.sort(function(a, b) {
-      return a.distance - b.distance;
-    });
-
-    d3.timer(tick);
-    return force;
-  };
-
-  force.resume = function() {
-    alpha = .1;
-    d3.timer(tick);
-    return force;
-  };
-
-  force.stop = function() {
-    alpha = 0;
-    return force;
-  };
-
-  // use `node.call(force.drag)` to make nodes draggable
-  force.drag = function() {
-    var node, element;
-
-    this
-      .on("mouseover", function(d) { d.fixed = true; })
-      .on("mouseout", function(d) { if (d != node) d.fixed = false; })
-      .on("mousedown", mousedown);
-
-    d3.select(window)
-      .on("mousemove", mousemove)
-      .on("mouseup", mouseup);
-
-    function mousedown(d) {
-      (node = d).fixed = true;
-      element = this;
-      d3.event.preventDefault();
-    }
-
-    function mousemove() {
-      if (!node) return;
-      var m = d3.svg.mouse(element);
-      node.x = m[0];
-      node.y = m[1];
-      force.resume(); // restart annealing
-    }
-
-    function mouseup() {
-      if (!node) return;
-      mousemove();
-      node.fixed = false;
-      node = element = null;
-    }
-
-    return force;
-  };
-
-  return force;
-};
-d3.layout.partition = function() {
-  var hierarchy = d3.layout.hierarchy(),
-      size = [1, 1]; // width, height
-
-  function position(node, x, dx, dy) {
-    var children = node.children;
-    node.x = x;
-    node.y = node.depth * dy;
-    node.dx = dx;
-    node.dy = dy;
-    if (children) {
-      var i = -1,
-          n = children.length,
-          c,
-          d;
-      dx /= node.value;
-      while (++i < n) {
-        position(c = children[i], x, d = c.value * dx, dy);
-        x += d;
-      }
-    }
-  }
-
-  function depth(node) {
-    var children = node.children,
-        d = 0;
-    if (children) {
-      var i = -1,
-          n = children.length;
-      while (++i < n) d = Math.max(d, depth(children[i]));
-    }
-    return 1 + d;
-  }
-
-  function partition(d, i) {
-    var nodes = hierarchy.call(this, d, i);
-    position(nodes[0], 0, size[0], size[1] / depth(nodes[0]));
-    return nodes;
-  }
-
-  partition.sort = d3.rebind(partition, hierarchy.sort);
-  partition.children = d3.rebind(partition, hierarchy.children);
-  partition.value = d3.rebind(partition, hierarchy.value);
-
-  partition.size = function(x) {
-    if (!arguments.length) return size;
-    size = x;
-    return partition;
-  };
-
-  return partition;
-};
-d3.layout.pie = function() {
-  var value = Number,
-      sort = null,
-      startAngle = 0,
-      endAngle = 2 * Math.PI;
-
-  function pie(data, i) {
-
-    // Compute the start angle.
-    var a = +(typeof startAngle == "function"
-        ? startAngle.apply(this, arguments)
-        : startAngle);
-
-    // Compute the angular range (end - start).
-    var k = (typeof endAngle == "function"
-        ? endAngle.apply(this, arguments)
-        : endAngle) - startAngle;
-
-    // Optionally sort the data.
-    var index = d3.range(data.length);
-    if (sort != null) index.sort(function(i, j) {
-      return sort(data[i], data[j]);
-    });
-
-    // Compute the numeric values for each data element.
-    var values = data.map(value);
-
-    // Convert k into a scale factor from value to angle, using the sum.
-    k /= values.reduce(function(p, d) { return p + d; }, 0);
-
-    // Compute the arcs!
-    var arcs = index.map(function(i) {
-      return {
-        value: d = values[i],
-        startAngle: a,
-        endAngle: a += d * k
-      };
-    });
-
-    // Return the arcs in the original data's order.
-    return data.map(function(d, i) {
-      return arcs[index[i]];
-    });
-  }
-
-  /**
-   * Specifies the value function *x*, which returns a nonnegative numeric value
-   * for each datum. The default value function is `Number`. The value function
-   * is passed two arguments: the current datum and the current index.
-   */
-  pie.value = function(x) {
-    if (!arguments.length) return value;
-    value = x;
-    return pie;
-  };
-
-  /**
-   * Specifies a sort comparison operator *x*. The comparator is passed two data
-   * elements from the data array, a and b; it returns a negative value if a is
-   * less than b, a positive value if a is greater than b, and zero if a equals
-   * b.
-   */
-  pie.sort = function(x) {
-    if (!arguments.length) return sort;
-    sort = x;
-    return pie;
-  };
-
-  /**
-   * Specifies the overall start angle of the pie chart. Defaults to 0. The
-   * start angle can be specified either as a constant or as a function; in the
-   * case of a function, it is evaluated once per array (as opposed to per
-   * element).
-   */
-  pie.startAngle = function(x) {
-    if (!arguments.length) return startAngle;
-    startAngle = x;
-    return pie;
-  };
-
-  /**
-   * Specifies the overall end angle of the pie chart. Defaults to 2π. The
-   * end angle can be specified either as a constant or as a function; in the
-   * case of a function, it is evaluated once per array (as opposed to per
-   * element).
-   */
-  pie.endAngle = function(x) {
-    if (!arguments.length) return endAngle;
-    endAngle = x;
-    return pie;
-  };
-
-  return pie;
-};
-// data is two-dimensional array of x,y; we populate y0
-// TODO perhaps make the `x`, `y` and `y0` structure customizable
-d3.layout.stack = function() {
-  var order = "default",
-      offset = "zero";
-
-  function stack(data) {
-    var n = data.length,
-        m = data[0].length,
-        i,
-        j,
-        y0;
-
-    // compute the order of series
-    var index = d3_layout_stackOrders[order](data);
-
-    // set y0 on the baseline
-    d3_layout_stackOffsets[offset](data, index);
-
-    // propagate offset to other series
-    for (j = 0; j < m; ++j) {
-      for (i = 1, y0 = data[index[0]][j].y0; i < n; ++i) {
-        data[index[i]][j].y0 = y0 += data[index[i - 1]][j].y;
-      }
-    }
-
-    return data;
-  }
-
-  stack.order = function(x) {
-    if (!arguments.length) return order;
-    order = x;
-    return stack;
-  };
-
-  stack.offset = function(x) {
-    if (!arguments.length) return offset;
-    offset = x;
-    return stack;
-  };
-
-  return stack;
-}
-
-var d3_layout_stackOrders = {
-
-  "inside-out": function(data) {
-    var n = data.length,
-        i,
-        j,
-        max = data.map(d3_layout_stackMaxIndex),
-        sums = data.map(d3_layout_stackReduceSum),
-        index = d3.range(n).sort(function(a, b) { return max[a] - max[b]; }),
-        top = 0,
-        bottom = 0,
-        tops = [],
-        bottoms = [];
-    for (i = 0; i < n; i++) {
-      j = index[i];
-      if (top < bottom) {
-        top += sums[j];
-        tops.push(j);
-      } else {
-        bottom += sums[j];
-        bottoms.push(j);
-      }
-    }
-    return bottoms.reverse().concat(tops);
-  },
-
-  "reverse": function(data) {
-    return d3.range(data.length).reverse();
-  },
-
-  "default": function(data) {
-    return d3.range(data.length);
-  }
-
-};
-
-var d3_layout_stackOffsets = {
-
-  "silhouette": function(data, index) {
-    var n = data.length,
-        m = data[0].length,
-        sums = [],
-        max = 0,
-        i,
-        j,
-        o;
-    for (j = 0; j < m; ++j) {
-      for (i = 0, o = 0; i < n; i++) o += data[i][j].y;
-      if (o > max) max = o;
-      sums.push(o);
-    }
-    for (j = 0, i = index[0]; j < m; ++j) {
-      data[i][j].y0 = (max - sums[j]) / 2;
-    }
-  },
-
-  "wiggle": function(data, index) {
-    var n = data.length,
-        x = data[0],
-        m = x.length,
-        max = 0,
-        i,
-        j,
-        k,
-        ii,
-        ik,
-        i0 = index[0],
-        s1,
-        s2,
-        s3,
-        dx,
-        o,
-        o0;
-    data[i0][0].y0 = o = o0 = 0;
-    for (j = 1; j < m; ++j) {
-      for (i = 0, s1 = 0; i < n; ++i) s1 += data[i][j].y;
-      for (i = 0, s2 = 0, dx = x[j].x - x[j - 1].x; i < n; ++i) {
-        for (k = 0, ii = index[i], s3 = (data[ii][j].y - data[ii][j - 1].y) / (2 * dx); k < i; ++k) {
-          s3 += (data[ik = index[k]][j].y - data[ik][j - 1].y) / dx;
-        }
-        s2 += s3 * data[ii][j].y;
-      }
-      data[i0][j].y0 = o -= s1 ? s2 / s1 * dx : 0;
-      if (o < o0) o0 = o;
-    }
-    for (j = 0; j < m; ++j) data[i0][j].y0 -= o0;
-  },
-
-  "zero": function(data, index) {
-    var j = 0,
-        m = data[0].length,
-        i0 = index[0];
-    for (; j < m; ++j) data[i0][j].y0 = 0;
-  }
-
-};
-
-function d3_layout_stackReduceSum(d) {
-  return d.reduce(d3_layout_stackSum, 0);
-}
-
-function d3_layout_stackMaxIndex(array) {
-  var i = 1,
-      j = 0,
-      v = array[0].y,
-      k,
-      n = array.length;
-  for (; i < n; ++i) {
-    if ((k = array[i].y) > v) {
-      j = i;
-      v = k;
-    }
-  }
-  return j;
-}
-
-function d3_layout_stackSum(p, d) {
-  return p + d.y;
-}
-d3.layout.hierarchy = function() {
-  var sort = d3_layout_hierarchySort,
-      children = d3_layout_hierarchyChildren,
-      value = d3_layout_hierarchyValue;
-
-  // Recursively compute the node depth and value.
-  // Also converts the data representation into a standard hierarchy structure.
-  function recurse(data, depth, nodes) {
-    var datas = children.call(hierarchy, data, depth),
-        node = {depth: depth, data: data};
-    nodes.push(node);
-    if (datas) {
-      var i = -1,
-          n = datas.length,
-          c = node.children = [],
-          v = 0,
-          j = depth + 1;
-      while (++i < n) {
-        d = recurse(datas[i], j, nodes);
-        if (d.value > 0) { // ignore NaN, negative, etc.
-          c.push(d);
-          v += d.value;
-          d.parent = node;
-        }
-      }
-      if (sort) c.sort(sort);
-      node.value = v;
-    } else {
-      node.value = value.call(hierarchy, data, depth);
-    }
-    return node;
-  }
-
-  // Recursively re-evaluates the node value.
-  function revalue(node, depth) {
-    var children = node.children,
-        v = 0;
-    if (children) {
-      var i = -1,
-          n = children.length,
-          j = depth + 1;
-      while (++i < n) v += revalue(children[i], j);
-    } else {
-      v = value.call(hierarchy, node.data, depth);
-    }
-    return node.value = v;
-  }
-
-  function hierarchy(d) {
-    var nodes = [];
-    recurse(d, 0, nodes);
-    return nodes;
-  }
-
-  hierarchy.sort = function(x) {
-    if (!arguments.length) return sort;
-    sort = x;
-    return hierarchy;
-  };
-
-  hierarchy.children = function(x) {
-    if (!arguments.length) return children;
-    children = x;
-    return hierarchy;
-  };
-
-  hierarchy.value = function(x) {
-    if (!arguments.length) return value;
-    value = x;
-    return hierarchy;
-  };
-
-  // Re-evaluates the `value` property for the specified hierarchy.
-  hierarchy.revalue = function(root) {
-    revalue(root, 0);
-    return root;
-  };
-
-  return hierarchy;
-}
-
-function d3_layout_hierarchyChildren(d) {
-  return d.children;
-}
-
-function d3_layout_hierarchyValue(d) {
-  return d.value;
-}
-
-function d3_layout_hierarchySort(a, b) {
-  return b.value - a.value;
-}
-// Squarified Treemaps by Mark Bruls, Kees Huizing, and Jarke J. van Wijk
-d3.layout.treemap = function() {
-  var hierarchy = d3.layout.hierarchy(),
-      round = Math.round,
-      size = [1, 1], // width, height
-      sticky = false,
-      stickies;
-
-  // Recursively compute the node area based on value & scale.
-  function scale(node, k) {
-    var children = node.children;
-    node.area = node.value * k;
-    if (children) {
-      var i = -1,
-          n = children.length;
-      while (++i < n) scale(children[i], k);
-    }
-  }
-
-  // Recursively arranges the specified node's children into squarified rows.
-  function squarify(node) {
-    if (!node.children) return;
-    var rect = {x: node.x, y: node.y, dx: node.dx, dy: node.dy},
-        row = [],
-        children = node.children.slice(), // copy-on-write
-        child,
-        best = Infinity, // the best row score so far
-        score, // the current row score
-        u = Math.min(rect.dx, rect.dy), // initial orientation
-        n;
-    row.area = 0;
-    while ((n = children.length) > 0) {
-      row.push(child = children[n - 1]);
-      row.area += child.area;
-      if ((score = worst(row, u)) <= best) { // continue with this orientation
-        children.pop();
-        best = score;
-      } else { // abort, and try a different orientation
-        row.area -= row.pop().area;
-        position(row, u, rect, false);
-        u = Math.min(rect.dx, rect.dy);
-        row.length = row.area = 0;
-        best = Infinity;
-      }
-    }
-    if (row.length) {
-      position(row, u, rect, true);
-      row.length = row.area = 0;
-    }
-    node.children.forEach(squarify);
-  }
-
-  // Recursively resizes the specified node's children into existing rows.
-  // Preserves the existing layout!
-  function stickify(node) {
-    if (!node.children) return;
-    var rect = {x: node.x, y: node.y, dx: node.dx, dy: node.dy},
-        children = node.children.slice(), // copy-on-write
-        child,
-        row = [];
-    row.area = 0;
-    while (child = children.pop()) {
-      row.push(child);
-      row.area += child.area;
-      if (child.z != null) {
-        position(row, child.z ? rect.dx : rect.dy, rect, !children.length);
-        row.length = row.area = 0;
-      }
-    }
-    node.children.forEach(stickify);
-  }
-
-  // Computes the score for the specified row, as the worst aspect ratio.
-  function worst(row, u) {
-    var s = row.area,
-        r,
-        rmax = 0,
-        rmin = Infinity,
-        i = -1,
-        n = row.length;
-    while (++i < n) {
-      r = row[i].area;
-      if (r < rmin) rmin = r;
-      if (r > rmax) rmax = r;
-    }
-    s *= s;
-    u *= u;
-    return Math.max((u * rmax) / s, s / (u * rmin));
-  }
-
-  // Positions the specified row of nodes. Modifies `rect`.
-  function position(row, u, rect, flush) {
-    var i = -1,
-        n = row.length,
-        x = rect.x,
-        y = rect.y,
-        v = u ? round(row.area / u) : 0,
-        o;
-    if (u == rect.dx) { // horizontal subdivision
-      if (flush || v > rect.dy) v = rect.dy; // over+underflow
-      while (++i < n) {
-        o = row[i];
-        o.x = x;
-        o.y = y;
-        o.dy = v;
-        x += o.dx = round(o.area / v);
-      }
-      o.z = true;
-      o.dx += rect.x + rect.dx - x; // rounding error
-      rect.y += v;
-      rect.dy -= v;
-    } else { // vertical subdivision
-      if (flush || v > rect.dx) v = rect.dx; // over+underflow
-      while (++i < n) {
-        o = row[i];
-        o.x = x;
-        o.y = y;
-        o.dx = v;
-        y += o.dy = round(o.area / v);
-      }
-      o.z = false;
-      o.dy += rect.y + rect.dy - y; // rounding error
-      rect.x += v;
-      rect.dx -= v;
-    }
-  }
-
-  function treemap(d) {
-    var nodes = stickies || hierarchy(d),
-        root = nodes[0];
-    root.x = 0;
-    root.y = 0;
-    root.dx = size[0];
-    root.dy = size[1];
-    if (stickies) hierarchy.revalue(root);
-    scale(root, size[0] * size[1] / root.value);
-    (stickies ? stickify : squarify)(root);
-    if (sticky) stickies = nodes;
-    return nodes;
-  }
-
-  treemap.sort = d3.rebind(treemap, hierarchy.sort);
-  treemap.children = d3.rebind(treemap, hierarchy.children);
-  treemap.value = d3.rebind(treemap, hierarchy.value);
-
-  treemap.size = function(x) {
-    if (!arguments.length) return size;
-    size = x;
-    return treemap;
-  };
-
-  treemap.round = function(x) {
-    if (!arguments.length) return round != Number;
-    round = x ? Math.round : Number;
-    return treemap;
-  };
-
-  treemap.sticky = function(x) {
-    if (!arguments.length) return sticky;
-    sticky = x;
-    stickies = null;
-    return treemap;
-  };
-
-  return treemap;
-};
-})()
\ No newline at end of file
-- 
cgit 1.2.3-korg