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 childs = children.call(hierarchy, data, depth),

        node = d3_layout_hierarchyInline ? data : {data: data};

    node.depth = depth;

    nodes.push(node);

    if (childs && (n = childs.length)) {

      var i = -1,

          n,

          c = node.children = [],

          v = 0,

          j = depth + 1;

      while (++i < n) {

        d = recurse(childs[i], j, nodes);

        d.parent = node;

        c.push(d);

        v += d.value;

      }

      if (sort) c.sort(sort);

      if (value) node.value = v;

    } else if (value) {

      node.value = +value.call(hierarchy, data, depth) || 0;

    }

    return node;

  }

  // Recursively re-evaluates the node value.

  function revalue(node, depth) {

    var children = node.children,

        v = 0;

    if (children && (n = children.length)) {

      var i = -1,

          n,

          j = depth + 1;

      while (++i < n) v += revalue(children[i], j);

    } else if (value) {

      v = +value.call(hierarchy, d3_layout_hierarchyInline ? node : node.data, depth) || 0;

    }

    if (value) node.value = v;

    return 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;

};

// A method assignment helper for hierarchy subclasses.

function d3_layout_hierarchyRebind(object, hierarchy) {

  object.sort = d3.rebind(object, hierarchy.sort);

  object.children = d3.rebind(object, hierarchy.children);

  object.links = d3_layout_hierarchyLinks;

  object.value = d3.rebind(object, hierarchy.value);

  // If the new API is used, enabling inlining.

  object.nodes = function(d) {

    d3_layout_hierarchyInline = true;

    return (object.nodes = object)(d);

  };

  return object;

}

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;

}

// Returns an array source+target objects for the specified nodes.

function d3_layout_hierarchyLinks(nodes) {

  return d3.merge(nodes.map(function(parent) {

    return (parent.children || []).map(function(child) {

      return {source: parent, target: child};

    });

  }));

}

// For backwards-compatibility, don't enable inlining by default.

var d3_layout_hierarchyInline = false;