text: (function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
    typeof define === 'function' && define.amd ? define(['exports'], factory) :
    (factory((global.d3_collection = global.d3_collection || {})));
  }(this, function (exports) { 'use strict';
  
    var version = "0.2.0";
  
    var prefix = "$";
  
    function Map() {}
  
    Map.prototype = map.prototype = {
      constructor: Map,
      has: function(key) {
        return (prefix + key) in this;
      },
      get: function(key) {
        return this[prefix + key];
      },
      set: function(key, value) {
        this[prefix + key] = value;
        return this;
      },
      remove: function(key) {
        var property = prefix + key;
        return property in this && delete this[property];
      },
      clear: function() {
        for (var property in this) if (property[0] === prefix) delete this[property];
      },
      keys: function() {
        var keys = [];
        for (var property in this) if (property[0] === prefix) keys.push(property.slice(1));
        return keys;
      },
      values: function() {
        var values = [];
        for (var property in this) if (property[0] === prefix) values.push(this[property]);
        return values;
      },
      entries: function() {
        var entries = [];
        for (var property in this) if (property[0] === prefix) entries.push({key: property.slice(1), value: this[property]});
        return entries;
      },
      size: function() {
        var size = 0;
        for (var property in this) if (property[0] === prefix) ++size;
        return size;
      },
      empty: function() {
        for (var property in this) if (property[0] === prefix) return false;
        return true;
      },
      each: function(f) {
        for (var property in this) if (property[0] === prefix) f(this[property], property.slice(1), this);
      }
    };
  
    function map(object, f) {
      var map = new Map;
  
      // Copy constructor.
      if (object instanceof Map) object.each(function(value, key) { map.set(key, value); });
  
      // Index array by numeric index or specified key function.
      else if (Array.isArray(object)) {
        var i = -1,
            n = object.length,
            o;
  
        if (f == null) while (++i < n) map.set(i, object[i]);
        else while (++i < n) map.set(f(o = object[i], i, object), o);
      }
  
      // Convert object to map.
      else if (object) for (var key in object) map.set(key, object[key]);
  
      return map;
    }
  
    function nest() {
      var keys = [],
          sortKeys = [],
          sortValues,
          rollup,
          nest;
  
      function apply(array, depth, createResult, setResult) {
        if (depth >= keys.length) return rollup != null
            ? rollup(array) : (sortValues != null
            ? array.sort(sortValues)
            : array);
  
        var i = -1,
            n = array.length,
            key = keys[depth++],
            keyValue,
            value,
            valuesByKey = map(),
            values,
            result = createResult();
  
        while (++i < n) {
          if (values = valuesByKey.get(keyValue = key(value = array[i]) + "")) {
            values.push(value);
          } else {
            valuesByKey.set(keyValue, [value]);
          }
        }
  
        valuesByKey.each(function(values, key) {
          setResult(result, key, apply(values, depth, createResult, setResult));
        });
  
        return result;
      }
  
      function entries(map, depth) {
        if (++depth > keys.length) return map;
        var array, sortKey = sortKeys[depth - 1];
        if (rollup != null && depth >= keys.length) array = map.entries();
        else array = [], map.each(function(v, k) { array.push({key: k, values: entries(v, depth)}); });
        return sortKey != null ? array.sort(function(a, b) { return sortKey(a.key, b.key); }) : array;
      }
  
      return nest = {
        object: function(array) { return apply(array, 0, createObject, setObject); },
        map: function(array) { return apply(array, 0, createMap, setMap); },
        entries: function(array) { return entries(apply(array, 0, createMap, setMap), 0); },
        key: function(d) { keys.push(d); return nest; },
        sortKeys: function(order) { sortKeys[keys.length - 1] = order; return nest; },
        sortValues: function(order) { sortValues = order; return nest; },
        rollup: function(f) { rollup = f; return nest; }
      };
    }
  
    function createObject() {
      return {};
    }
  
    function setObject(object, key, value) {
      object[key] = value;
    }
  
    function createMap() {
      return map();
    }
  
    function setMap(map, key, value) {
      map.set(key, value);
    }
  
    function Set() {}
  
    var proto = map.prototype;
  
    Set.prototype = set.prototype = {
      constructor: Set,
      has: proto.has,
      add: function(value) {
        value += "";
        this[prefix + value] = value;
        return this;
      },
      remove: proto.remove,
      clear: proto.clear,
      values: proto.keys,
      size: proto.size,
      empty: proto.empty,
      each: proto.each
    };
  
    function set(object, f) {
      var set = new Set;
  
      // Copy constructor.
      if (object instanceof Set) object.each(function(value) { set.add(value); });
  
      // Otherwise, assume it’s an array.
      else if (object) {
        var i = -1, n = object.length;
        if (f == null) while (++i < n) set.add(object[i]);
        else while (++i < n) set.add(f(object[i], i, object));
      }
  
      return set;
    }
  
    function keys(map) {
      var keys = [];
      for (var key in map) keys.push(key);
      return keys;
    }
  
    function values(map) {
      var values = [];
      for (var key in map) values.push(map[key]);
      return values;
    }
  
    function entries(map) {
      var entries = [];
      for (var key in map) entries.push({key: key, value: map[key]});
      return entries;
    }
  
    exports.version = version;
    exports.nest = nest;
    exports.set = set;
    exports.map = map;
    exports.keys = keys;
    exports.values = values;
    exports.entries = entries;
  
  }));