d3.nest = function() {

  var nest = {},

      keys = [],

      sortKeys = [],

      sortValues,

      rollup;

  function map(array, depth) {

    if (depth >= keys.length) return rollup

        ? rollup.call(nest, array) : (sortValues

        ? array.sort(sortValues)

        : array);

    var i = -1,

        n = array.length,

        key = keys[depth++],

        keyValue,

        object,

        o = {};

    while (++i < n) {

      if ((keyValue = key(object = array[i])) in o) {

        o[keyValue].push(object);

      } else {

        o[keyValue] = [object];

      }

    }

    for (keyValue in o) {

      o[keyValue] = map(o[keyValue], depth);

    }

    return o;

  }

  function entries(map, depth) {

    if (depth >= keys.length) return map;

    var a = [],

        sortKey = sortKeys[depth++],

        key;

    for (key in map) {

      a.push({key: key, values: entries(map[key], depth)});

    }

    if (sortKey) a.sort(function(a, b) {

      return sortKey(a.key, b.key);

    });

    return a;

  }

  nest.map = function(array) {

    return map(array, 0);

  };

  nest.entries = function(array) {

    return entries(map(array, 0), 0);

  };

  nest.key = function(d) {

    keys.push(d);

    return nest;

  };

  // Specifies the order for the most-recently specified key.

  // Note: only applies to entries. Map keys are unordered!

  nest.sortKeys = function(order) {

    sortKeys[keys.length - 1] = order;

    return nest;

  };

  // Specifies the order for leaf values.

  // Applies to both maps and entries array.

  nest.sortValues = function(order) {

    sortValues = order;

    return nest;

  };

  nest.rollup = function(f) {

    rollup = f;

    return nest;

  };

  return nest;

};