JavaScriptCollection
diff --git a/‎d3.layout.js‎
Lines changed: 53 additions & 55 deletions b/‎d3.layout.js‎
Lines changed: 53 additions & 55 deletions
@@ -753,16 +753,11 @@ d3.layout.tree = function() {
         y1 = 0; // max depth
 
     function firstWalk(node, previousSibling) {
-      var children = node.children;
-      if (!children) {
-        if (previousSibling) {
-          node.prelim = previousSibling.prelim + separation(node, previousSibling);
-        }
-      } else {
+      var children = node.children,
+          layout = node._tree;
+      if (children) {
         var n = children.length,
-            firstChild = children[0],
-            lastChild = children[n - 1],
-            ancestor = firstChild,
+            ancestor = children[0],
             previousChild,
             child,
             i = -1;
@@ -773,31 +768,35 @@ d3.layout.tree = function() {
           previousChild = child;
         }
         d3_layout_treeShift(node);
-        var midpoint = .5 * (firstChild.prelim + lastChild.prelim);
+        var midpoint = .5 * (children[0]._tree.prelim + children[n - 1]._tree.prelim);
         if (previousSibling) {
-          node.prelim = previousSibling.prelim + separation(node, previousSibling);
-          node.mod = node.prelim - midpoint;
+          layout.prelim = previousSibling._tree.prelim + separation(node, previousSibling);
+          layout.mod = layout.prelim - midpoint;
         } else {
-          node.prelim = midpoint;
+          layout.prelim = midpoint;
+        }
+      } else {
+        if (previousSibling) {
+          layout.prelim = previousSibling._tree.prelim + separation(node, previousSibling);
         }
       }
     }
 
     function secondWalk(node, x) {
-      node.breadth = node.prelim + x;
+      node.x = node._tree.prelim + x;
       var children = node.children;
       if (children) {
         var i = -1,
             n = children.length;
-        x += node.mod;
+        x += node._tree.mod;
         while (++i < n) {
           secondWalk(children[i], x);
         }
       }
 
       // Compute extent of breadth and depth.
-      if (node.breadth < x0) x0 = node.breadth;
-      if (node.breadth > x1) x1 = node.breadth;
+      if (node.x < x0) x0 = node.x;
+      if (node.x > x1) x1 = node.x;
       if (node.depth > y1) y1 = node.depth;
     }
 
@@ -807,65 +806,60 @@ d3.layout.tree = function() {
             vop = node,
             vim = previousSibling,
             vom = node.parent.children[0],
-            sip = vip.mod,
-            sop = vop.mod,
-            sim = vim.mod,
-            som = vom.mod,
+            sip = vip._tree.mod,
+            sop = vop._tree.mod,
+            sim = vim._tree.mod,
+            som = vom._tree.mod,
             shift;
         while (vim = d3_tree_layoutRight(vim), vip = d3_tree_layoutLeft(vip), vim && vip) {
           vom = d3_tree_layoutLeft(vom);
           vop = d3_tree_layoutRight(vop);
-          vop.ancestor = node;
-          shift = vim.prelim + sim - vip.prelim - sip + separation(vim, vip);
+          vop._tree.ancestor = node;
+          shift = vim._tree.prelim + sim - vip._tree.prelim - sip + separation(vim, vip);
           if (shift > 0) {
             d3_layout_treeMove(d3_layout_treeAncestor(vim, node, ancestor), node, shift);
             sip += shift;
             sop += shift;
           }
-          sim += vim.mod;
-          sip += vip.mod;
-          som += vom.mod;
-          sop += vop.mod;
+          sim += vim._tree.mod;
+          sip += vip._tree.mod;
+          som += vom._tree.mod;
+          sop += vop._tree.mod;
         }
         if (vim && !d3_tree_layoutRight(vop)) {
-          vop.thread = vim;
-          vop.mod += sim - sop;
+          vop._tree.thread = vim;
+          vop._tree.mod += sim - sop;
         }
         if (vip && !d3_tree_layoutLeft(vom)) {
-          vom.thread = vip;
-          vom.mod += sip - som;
+          vom._tree.thread = vip;
+          vom._tree.mod += sip - som;
           ancestor = node;
         }
       }
       return ancestor;
     }
 
-    // Initialize temporary layout variables. TODO store separately?
+    // Initialize temporary layout variables.
     d3_layout_treeVisitAfter(root, function(node, previousSibling) {
-      node.ancestor = node;
-      node.prelim = 0;
-      node.mod = 0;
-      node.change = 0;
-      node.shift = 0;
-      node.number = previousSibling ? previousSibling.number + 1 : 0;
+      node._tree = {
+        ancestor: node,
+        prelim: 0,
+        mod: 0,
+        change: 0,
+        shift: 0,
+        number: previousSibling ? previousSibling._tree.number + 1 : 0
+      };
     });
 
     // Compute the layout using Buchheim et al.'s algorithm.
     firstWalk(root);
-    secondWalk(root, -root.prelim);
+    secondWalk(root, -root._tree.prelim);
 
     // Clear temporary layout variables; transform depth and breadth.
     d3_layout_treeVisitAfter(root, function(node) {
-      node.x = ((node.breadth - x0) / (x1 - x0)) * size[0];
+      node.x = ((node.x - x0) / (x1 - x0)) * size[0];
       node.y = node.depth / y1 * size[1];
-      delete node.breadth;
-      delete node.ancestor;
-      delete node.prelim;
-      delete node.mod;
-      delete node.change;
-      delete node.shift;
-      delete node.number;
-      delete node.thread;
+      delete node._tree;
     });
 
     return nodes;
@@ -898,11 +892,11 @@ function d3_layout_treeSeparation(a, b) {
 // }
 
 function d3_tree_layoutLeft(node) {
-  return node.children ? node.children[0] : node.thread;
+  return node.children ? node.children[0] : node._tree.thread;
 }
 
 function d3_tree_layoutRight(node) {
-  return node.children ? node.children[node.children.length - 1] : node.thread;
+  return node.children ? node.children[node.children.length - 1] : node._tree.thread;
 }
 
 function d3_layout_treeVisitAfter(node, callback) {
@@ -931,24 +925,28 @@ function d3_layout_treeShift(node) {
       i = children.length,
       child;
   while (--i >= 0) {
-    child = children[i];
+    child = children[i]._tree;
     child.prelim += shift;
     child.mod += shift;
     shift += child.shift + (change += child.change);
   }
 }
 
 function d3_layout_treeMove(ancestor, node, shift) {
-  var subtrees = node.number - ancestor.number;
-  node.change -= shift / subtrees;
+  ancestor = ancestor._tree;
+  node = node._tree;
+  var change = shift / (node.number - ancestor.number);
+  ancestor.change += change;
+  node.change -= change;
   node.shift += shift;
-  ancestor.change += shift / subtrees;
   node.prelim += shift;
   node.mod += shift;
 }
 
 function d3_layout_treeAncestor(vim, node, ancestor) {
-  return vim.ancestor.parent == node.parent ? vim.ancestor : ancestor;
+  return vim._tree.ancestor.parent == node.parent
+      ? vim._tree.ancestor
+      : ancestor;
 }
 // Squarified Treemaps by Mark Bruls, Kees Huizing, and Jarke J. van Wijk
 d3.layout.treemap = function() {