diff --git a/.babelrc b/.babelrc
index af0f0c3..c970805 100644
--- a/.babelrc
+++ b/.babelrc
@@ -1,3 +1,4 @@
 {
-  "presets": ["es2015"]
+  "presets": ["es2015"],
+  "plugins": ["transform-runtime"]
 }
\ No newline at end of file
diff --git a/build/app.js b/build/app.js
index 10c1165..949adec 100644
--- a/build/app.js
+++ b/build/app.js
@@ -1,4 +1,125 @@
 (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+// shim for using process in browser
+
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things.  But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals.  It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+(function () {
+  try {
+    cachedSetTimeout = setTimeout;
+  } catch (e) {
+    cachedSetTimeout = function () {
+      throw new Error('setTimeout is not defined');
+    }
+  }
+  try {
+    cachedClearTimeout = clearTimeout;
+  } catch (e) {
+    cachedClearTimeout = function () {
+      throw new Error('clearTimeout is not defined');
+    }
+  }
+} ())
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+    if (!draining || !currentQueue) {
+        return;
+    }
+    draining = false;
+    if (currentQueue.length) {
+        queue = currentQueue.concat(queue);
+    } else {
+        queueIndex = -1;
+    }
+    if (queue.length) {
+        drainQueue();
+    }
+}
+
+function drainQueue() {
+    if (draining) {
+        return;
+    }
+    var timeout = cachedSetTimeout(cleanUpNextTick);
+    draining = true;
+
+    var len = queue.length;
+    while(len) {
+        currentQueue = queue;
+        queue = [];
+        while (++queueIndex < len) {
+            if (currentQueue) {
+                currentQueue[queueIndex].run();
+            }
+        }
+        queueIndex = -1;
+        len = queue.length;
+    }
+    currentQueue = null;
+    draining = false;
+    cachedClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+    var args = new Array(arguments.length - 1);
+    if (arguments.length > 1) {
+        for (var i = 1; i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+        }
+    }
+    queue.push(new Item(fun, args));
+    if (queue.length === 1 && !draining) {
+        cachedSetTimeout(drainQueue, 0);
+    }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+    this.fun = fun;
+    this.array = array;
+}
+Item.prototype.run = function () {
+    this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+};
+
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };
+
+},{}],2:[function(require,module,exports){
 'use strict';
 
 var pheasant = require('./lib/pheasant.js');
@@ -19,53 +140,354 @@ window.onload = function () {
   return req.send(null);
 };
 
-},{"./lib/pheasant.js":2}],2:[function(require,module,exports){
+},{"./lib/pheasant.js":3}],3:[function(require,module,exports){
 'use strict';
 
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _regenerator = require('babel-runtime/regenerator');
+
+var _regenerator2 = _interopRequireDefault(_regenerator);
+
+var _getIterator2 = require('babel-runtime/core-js/get-iterator');
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _marked = [eachYear, eachDay, eachHour].map(_regenerator2.default.mark);
+
 // Create heat map data visualization
 
 // Creates the visualization
 function visualize(data, domElementId, opts) {
 
-  console.log('visualizing...');
-
   var options = {
-    minColor: 0xf0f0f0,
-    maxColor: 0x050505,
-    numSteps: 5
+    minColor: 0xfbfbfb,
+    maxColor: 0x606060,
+    numSteps: 10,
+    cellWidth: 6,
+    cellHeight: 6,
+    cellSpacing: 2
   };
 
   var element = document.getElementById(domElementId);
-  var canvas = createCanvas(500, 200);
+  var canvas = createCanvas(365 * options.cellWidth, 1000);
   element.appendChild(canvas);
   var context = canvas.getContext('2d');
 
-  var steps = calculateColorSteps(options.minColor, options.maxColor, options.numSteps);
+  var stepColors = calculateColorSteps(options.minColor, options.maxColor, options.numSteps);
+  var valueSteps = calculateValueSteps(data, options.numSteps);
+
+  console.log(valueSteps);
+
+  // Ensure the data is keyed by Epoch time values - easier to work with
+  data = ensureEpochKeys(data);
+
+  // Find start and end keys
+
+  var _findStartAndEndTimes = findStartAndEndTimes(data);
+
+  var start = _findStartAndEndTimes.start;
+  var end = _findStartAndEndTimes.end;
+
+
+  var x = 0,
+      y = 0,
+      yearOffset = 0;
+  var w = options.cellWidth,
+      h = options.cellHeight; // TODO dynamically calculate these from the time dimensions
+
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
+
+  try {
+    for (var _iterator = (0, _getIterator3.default)(eachYear(parseInt(start), parseInt(end))), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var year = _step.value;
+
+      // Set x back to 0, and move y down if needed
+      x = 0;
+
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
+
+      try {
+        for (var _iterator2 = (0, _getIterator3.default)(eachDay(year)), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          var day = _step2.value;
+
+          // Set x over one and move y back up to the year offset
+          y = yearOffset;
+
+          var _iteratorNormalCompletion3 = true;
+          var _didIteratorError3 = false;
+          var _iteratorError3 = undefined;
+
+          try {
+            for (var _iterator3 = (0, _getIterator3.default)(eachHour(day)), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+              var hour = _step3.value;
+
+              // Draw the block onto the canvas
+              var value = data[hour];
+              var color = getColor(value, valueSteps, stepColors);
+
+              context.fillStyle = color;
+              context.fillRect(x, y, w, h);
+              y += h + options.cellSpacing;
+            }
+          } catch (err) {
+            _didIteratorError3 = true;
+            _iteratorError3 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion3 && _iterator3.return) {
+                _iterator3.return();
+              }
+            } finally {
+              if (_didIteratorError3) {
+                throw _iteratorError3;
+              }
+            }
+          }
+
+          x += w + options.cellSpacing;
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+
+      yearOffset += (h + options.cellSpacing) * 24;
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+}
+
+function getColor(value, valueSteps, stepColors) {
+  var index = 0,
+      color = '#ffffff'; // White is default
+
+  // TODO Handle negative numebers, or at least 0, a little better
+  if (value) {
+    do {
+      color = stepColors[index];
+    } while (index < valueSteps.length && value > valueSteps[index++]);
+  }
+
+  return color;
+}
+
+// Yields Jan 1 at Midnight in Epoch milliseconds starting at start year, ending with end year
+function eachYear(start, end) {
+  var current, endDate, endYear;
+  return _regenerator2.default.wrap(function eachYear$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          current = new Date(new Date(start).getUTCFullYear(), 0), endDate = new Date(new Date(end).getUTCFullYear(), 12), endYear = endDate.getUTCFullYear();
+
+        case 1:
+          if (!(current.getUTCFullYear() < endYear)) {
+            _context.next = 7;
+            break;
+          }
+
+          _context.next = 4;
+          return current.getTime();
+
+        case 4:
+          current.setUTCFullYear(current.getUTCFullYear() + 1);
+          _context.next = 1;
+          break;
+
+        case 7:
+        case 'end':
+          return _context.stop();
+      }
+    }
+  }, _marked[0], this);
+}
+
+// Yields midnight in milliseconds for each day in the year (handles leap year)
+function eachDay(year) {
+  var date, month, current, end, currentMonth;
+  return _regenerator2.default.wrap(function eachDay$(_context2) {
+    while (1) {
+      switch (_context2.prev = _context2.next) {
+        case 0:
+          date = 1, month = 0, current = new Date(new Date(year).getUTCFullYear(), 0), end = new Date(new Date(year).getUTCFullYear(), 12);
+
+        case 1:
+          if (!(current.getTime() < end.getTime())) {
+            _context2.next = 9;
+            break;
+          }
+
+          _context2.next = 4;
+          return current.getTime();
+
+        case 4:
+
+          current.setUTCDate(++date);
+
+          currentMonth = current.getUTCMonth();
+
+          if (currentMonth > month) {
+            current.setUTCMonth(++month);
+            current.setUTCDate(date = 1);
+            month = currentMonth;
+          }
+          _context2.next = 1;
+          break;
+
+        case 9:
+        case 'end':
+          return _context2.stop();
+      }
+    }
+  }, _marked[1], this);
+}
+
+// Yields start of hour in milliseconds for each hour in the day
+function eachHour(day) {
+  var hours, hourMilliseconds, dayDate, current, end;
+  return _regenerator2.default.wrap(function eachHour$(_context3) {
+    while (1) {
+      switch (_context3.prev = _context3.next) {
+        case 0:
+          hours = 0, hourMilliseconds = 60 * 60 * 1000, dayDate = new Date(day), current = new Date(dayDate.getUTCFullYear(), dayDate.getUTCMonth(), dayDate.getUTCDate()).getTime(), end = current + 24 * hourMilliseconds;
+
+        case 1:
+          if (!(current <= end)) {
+            _context3.next = 7;
+            break;
+          }
+
+          _context3.next = 4;
+          return current;
+
+        case 4:
+          current += hourMilliseconds;
+          _context3.next = 1;
+          break;
 
-  context.fillRect(20, 20, 100, 100);
+        case 7:
+        case 'end':
+          return _context3.stop();
+      }
+    }
+  }, _marked[2], this);
+}
+
+// function eachHour*(start, end, step = 60 * 60 * 1000) {
+//   let current = start;
+//   while (current <= end) {
+//     yield current;
+//     current += step;
+//   }
+// }
+
+function findStartAndEndTimes(data) {
+  var start = new Date(),
+      end = new Date();
+
+  end.setYear(1000); // Maybe there's a better way?
+
+  for (var k in data) {
+    if (k < start) start = k;
+    if (k > end) end = k;
+  }
+
+  return { start: start, end: end };
+}
+
+function ensureEpochKeys(data) {
+  var r = {};
+  (0, _keys2.default)(data).forEach(function (k) {
+    var d = new Date(k),
+        offset = d.getTimezoneOffset() * 60 * 1000;
+
+    r[d.getTime() + offset] = data[k];
+  });
+  return r;
+}
+
+function calculateValueSteps(data, stepCount) {
+  var values = getValues(data).sort(function (a, b) {
+    return a === b ? 0 : a < b ? -1 : 1;
+  }),
+      stepSize = Math.round(values.length / stepCount);
+
+  var steps = [];
+
+  for (var i = 0; i < stepCount; i++) {
+    var index = stepSize * (i + 1);
+    if (index >= values.length) break;
+    steps.push(values[index]);
+  }
+
+  console.log('foo');
+  console.log(values[values.length - 50]);
+
+  return steps;
+}
+
+function getValues(obj) {
+  return (0, _keys2.default)(obj).map(function (k) {
+    return obj[k];
+  });
 }
 
 function calculateColorSteps(min, max, stepCount) {
+  // TODO Put this in its own module.
   var minRed = min & 0xff0000,
       minGreen = min & 0x00ff00,
       minBlue = min & 0x0000ff,
       maxRed = max & 0xff0000,
       maxGreen = max & 0x00ff00,
       maxBlue = max & 0x0000ff,
-      setps = [];
+      redStepSize = (minRed - maxRed) / stepCount & 0xff0000,
+      greenStepSize = (minGreen - maxGreen) / stepCount & 0x00ff00,
+      blueStepSize = (minBlue - maxBlue) / stepCount & 0x0000ff;
+
+  var steps = [];
 
-  var redStepSize = Math.floor((maxRed - minRed) / stepCount),
-      greenStepSize = Math.floor((maxGreen - minGreen) / stepCount),
-      blueStepSize = Math.floor((maxBlue - minBlue) / stepCount);
+  for (var i = 0; i < stepCount; i++) {
+    var r = maxRed + redStepSize * i,
+        g = maxGreen + greenStepSize * i,
+        b = maxBlue + blueStepSize * i;
 
-  for (; i < stepCount; i++) {
-    var r = minRed + (redStepSize * i + 1),
-        g = minGreen + (greenStepSize * i + 1),
-        b = minBlue + (blueStepSize * i + 1);
     steps.push(r | g | b);
   }
 
-  return steps;
+  return steps.map(function (n) {
+    return '#' + n.toString(16);
+  }).reverse();
 }
 
 function createCanvas(width, height) {
@@ -80,5 +502,1372 @@ module.exports = {
   visualize: visualize
 };
 
-},{}]},{},[1])
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+},{"babel-runtime/core-js/get-iterator":4,"babel-runtime/core-js/object/keys":5,"babel-runtime/regenerator":6}],4:[function(require,module,exports){
+module.exports = { "default": require("core-js/library/fn/get-iterator"), __esModule: true };
+},{"core-js/library/fn/get-iterator":7}],5:[function(require,module,exports){
+module.exports = { "default": require("core-js/library/fn/object/keys"), __esModule: true };
+},{"core-js/library/fn/object/keys":8}],6:[function(require,module,exports){
+module.exports = require("regenerator-runtime");
+
+},{"regenerator-runtime":62}],7:[function(require,module,exports){
+require('../modules/web.dom.iterable');
+require('../modules/es6.string.iterator');
+module.exports = require('../modules/core.get-iterator');
+},{"../modules/core.get-iterator":57,"../modules/es6.string.iterator":60,"../modules/web.dom.iterable":61}],8:[function(require,module,exports){
+require('../../modules/es6.object.keys');
+module.exports = require('../../modules/_core').Object.keys;
+},{"../../modules/_core":15,"../../modules/es6.object.keys":59}],9:[function(require,module,exports){
+module.exports = function(it){
+  if(typeof it != 'function')throw TypeError(it + ' is not a function!');
+  return it;
+};
+},{}],10:[function(require,module,exports){
+module.exports = function(){ /* empty */ };
+},{}],11:[function(require,module,exports){
+var isObject = require('./_is-object');
+module.exports = function(it){
+  if(!isObject(it))throw TypeError(it + ' is not an object!');
+  return it;
+};
+},{"./_is-object":29}],12:[function(require,module,exports){
+// false -> Array#indexOf
+// true  -> Array#includes
+var toIObject = require('./_to-iobject')
+  , toLength  = require('./_to-length')
+  , toIndex   = require('./_to-index');
+module.exports = function(IS_INCLUDES){
+  return function($this, el, fromIndex){
+    var O      = toIObject($this)
+      , length = toLength(O.length)
+      , index  = toIndex(fromIndex, length)
+      , value;
+    // Array#includes uses SameValueZero equality algorithm
+    if(IS_INCLUDES && el != el)while(length > index){
+      value = O[index++];
+      if(value != value)return true;
+    // Array#toIndex ignores holes, Array#includes - not
+    } else for(;length > index; index++)if(IS_INCLUDES || index in O){
+      if(O[index] === el)return IS_INCLUDES || index || 0;
+    } return !IS_INCLUDES && -1;
+  };
+};
+},{"./_to-index":48,"./_to-iobject":50,"./_to-length":51}],13:[function(require,module,exports){
+// getting tag from 19.1.3.6 Object.prototype.toString()
+var cof = require('./_cof')
+  , TAG = require('./_wks')('toStringTag')
+  // ES3 wrong here
+  , ARG = cof(function(){ return arguments; }()) == 'Arguments';
+
+// fallback for IE11 Script Access Denied error
+var tryGet = function(it, key){
+  try {
+    return it[key];
+  } catch(e){ /* empty */ }
+};
+
+module.exports = function(it){
+  var O, T, B;
+  return it === undefined ? 'Undefined' : it === null ? 'Null'
+    // @@toStringTag case
+    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
+    // builtinTag case
+    : ARG ? cof(O)
+    // ES3 arguments fallback
+    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
+};
+},{"./_cof":14,"./_wks":55}],14:[function(require,module,exports){
+var toString = {}.toString;
+
+module.exports = function(it){
+  return toString.call(it).slice(8, -1);
+};
+},{}],15:[function(require,module,exports){
+var core = module.exports = {version: '2.4.0'};
+if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
+},{}],16:[function(require,module,exports){
+// optional / simple context binding
+var aFunction = require('./_a-function');
+module.exports = function(fn, that, length){
+  aFunction(fn);
+  if(that === undefined)return fn;
+  switch(length){
+    case 1: return function(a){
+      return fn.call(that, a);
+    };
+    case 2: return function(a, b){
+      return fn.call(that, a, b);
+    };
+    case 3: return function(a, b, c){
+      return fn.call(that, a, b, c);
+    };
+  }
+  return function(/* ...args */){
+    return fn.apply(that, arguments);
+  };
+};
+},{"./_a-function":9}],17:[function(require,module,exports){
+// 7.2.1 RequireObjectCoercible(argument)
+module.exports = function(it){
+  if(it == undefined)throw TypeError("Can't call method on  " + it);
+  return it;
+};
+},{}],18:[function(require,module,exports){
+// Thank's IE8 for his funny defineProperty
+module.exports = !require('./_fails')(function(){
+  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
+});
+},{"./_fails":22}],19:[function(require,module,exports){
+var isObject = require('./_is-object')
+  , document = require('./_global').document
+  // in old IE typeof document.createElement is 'object'
+  , is = isObject(document) && isObject(document.createElement);
+module.exports = function(it){
+  return is ? document.createElement(it) : {};
+};
+},{"./_global":23,"./_is-object":29}],20:[function(require,module,exports){
+// IE 8- don't enum bug keys
+module.exports = (
+  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
+).split(',');
+},{}],21:[function(require,module,exports){
+var global    = require('./_global')
+  , core      = require('./_core')
+  , ctx       = require('./_ctx')
+  , hide      = require('./_hide')
+  , PROTOTYPE = 'prototype';
+
+var $export = function(type, name, source){
+  var IS_FORCED = type & $export.F
+    , IS_GLOBAL = type & $export.G
+    , IS_STATIC = type & $export.S
+    , IS_PROTO  = type & $export.P
+    , IS_BIND   = type & $export.B
+    , IS_WRAP   = type & $export.W
+    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})
+    , expProto  = exports[PROTOTYPE]
+    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]
+    , key, own, out;
+  if(IS_GLOBAL)source = name;
+  for(key in source){
+    // contains in native
+    own = !IS_FORCED && target && target[key] !== undefined;
+    if(own && key in exports)continue;
+    // export native or passed
+    out = own ? target[key] : source[key];
+    // prevent global pollution for namespaces
+    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
+    // bind timers to global for call from export context
+    : IS_BIND && own ? ctx(out, global)
+    // wrap global constructors for prevent change them in library
+    : IS_WRAP && target[key] == out ? (function(C){
+      var F = function(a, b, c){
+        if(this instanceof C){
+          switch(arguments.length){
+            case 0: return new C;
+            case 1: return new C(a);
+            case 2: return new C(a, b);
+          } return new C(a, b, c);
+        } return C.apply(this, arguments);
+      };
+      F[PROTOTYPE] = C[PROTOTYPE];
+      return F;
+    // make static versions for prototype methods
+    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
+    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
+    if(IS_PROTO){
+      (exports.virtual || (exports.virtual = {}))[key] = out;
+      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
+      if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);
+    }
+  }
+};
+// type bitmap
+$export.F = 1;   // forced
+$export.G = 2;   // global
+$export.S = 4;   // static
+$export.P = 8;   // proto
+$export.B = 16;  // bind
+$export.W = 32;  // wrap
+$export.U = 64;  // safe
+$export.R = 128; // real proto method for `library` 
+module.exports = $export;
+},{"./_core":15,"./_ctx":16,"./_global":23,"./_hide":25}],22:[function(require,module,exports){
+module.exports = function(exec){
+  try {
+    return !!exec();
+  } catch(e){
+    return true;
+  }
+};
+},{}],23:[function(require,module,exports){
+// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+var global = module.exports = typeof window != 'undefined' && window.Math == Math
+  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
+if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
+},{}],24:[function(require,module,exports){
+var hasOwnProperty = {}.hasOwnProperty;
+module.exports = function(it, key){
+  return hasOwnProperty.call(it, key);
+};
+},{}],25:[function(require,module,exports){
+var dP         = require('./_object-dp')
+  , createDesc = require('./_property-desc');
+module.exports = require('./_descriptors') ? function(object, key, value){
+  return dP.f(object, key, createDesc(1, value));
+} : function(object, key, value){
+  object[key] = value;
+  return object;
+};
+},{"./_descriptors":18,"./_object-dp":36,"./_property-desc":42}],26:[function(require,module,exports){
+module.exports = require('./_global').document && document.documentElement;
+},{"./_global":23}],27:[function(require,module,exports){
+module.exports = !require('./_descriptors') && !require('./_fails')(function(){
+  return Object.defineProperty(require('./_dom-create')('div'), 'a', {get: function(){ return 7; }}).a != 7;
+});
+},{"./_descriptors":18,"./_dom-create":19,"./_fails":22}],28:[function(require,module,exports){
+// fallback for non-array-like ES3 and non-enumerable old V8 strings
+var cof = require('./_cof');
+module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
+  return cof(it) == 'String' ? it.split('') : Object(it);
+};
+},{"./_cof":14}],29:[function(require,module,exports){
+module.exports = function(it){
+  return typeof it === 'object' ? it !== null : typeof it === 'function';
+};
+},{}],30:[function(require,module,exports){
+'use strict';
+var create         = require('./_object-create')
+  , descriptor     = require('./_property-desc')
+  , setToStringTag = require('./_set-to-string-tag')
+  , IteratorPrototype = {};
+
+// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
+require('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function(){ return this; });
+
+module.exports = function(Constructor, NAME, next){
+  Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});
+  setToStringTag(Constructor, NAME + ' Iterator');
+};
+},{"./_hide":25,"./_object-create":35,"./_property-desc":42,"./_set-to-string-tag":44,"./_wks":55}],31:[function(require,module,exports){
+'use strict';
+var LIBRARY        = require('./_library')
+  , $export        = require('./_export')
+  , redefine       = require('./_redefine')
+  , hide           = require('./_hide')
+  , has            = require('./_has')
+  , Iterators      = require('./_iterators')
+  , $iterCreate    = require('./_iter-create')
+  , setToStringTag = require('./_set-to-string-tag')
+  , getPrototypeOf = require('./_object-gpo')
+  , ITERATOR       = require('./_wks')('iterator')
+  , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`
+  , FF_ITERATOR    = '@@iterator'
+  , KEYS           = 'keys'
+  , VALUES         = 'values';
+
+var returnThis = function(){ return this; };
+
+module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){
+  $iterCreate(Constructor, NAME, next);
+  var getMethod = function(kind){
+    if(!BUGGY && kind in proto)return proto[kind];
+    switch(kind){
+      case KEYS: return function keys(){ return new Constructor(this, kind); };
+      case VALUES: return function values(){ return new Constructor(this, kind); };
+    } return function entries(){ return new Constructor(this, kind); };
+  };
+  var TAG        = NAME + ' Iterator'
+    , DEF_VALUES = DEFAULT == VALUES
+    , VALUES_BUG = false
+    , proto      = Base.prototype
+    , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]
+    , $default   = $native || getMethod(DEFAULT)
+    , $entries   = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined
+    , $anyNative = NAME == 'Array' ? proto.entries || $native : $native
+    , methods, key, IteratorPrototype;
+  // Fix native
+  if($anyNative){
+    IteratorPrototype = getPrototypeOf($anyNative.call(new Base));
+    if(IteratorPrototype !== Object.prototype){
+      // Set @@toStringTag to native iterators
+      setToStringTag(IteratorPrototype, TAG, true);
+      // fix for some old engines
+      if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);
+    }
+  }
+  // fix Array#{values, @@iterator}.name in V8 / FF
+  if(DEF_VALUES && $native && $native.name !== VALUES){
+    VALUES_BUG = true;
+    $default = function values(){ return $native.call(this); };
+  }
+  // Define iterator
+  if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){
+    hide(proto, ITERATOR, $default);
+  }
+  // Plug for library
+  Iterators[NAME] = $default;
+  Iterators[TAG]  = returnThis;
+  if(DEFAULT){
+    methods = {
+      values:  DEF_VALUES ? $default : getMethod(VALUES),
+      keys:    IS_SET     ? $default : getMethod(KEYS),
+      entries: $entries
+    };
+    if(FORCED)for(key in methods){
+      if(!(key in proto))redefine(proto, key, methods[key]);
+    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
+  }
+  return methods;
+};
+},{"./_export":21,"./_has":24,"./_hide":25,"./_iter-create":30,"./_iterators":33,"./_library":34,"./_object-gpo":38,"./_redefine":43,"./_set-to-string-tag":44,"./_wks":55}],32:[function(require,module,exports){
+module.exports = function(done, value){
+  return {value: value, done: !!done};
+};
+},{}],33:[function(require,module,exports){
+module.exports = {};
+},{}],34:[function(require,module,exports){
+module.exports = true;
+},{}],35:[function(require,module,exports){
+// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
+var anObject    = require('./_an-object')
+  , dPs         = require('./_object-dps')
+  , enumBugKeys = require('./_enum-bug-keys')
+  , IE_PROTO    = require('./_shared-key')('IE_PROTO')
+  , Empty       = function(){ /* empty */ }
+  , PROTOTYPE   = 'prototype';
+
+// Create object with fake `null` prototype: use iframe Object with cleared prototype
+var createDict = function(){
+  // Thrash, waste and sodomy: IE GC bug
+  var iframe = require('./_dom-create')('iframe')
+    , i      = enumBugKeys.length
+    , gt     = '>'
+    , iframeDocument;
+  iframe.style.display = 'none';
+  require('./_html').appendChild(iframe);
+  iframe.src = 'javascript:'; // eslint-disable-line no-script-url
+  // createDict = iframe.contentWindow.Object;
+  // html.removeChild(iframe);
+  iframeDocument = iframe.contentWindow.document;
+  iframeDocument.open();
+  iframeDocument.write('<script>document.F=Object</script' + gt);
+  iframeDocument.close();
+  createDict = iframeDocument.F;
+  while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];
+  return createDict();
+};
+
+module.exports = Object.create || function create(O, Properties){
+  var result;
+  if(O !== null){
+    Empty[PROTOTYPE] = anObject(O);
+    result = new Empty;
+    Empty[PROTOTYPE] = null;
+    // add "__proto__" for Object.getPrototypeOf polyfill
+    result[IE_PROTO] = O;
+  } else result = createDict();
+  return Properties === undefined ? result : dPs(result, Properties);
+};
+},{"./_an-object":11,"./_dom-create":19,"./_enum-bug-keys":20,"./_html":26,"./_object-dps":37,"./_shared-key":45}],36:[function(require,module,exports){
+var anObject       = require('./_an-object')
+  , IE8_DOM_DEFINE = require('./_ie8-dom-define')
+  , toPrimitive    = require('./_to-primitive')
+  , dP             = Object.defineProperty;
+
+exports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes){
+  anObject(O);
+  P = toPrimitive(P, true);
+  anObject(Attributes);
+  if(IE8_DOM_DEFINE)try {
+    return dP(O, P, Attributes);
+  } catch(e){ /* empty */ }
+  if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');
+  if('value' in Attributes)O[P] = Attributes.value;
+  return O;
+};
+},{"./_an-object":11,"./_descriptors":18,"./_ie8-dom-define":27,"./_to-primitive":53}],37:[function(require,module,exports){
+var dP       = require('./_object-dp')
+  , anObject = require('./_an-object')
+  , getKeys  = require('./_object-keys');
+
+module.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties){
+  anObject(O);
+  var keys   = getKeys(Properties)
+    , length = keys.length
+    , i = 0
+    , P;
+  while(length > i)dP.f(O, P = keys[i++], Properties[P]);
+  return O;
+};
+},{"./_an-object":11,"./_descriptors":18,"./_object-dp":36,"./_object-keys":40}],38:[function(require,module,exports){
+// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
+var has         = require('./_has')
+  , toObject    = require('./_to-object')
+  , IE_PROTO    = require('./_shared-key')('IE_PROTO')
+  , ObjectProto = Object.prototype;
+
+module.exports = Object.getPrototypeOf || function(O){
+  O = toObject(O);
+  if(has(O, IE_PROTO))return O[IE_PROTO];
+  if(typeof O.constructor == 'function' && O instanceof O.constructor){
+    return O.constructor.prototype;
+  } return O instanceof Object ? ObjectProto : null;
+};
+},{"./_has":24,"./_shared-key":45,"./_to-object":52}],39:[function(require,module,exports){
+var has          = require('./_has')
+  , toIObject    = require('./_to-iobject')
+  , arrayIndexOf = require('./_array-includes')(false)
+  , IE_PROTO     = require('./_shared-key')('IE_PROTO');
+
+module.exports = function(object, names){
+  var O      = toIObject(object)
+    , i      = 0
+    , result = []
+    , key;
+  for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);
+  // Don't enum bug & hidden keys
+  while(names.length > i)if(has(O, key = names[i++])){
+    ~arrayIndexOf(result, key) || result.push(key);
+  }
+  return result;
+};
+},{"./_array-includes":12,"./_has":24,"./_shared-key":45,"./_to-iobject":50}],40:[function(require,module,exports){
+// 19.1.2.14 / 15.2.3.14 Object.keys(O)
+var $keys       = require('./_object-keys-internal')
+  , enumBugKeys = require('./_enum-bug-keys');
+
+module.exports = Object.keys || function keys(O){
+  return $keys(O, enumBugKeys);
+};
+},{"./_enum-bug-keys":20,"./_object-keys-internal":39}],41:[function(require,module,exports){
+// most Object methods by ES6 should accept primitives
+var $export = require('./_export')
+  , core    = require('./_core')
+  , fails   = require('./_fails');
+module.exports = function(KEY, exec){
+  var fn  = (core.Object || {})[KEY] || Object[KEY]
+    , exp = {};
+  exp[KEY] = exec(fn);
+  $export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);
+};
+},{"./_core":15,"./_export":21,"./_fails":22}],42:[function(require,module,exports){
+module.exports = function(bitmap, value){
+  return {
+    enumerable  : !(bitmap & 1),
+    configurable: !(bitmap & 2),
+    writable    : !(bitmap & 4),
+    value       : value
+  };
+};
+},{}],43:[function(require,module,exports){
+module.exports = require('./_hide');
+},{"./_hide":25}],44:[function(require,module,exports){
+var def = require('./_object-dp').f
+  , has = require('./_has')
+  , TAG = require('./_wks')('toStringTag');
+
+module.exports = function(it, tag, stat){
+  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
+};
+},{"./_has":24,"./_object-dp":36,"./_wks":55}],45:[function(require,module,exports){
+var shared = require('./_shared')('keys')
+  , uid    = require('./_uid');
+module.exports = function(key){
+  return shared[key] || (shared[key] = uid(key));
+};
+},{"./_shared":46,"./_uid":54}],46:[function(require,module,exports){
+var global = require('./_global')
+  , SHARED = '__core-js_shared__'
+  , store  = global[SHARED] || (global[SHARED] = {});
+module.exports = function(key){
+  return store[key] || (store[key] = {});
+};
+},{"./_global":23}],47:[function(require,module,exports){
+var toInteger = require('./_to-integer')
+  , defined   = require('./_defined');
+// true  -> String#at
+// false -> String#codePointAt
+module.exports = function(TO_STRING){
+  return function(that, pos){
+    var s = String(defined(that))
+      , i = toInteger(pos)
+      , l = s.length
+      , a, b;
+    if(i < 0 || i >= l)return TO_STRING ? '' : undefined;
+    a = s.charCodeAt(i);
+    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
+      ? TO_STRING ? s.charAt(i) : a
+      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
+  };
+};
+},{"./_defined":17,"./_to-integer":49}],48:[function(require,module,exports){
+var toInteger = require('./_to-integer')
+  , max       = Math.max
+  , min       = Math.min;
+module.exports = function(index, length){
+  index = toInteger(index);
+  return index < 0 ? max(index + length, 0) : min(index, length);
+};
+},{"./_to-integer":49}],49:[function(require,module,exports){
+// 7.1.4 ToInteger
+var ceil  = Math.ceil
+  , floor = Math.floor;
+module.exports = function(it){
+  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
+};
+},{}],50:[function(require,module,exports){
+// to indexed object, toObject with fallback for non-array-like ES3 strings
+var IObject = require('./_iobject')
+  , defined = require('./_defined');
+module.exports = function(it){
+  return IObject(defined(it));
+};
+},{"./_defined":17,"./_iobject":28}],51:[function(require,module,exports){
+// 7.1.15 ToLength
+var toInteger = require('./_to-integer')
+  , min       = Math.min;
+module.exports = function(it){
+  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
+};
+},{"./_to-integer":49}],52:[function(require,module,exports){
+// 7.1.13 ToObject(argument)
+var defined = require('./_defined');
+module.exports = function(it){
+  return Object(defined(it));
+};
+},{"./_defined":17}],53:[function(require,module,exports){
+// 7.1.1 ToPrimitive(input [, PreferredType])
+var isObject = require('./_is-object');
+// instead of the ES6 spec version, we didn't implement @@toPrimitive case
+// and the second argument - flag - preferred type is a string
+module.exports = function(it, S){
+  if(!isObject(it))return it;
+  var fn, val;
+  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
+  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;
+  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
+  throw TypeError("Can't convert object to primitive value");
+};
+},{"./_is-object":29}],54:[function(require,module,exports){
+var id = 0
+  , px = Math.random();
+module.exports = function(key){
+  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
+};
+},{}],55:[function(require,module,exports){
+var store      = require('./_shared')('wks')
+  , uid        = require('./_uid')
+  , Symbol     = require('./_global').Symbol
+  , USE_SYMBOL = typeof Symbol == 'function';
+
+var $exports = module.exports = function(name){
+  return store[name] || (store[name] =
+    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
+};
+
+$exports.store = store;
+},{"./_global":23,"./_shared":46,"./_uid":54}],56:[function(require,module,exports){
+var classof   = require('./_classof')
+  , ITERATOR  = require('./_wks')('iterator')
+  , Iterators = require('./_iterators');
+module.exports = require('./_core').getIteratorMethod = function(it){
+  if(it != undefined)return it[ITERATOR]
+    || it['@@iterator']
+    || Iterators[classof(it)];
+};
+},{"./_classof":13,"./_core":15,"./_iterators":33,"./_wks":55}],57:[function(require,module,exports){
+var anObject = require('./_an-object')
+  , get      = require('./core.get-iterator-method');
+module.exports = require('./_core').getIterator = function(it){
+  var iterFn = get(it);
+  if(typeof iterFn != 'function')throw TypeError(it + ' is not iterable!');
+  return anObject(iterFn.call(it));
+};
+},{"./_an-object":11,"./_core":15,"./core.get-iterator-method":56}],58:[function(require,module,exports){
+'use strict';
+var addToUnscopables = require('./_add-to-unscopables')
+  , step             = require('./_iter-step')
+  , Iterators        = require('./_iterators')
+  , toIObject        = require('./_to-iobject');
+
+// 22.1.3.4 Array.prototype.entries()
+// 22.1.3.13 Array.prototype.keys()
+// 22.1.3.29 Array.prototype.values()
+// 22.1.3.30 Array.prototype[@@iterator]()
+module.exports = require('./_iter-define')(Array, 'Array', function(iterated, kind){
+  this._t = toIObject(iterated); // target
+  this._i = 0;                   // next index
+  this._k = kind;                // kind
+// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
+}, function(){
+  var O     = this._t
+    , kind  = this._k
+    , index = this._i++;
+  if(!O || index >= O.length){
+    this._t = undefined;
+    return step(1);
+  }
+  if(kind == 'keys'  )return step(0, index);
+  if(kind == 'values')return step(0, O[index]);
+  return step(0, [index, O[index]]);
+}, 'values');
+
+// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
+Iterators.Arguments = Iterators.Array;
+
+addToUnscopables('keys');
+addToUnscopables('values');
+addToUnscopables('entries');
+},{"./_add-to-unscopables":10,"./_iter-define":31,"./_iter-step":32,"./_iterators":33,"./_to-iobject":50}],59:[function(require,module,exports){
+// 19.1.2.14 Object.keys(O)
+var toObject = require('./_to-object')
+  , $keys    = require('./_object-keys');
+
+require('./_object-sap')('keys', function(){
+  return function keys(it){
+    return $keys(toObject(it));
+  };
+});
+},{"./_object-keys":40,"./_object-sap":41,"./_to-object":52}],60:[function(require,module,exports){
+'use strict';
+var $at  = require('./_string-at')(true);
+
+// 21.1.3.27 String.prototype[@@iterator]()
+require('./_iter-define')(String, 'String', function(iterated){
+  this._t = String(iterated); // target
+  this._i = 0;                // next index
+// 21.1.5.2.1 %StringIteratorPrototype%.next()
+}, function(){
+  var O     = this._t
+    , index = this._i
+    , point;
+  if(index >= O.length)return {value: undefined, done: true};
+  point = $at(O, index);
+  this._i += point.length;
+  return {value: point, done: false};
+});
+},{"./_iter-define":31,"./_string-at":47}],61:[function(require,module,exports){
+require('./es6.array.iterator');
+var global        = require('./_global')
+  , hide          = require('./_hide')
+  , Iterators     = require('./_iterators')
+  , TO_STRING_TAG = require('./_wks')('toStringTag');
+
+for(var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++){
+  var NAME       = collections[i]
+    , Collection = global[NAME]
+    , proto      = Collection && Collection.prototype;
+  if(proto && !proto[TO_STRING_TAG])hide(proto, TO_STRING_TAG, NAME);
+  Iterators[NAME] = Iterators.Array;
+}
+},{"./_global":23,"./_hide":25,"./_iterators":33,"./_wks":55,"./es6.array.iterator":58}],62:[function(require,module,exports){
+(function (global){
+// This method of obtaining a reference to the global object needs to be
+// kept identical to the way it is obtained in runtime.js
+var g =
+  typeof global === "object" ? global :
+  typeof window === "object" ? window :
+  typeof self === "object" ? self : this;
+
+// Use `getOwnPropertyNames` because not all browsers support calling
+// `hasOwnProperty` on the global `self` object in a worker. See #183.
+var hadRuntime = g.regeneratorRuntime &&
+  Object.getOwnPropertyNames(g).indexOf("regeneratorRuntime") >= 0;
+
+// Save the old regeneratorRuntime in case it needs to be restored later.
+var oldRuntime = hadRuntime && g.regeneratorRuntime;
+
+// Force reevalutation of runtime.js.
+g.regeneratorRuntime = undefined;
+
+module.exports = require("./runtime");
+
+if (hadRuntime) {
+  // Restore the original runtime.
+  g.regeneratorRuntime = oldRuntime;
+} else {
+  // Remove the global property added by runtime.js.
+  try {
+    delete g.regeneratorRuntime;
+  } catch(e) {
+    g.regeneratorRuntime = undefined;
+  }
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./runtime":63}],63:[function(require,module,exports){
+(function (process,global){
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+!(function(global) {
+  "use strict";
+
+  var hasOwn = Object.prototype.hasOwnProperty;
+  var undefined; // More compressible than void 0.
+  var $Symbol = typeof Symbol === "function" ? Symbol : {};
+  var iteratorSymbol = $Symbol.iterator || "@@iterator";
+  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+  var inModule = typeof module === "object";
+  var runtime = global.regeneratorRuntime;
+  if (runtime) {
+    if (inModule) {
+      // If regeneratorRuntime is defined globally and we're in a module,
+      // make the exports object identical to regeneratorRuntime.
+      module.exports = runtime;
+    }
+    // Don't bother evaluating the rest of this file if the runtime was
+    // already defined globally.
+    return;
+  }
+
+  // Define the runtime globally (as expected by generated code) as either
+  // module.exports (if we're in a module) or a new, empty object.
+  runtime = global.regeneratorRuntime = inModule ? module.exports : {};
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    // If outerFn provided, then outerFn.prototype instanceof Generator.
+    var generator = Object.create((outerFn || Generator).prototype);
+    var context = new Context(tryLocsList || []);
+
+    // The ._invoke method unifies the implementations of the .next,
+    // .throw, and .return methods.
+    generator._invoke = makeInvokeMethod(innerFn, self, context);
+
+    return generator;
+  }
+  runtime.wrap = wrap;
+
+  // Try/catch helper to minimize deoptimizations. Returns a completion
+  // record like context.tryEntries[i].completion. This interface could
+  // have been (and was previously) designed to take a closure to be
+  // invoked without arguments, but in all the cases we care about we
+  // already have an existing method we want to call, so there's no need
+  // to create a new function object. We can even get away with assuming
+  // the method takes exactly one argument, since that happens to be true
+  // in every case, so we don't have to touch the arguments object. The
+  // only additional allocation required is the completion record, which
+  // has a stable shape and so hopefully should be cheap to allocate.
+  function tryCatch(fn, obj, arg) {
+    try {
+      return { type: "normal", arg: fn.call(obj, arg) };
+    } catch (err) {
+      return { type: "throw", arg: err };
+    }
+  }
+
+  var GenStateSuspendedStart = "suspendedStart";
+  var GenStateSuspendedYield = "suspendedYield";
+  var GenStateExecuting = "executing";
+  var GenStateCompleted = "completed";
+
+  // Returning this object from the innerFn has the same effect as
+  // breaking out of the dispatch switch statement.
+  var ContinueSentinel = {};
+
+  // Dummy constructor functions that we use as the .constructor and
+  // .constructor.prototype properties for functions that return Generator
+  // objects. For full spec compliance, you may wish to configure your
+  // minifier not to mangle the names of these two functions.
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype;
+  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
+  GeneratorFunctionPrototype.constructor = GeneratorFunction;
+  GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = "GeneratorFunction";
+
+  // Helper for defining the .next, .throw, and .return methods of the
+  // Iterator interface in terms of a single ._invoke method.
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function(method) {
+      prototype[method] = function(arg) {
+        return this._invoke(method, arg);
+      };
+    });
+  }
+
+  runtime.isGeneratorFunction = function(genFun) {
+    var ctor = typeof genFun === "function" && genFun.constructor;
+    return ctor
+      ? ctor === GeneratorFunction ||
+        // For the native GeneratorFunction constructor, the best we can
+        // do is to check its .name property.
+        (ctor.displayName || ctor.name) === "GeneratorFunction"
+      : false;
+  };
+
+  runtime.mark = function(genFun) {
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+    } else {
+      genFun.__proto__ = GeneratorFunctionPrototype;
+      if (!(toStringTagSymbol in genFun)) {
+        genFun[toStringTagSymbol] = "GeneratorFunction";
+      }
+    }
+    genFun.prototype = Object.create(Gp);
+    return genFun;
+  };
+
+  // Within the body of any async function, `await x` is transformed to
+  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
+  // `value instanceof AwaitArgument` to determine if the yielded value is
+  // meant to be awaited. Some may consider the name of this method too
+  // cutesy, but they are curmudgeons.
+  runtime.awrap = function(arg) {
+    return new AwaitArgument(arg);
+  };
+
+  function AwaitArgument(arg) {
+    this.arg = arg;
+  }
+
+  function AsyncIterator(generator) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+      if (record.type === "throw") {
+        reject(record.arg);
+      } else {
+        var result = record.arg;
+        var value = result.value;
+        if (value instanceof AwaitArgument) {
+          return Promise.resolve(value.arg).then(function(value) {
+            invoke("next", value, resolve, reject);
+          }, function(err) {
+            invoke("throw", err, resolve, reject);
+          });
+        }
+
+        return Promise.resolve(value).then(function(unwrapped) {
+          // When a yielded Promise is resolved, its final value becomes
+          // the .value of the Promise<{value,done}> result for the
+          // current iteration. If the Promise is rejected, however, the
+          // result for this iteration will be rejected with the same
+          // reason. Note that rejections of yielded Promises are not
+          // thrown back into the generator function, as is the case
+          // when an awaited Promise is rejected. This difference in
+          // behavior between yield and await is important, because it
+          // allows the consumer to decide what to do with the yielded
+          // rejection (swallow it and continue, manually .throw it back
+          // into the generator, abandon iteration, whatever). With
+          // await, by contrast, there is no opportunity to examine the
+          // rejection reason outside the generator function, so the
+          // only option is to throw it from the await expression, and
+          // let the generator function handle the exception.
+          result.value = unwrapped;
+          resolve(result);
+        }, reject);
+      }
+    }
+
+    if (typeof process === "object" && process.domain) {
+      invoke = process.domain.bind(invoke);
+    }
+
+    var previousPromise;
+
+    function enqueue(method, arg) {
+      function callInvokeWithMethodAndArg() {
+        return new Promise(function(resolve, reject) {
+          invoke(method, arg, resolve, reject);
+        });
+      }
+
+      return previousPromise =
+        // If enqueue has been called before, then we want to wait until
+        // all previous Promises have been resolved before calling invoke,
+        // so that results are always delivered in the correct order. If
+        // enqueue has not been called before, then it is important to
+        // call invoke immediately, without waiting on a callback to fire,
+        // so that the async generator function has the opportunity to do
+        // any necessary setup in a predictable way. This predictability
+        // is why the Promise constructor synchronously invokes its
+        // executor callback, and why async functions synchronously
+        // execute code before the first await. Since we implement simple
+        // async functions in terms of async generators, it is especially
+        // important to get this right, even though it requires care.
+        previousPromise ? previousPromise.then(
+          callInvokeWithMethodAndArg,
+          // Avoid propagating failures to Promises returned by later
+          // invocations of the iterator.
+          callInvokeWithMethodAndArg
+        ) : callInvokeWithMethodAndArg();
+    }
+
+    // Define the unified helper method that is used to implement .next,
+    // .throw, and .return (see defineIteratorMethods).
+    this._invoke = enqueue;
+  }
+
+  defineIteratorMethods(AsyncIterator.prototype);
+
+  // Note that simple async functions are implemented on top of
+  // AsyncIterator objects; they just return a Promise for the value of
+  // the final result produced by the iterator.
+  runtime.async = function(innerFn, outerFn, self, tryLocsList) {
+    var iter = new AsyncIterator(
+      wrap(innerFn, outerFn, self, tryLocsList)
+    );
+
+    return runtime.isGeneratorFunction(outerFn)
+      ? iter // If outerFn is a generator, return the full iterator.
+      : iter.next().then(function(result) {
+          return result.done ? result.value : iter.next();
+        });
+  };
+
+  function makeInvokeMethod(innerFn, self, context) {
+    var state = GenStateSuspendedStart;
+
+    return function invoke(method, arg) {
+      if (state === GenStateExecuting) {
+        throw new Error("Generator is already running");
+      }
+
+      if (state === GenStateCompleted) {
+        if (method === "throw") {
+          throw arg;
+        }
+
+        // Be forgiving, per 25.3.3.3.3 of the spec:
+        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+        return doneResult();
+      }
+
+      while (true) {
+        var delegate = context.delegate;
+        if (delegate) {
+          if (method === "return" ||
+              (method === "throw" && delegate.iterator[method] === undefined)) {
+            // A return or throw (when the delegate iterator has no throw
+            // method) always terminates the yield* loop.
+            context.delegate = null;
+
+            // If the delegate iterator has a return method, give it a
+            // chance to clean up.
+            var returnMethod = delegate.iterator["return"];
+            if (returnMethod) {
+              var record = tryCatch(returnMethod, delegate.iterator, arg);
+              if (record.type === "throw") {
+                // If the return method threw an exception, let that
+                // exception prevail over the original return or throw.
+                method = "throw";
+                arg = record.arg;
+                continue;
+              }
+            }
+
+            if (method === "return") {
+              // Continue with the outer return, now that the delegate
+              // iterator has been terminated.
+              continue;
+            }
+          }
+
+          var record = tryCatch(
+            delegate.iterator[method],
+            delegate.iterator,
+            arg
+          );
+
+          if (record.type === "throw") {
+            context.delegate = null;
+
+            // Like returning generator.throw(uncaught), but without the
+            // overhead of an extra function call.
+            method = "throw";
+            arg = record.arg;
+            continue;
+          }
+
+          // Delegate generator ran and handled its own exceptions so
+          // regardless of what the method was, we continue as if it is
+          // "next" with an undefined arg.
+          method = "next";
+          arg = undefined;
+
+          var info = record.arg;
+          if (info.done) {
+            context[delegate.resultName] = info.value;
+            context.next = delegate.nextLoc;
+          } else {
+            state = GenStateSuspendedYield;
+            return info;
+          }
+
+          context.delegate = null;
+        }
+
+        if (method === "next") {
+          // Setting context._sent for legacy support of Babel's
+          // function.sent implementation.
+          context.sent = context._sent = arg;
+
+        } else if (method === "throw") {
+          if (state === GenStateSuspendedStart) {
+            state = GenStateCompleted;
+            throw arg;
+          }
+
+          if (context.dispatchException(arg)) {
+            // If the dispatched exception was caught by a catch block,
+            // then let that catch block handle the exception normally.
+            method = "next";
+            arg = undefined;
+          }
+
+        } else if (method === "return") {
+          context.abrupt("return", arg);
+        }
+
+        state = GenStateExecuting;
+
+        var record = tryCatch(innerFn, self, context);
+        if (record.type === "normal") {
+          // If an exception is thrown from innerFn, we leave state ===
+          // GenStateExecuting and loop back for another invocation.
+          state = context.done
+            ? GenStateCompleted
+            : GenStateSuspendedYield;
+
+          var info = {
+            value: record.arg,
+            done: context.done
+          };
+
+          if (record.arg === ContinueSentinel) {
+            if (context.delegate && method === "next") {
+              // Deliberately forget the last sent value so that we don't
+              // accidentally pass it on to the delegate.
+              arg = undefined;
+            }
+          } else {
+            return info;
+          }
+
+        } else if (record.type === "throw") {
+          state = GenStateCompleted;
+          // Dispatch the exception by looping back around to the
+          // context.dispatchException(arg) call above.
+          method = "throw";
+          arg = record.arg;
+        }
+      }
+    };
+  }
+
+  // Define Generator.prototype.{next,throw,return} in terms of the
+  // unified ._invoke helper method.
+  defineIteratorMethods(Gp);
+
+  Gp[iteratorSymbol] = function() {
+    return this;
+  };
+
+  Gp[toStringTagSymbol] = "Generator";
+
+  Gp.toString = function() {
+    return "[object Generator]";
+  };
+
+  function pushTryEntry(locs) {
+    var entry = { tryLoc: locs[0] };
+
+    if (1 in locs) {
+      entry.catchLoc = locs[1];
+    }
+
+    if (2 in locs) {
+      entry.finallyLoc = locs[2];
+      entry.afterLoc = locs[3];
+    }
+
+    this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal";
+    delete record.arg;
+    entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    // The root entry object (effectively a try statement without a catch
+    // or a finally block) gives us a place to store values thrown from
+    // locations where there is no enclosing try statement.
+    this.tryEntries = [{ tryLoc: "root" }];
+    tryLocsList.forEach(pushTryEntry, this);
+    this.reset(true);
+  }
+
+  runtime.keys = function(object) {
+    var keys = [];
+    for (var key in object) {
+      keys.push(key);
+    }
+    keys.reverse();
+
+    // Rather than returning an object with a next method, we keep
+    // things simple and return the next function itself.
+    return function next() {
+      while (keys.length) {
+        var key = keys.pop();
+        if (key in object) {
+          next.value = key;
+          next.done = false;
+          return next;
+        }
+      }
+
+      // To avoid creating an additional object, we just hang the .value
+      // and .done properties off the next function object itself. This
+      // also ensures that the minifier will not anonymize the function.
+      next.done = true;
+      return next;
+    };
+  };
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) {
+        return iteratorMethod.call(iterable);
+      }
+
+      if (typeof iterable.next === "function") {
+        return iterable;
+      }
+
+      if (!isNaN(iterable.length)) {
+        var i = -1, next = function next() {
+          while (++i < iterable.length) {
+            if (hasOwn.call(iterable, i)) {
+              next.value = iterable[i];
+              next.done = false;
+              return next;
+            }
+          }
+
+          next.value = undefined;
+          next.done = true;
+
+          return next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    // Return an iterator with no values.
+    return { next: doneResult };
+  }
+  runtime.values = values;
+
+  function doneResult() {
+    return { value: undefined, done: true };
+  }
+
+  Context.prototype = {
+    constructor: Context,
+
+    reset: function(skipTempReset) {
+      this.prev = 0;
+      this.next = 0;
+      // Resetting context._sent for legacy support of Babel's
+      // function.sent implementation.
+      this.sent = this._sent = undefined;
+      this.done = false;
+      this.delegate = null;
+
+      this.tryEntries.forEach(resetTryEntry);
+
+      if (!skipTempReset) {
+        for (var name in this) {
+          // Not sure about the optimal order of these conditions:
+          if (name.charAt(0) === "t" &&
+              hasOwn.call(this, name) &&
+              !isNaN(+name.slice(1))) {
+            this[name] = undefined;
+          }
+        }
+      }
+    },
+
+    stop: function() {
+      this.done = true;
+
+      var rootEntry = this.tryEntries[0];
+      var rootRecord = rootEntry.completion;
+      if (rootRecord.type === "throw") {
+        throw rootRecord.arg;
+      }
+
+      return this.rval;
+    },
+
+    dispatchException: function(exception) {
+      if (this.done) {
+        throw exception;
+      }
+
+      var context = this;
+      function handle(loc, caught) {
+        record.type = "throw";
+        record.arg = exception;
+        context.next = loc;
+        return !!caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        var record = entry.completion;
+
+        if (entry.tryLoc === "root") {
+          // Exception thrown outside of any try block that could handle
+          // it, so set the completion value of the entire function to
+          // throw the exception.
+          return handle("end");
+        }
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc");
+          var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            } else if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            }
+
+          } else if (hasFinally) {
+            if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+
+          } else {
+            throw new Error("try statement without catch or finally");
+          }
+        }
+      }
+    },
+
+    abrupt: function(type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc <= this.prev &&
+            hasOwn.call(entry, "finallyLoc") &&
+            this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+
+      if (finallyEntry &&
+          (type === "break" ||
+           type === "continue") &&
+          finallyEntry.tryLoc <= arg &&
+          arg <= finallyEntry.finallyLoc) {
+        // Ignore the finally entry if control is not jumping to a
+        // location outside the try/catch block.
+        finallyEntry = null;
+      }
+
+      var record = finallyEntry ? finallyEntry.completion : {};
+      record.type = type;
+      record.arg = arg;
+
+      if (finallyEntry) {
+        this.next = finallyEntry.finallyLoc;
+      } else {
+        this.complete(record);
+      }
+
+      return ContinueSentinel;
+    },
+
+    complete: function(record, afterLoc) {
+      if (record.type === "throw") {
+        throw record.arg;
+      }
+
+      if (record.type === "break" ||
+          record.type === "continue") {
+        this.next = record.arg;
+      } else if (record.type === "return") {
+        this.rval = record.arg;
+        this.next = "end";
+      } else if (record.type === "normal" && afterLoc) {
+        this.next = afterLoc;
+      }
+    },
+
+    finish: function(finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) {
+          this.complete(entry.completion, entry.afterLoc);
+          resetTryEntry(entry);
+          return ContinueSentinel;
+        }
+      }
+    },
+
+    "catch": function(tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+          if (record.type === "throw") {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+          return thrown;
+        }
+      }
+
+      // The context.catch method must only be called with a location
+      // argument that corresponds to a known catch block.
+      throw new Error("illegal catch attempt");
+    },
+
+    delegateYield: function(iterable, resultName, nextLoc) {
+      this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      };
+
+      return ContinueSentinel;
+    }
+  };
+})(
+  // Among the various tricks for obtaining a reference to the global
+  // object, this seems to be the most reliable technique that does not
+  // use indirect eval (which violates Content Security Policy).
+  typeof global === "object" ? global :
+  typeof window === "object" ? window :
+  typeof self === "object" ? self : this
+);
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"_process":1}]},{},[2])
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../.nvm/versions/node/v6.2.2/lib/node_modules/watchify/node_modules/browser-pack/_prelude.js","../../.nvm/versions/node/v6.2.2/lib/node_modules/watchify/node_modules/process/browser.js","index.js","lib/pheasant.js","node_modules/babel-runtime/core-js/get-iterator.js","node_modules/babel-runtime/core-js/object/keys.js","node_modules/babel-runtime/regenerator/index.js","node_modules/core-js/library/fn/get-iterator.js","node_modules/core-js/library/fn/object/keys.js","node_modules/core-js/library/modules/_a-function.js","node_modules/core-js/library/modules/_add-to-unscopables.js","node_modules/core-js/library/modules/_an-object.js","node_modules/core-js/library/modules/_array-includes.js","node_modules/core-js/library/modules/_classof.js","node_modules/core-js/library/modules/_cof.js","node_modules/core-js/library/modules/_core.js","node_modules/core-js/library/modules/_ctx.js","node_modules/core-js/library/modules/_defined.js","node_modules/core-js/library/modules/_descriptors.js","node_modules/core-js/library/modules/_dom-create.js","node_modules/core-js/library/modules/_enum-bug-keys.js","node_modules/core-js/library/modules/_export.js","node_modules/core-js/library/modules/_fails.js","node_modules/core-js/library/modules/_global.js","node_modules/core-js/library/modules/_has.js","node_modules/core-js/library/modules/_hide.js","node_modules/core-js/library/modules/_html.js","node_modules/core-js/library/modules/_ie8-dom-define.js","node_modules/core-js/library/modules/_iobject.js","node_modules/core-js/library/modules/_is-object.js","node_modules/core-js/library/modules/_iter-create.js","node_modules/core-js/library/modules/_iter-define.js","node_modules/core-js/library/modules/_iter-step.js","node_modules/core-js/library/modules/_iterators.js","node_modules/core-js/library/modules/_library.js","node_modules/core-js/library/modules/_object-create.js","node_modules/core-js/library/modules/_object-dp.js","node_modules/core-js/library/modules/_object-dps.js","node_modules/core-js/library/modules/_object-gpo.js","node_modules/core-js/library/modules/_object-keys-internal.js","node_modules/core-js/library/modules/_object-keys.js","node_modules/core-js/library/modules/_object-sap.js","node_modules/core-js/library/modules/_property-desc.js","node_modules/core-js/library/modules/_redefine.js","node_modules/core-js/library/modules/_set-to-string-tag.js","node_modules/core-js/library/modules/_shared-key.js","node_modules/core-js/library/modules/_shared.js","node_modules/core-js/library/modules/_string-at.js","node_modules/core-js/library/modules/_to-index.js","node_modules/core-js/library/modules/_to-integer.js","node_modules/core-js/library/modules/_to-iobject.js","node_modules/core-js/library/modules/_to-length.js","node_modules/core-js/library/modules/_to-object.js","node_modules/core-js/library/modules/_to-primitive.js","node_modules/core-js/library/modules/_uid.js","node_modules/core-js/library/modules/_wks.js","node_modules/core-js/library/modules/core.get-iterator-method.js","node_modules/core-js/library/modules/core.get-iterator.js","node_modules/core-js/library/modules/es6.array.iterator.js","node_modules/core-js/library/modules/es6.object.keys.js","node_modules/core-js/library/modules/es6.string.iterator.js","node_modules/core-js/library/modules/web.dom.iterable.js","node_modules/regenerator-runtime/runtime-module.js","node_modules/regenerator-runtime/runtime.js"],"names":[],"mappings":"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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5DA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;;ACAA;AACA;AACA;;ACFA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrEA;AACA;AACA;;ACFA;;ACAA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACh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file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","// shim for using process in browser\n\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\n(function () {\n  try {\n    cachedSetTimeout = setTimeout;\n  } catch (e) {\n    cachedSetTimeout = function () {\n      throw new Error('setTimeout is not defined');\n    }\n  }\n  try {\n    cachedClearTimeout = clearTimeout;\n  } catch (e) {\n    cachedClearTimeout = function () {\n      throw new Error('clearTimeout is not defined');\n    }\n  }\n} ())\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = cachedSetTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    cachedClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        cachedSetTimeout(drainQueue, 0);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","const pheasant = require('./lib/pheasant.js');\n\nconst req = new XMLHttpRequest();\n\nreq.overrideMimeType('application/json');\nreq.open('GET', 'data/daily-crime-2010-2015.json', true);\n\nreq.onreadystatechange = () => {\n  if (req.readyState === 4 && req.status === 200) {\n    pheasant.visualize(JSON.parse(req.responseText), 'canvas_goes_here');\n  }\n}\n\n// Fetch the data\nwindow.onload = () => req.send(null);\n\n","// Create heat map data visualization\n\n// Creates the visualization\nfunction visualize(data, domElementId, opts) {\n  \n  let options = {\n    minColor: 0xfbfbfb,\n    maxColor: 0x606060,\n    numSteps: 10,\n    cellWidth: 6,\n    cellHeight: 6,\n    cellSpacing: 2\n  }\n\n  const element = document.getElementById(domElementId);\n  const canvas = createCanvas(365 * options.cellWidth, 1000);\n  element.appendChild(canvas);\n  const context = canvas.getContext('2d');\n\n  const stepColors = calculateColorSteps(options.minColor, options.maxColor, options.numSteps);\n  const valueSteps = calculateValueSteps(data, options.numSteps);\n\n  console.log(valueSteps)\n\n  // Ensure the data is keyed by Epoch time values - easier to work with\n  data = ensureEpochKeys(data);\n\n  // Find start and end keys\n  let {start, end} = findStartAndEndTimes(data);\n\n  let x = 0, y = 0, yearOffset = 0;\n  const w = options.cellWidth, h = options.cellHeight; // TODO dynamically calculate these from the time dimensions\n\n  for (let year of eachYear(parseInt(start), parseInt(end))) {\n    // Set x back to 0, and move y down if needed\n    x = 0;\n\n    for (let day of eachDay(year)) {\n      // Set x over one and move y back up to the year offset\n      y = yearOffset;\n\n      for (let hour of eachHour(day)) {\n        // Draw the block onto the canvas\n        let value = data[hour];\n        let color = getColor(value, valueSteps, stepColors);\n\n        context.fillStyle = color;\n        context.fillRect(x, y, w, h);\n        y += h + options.cellSpacing;\n      }\n\n      x += w + options.cellSpacing;\n    }\n\n    yearOffset += (h + options.cellSpacing) * 24;\n  }\n\n}\n\nfunction getColor(value, valueSteps, stepColors) {\n  let \n    index = 0,\n    color = '#ffffff'; // White is default\n\n  // TODO Handle negative numebers, or at least 0, a little better\n  if (value) {\n    do {\n      color = stepColors[index];\n    } while (index < valueSteps.length && value > valueSteps[index++]);\n  }\n\n  return color;\n}\n\n// Yields Jan 1 at Midnight in Epoch milliseconds starting at start year, ending with end year\nfunction* eachYear(start, end) {\n  let \n    current = new Date((new Date(start)).getUTCFullYear(), 0),\n    endDate = new Date((new Date(end)).getUTCFullYear(), 12),\n    endYear = endDate.getUTCFullYear()\n  ;\n\n  while (current.getUTCFullYear() < endYear) {\n    yield current.getTime();\n    current.setUTCFullYear(current.getUTCFullYear() + 1);\n  }\n}\n\n// Yields midnight in milliseconds for each day in the year (handles leap year)\nfunction* eachDay(year) {\n  let\n    date = 1,\n    month = 0,\n    current = new Date((new Date(year)).getUTCFullYear(), 0),\n    end = new Date((new Date(year)).getUTCFullYear(), 12)\n  ;\n\n  while (current.getTime() < end.getTime()) {\n    \n    yield current.getTime();\n\n    current.setUTCDate(++date);\n\n    let currentMonth = current.getUTCMonth();\n    if (currentMonth > month) {\n      current.setUTCMonth(++month);\n      current.setUTCDate(date = 1);\n      month = currentMonth;\n    }\n  }\n}\n\n// Yields start of hour in milliseconds for each hour in the day\nfunction* eachHour(day) {\n  let\n    hours = 0,\n    hourMilliseconds = 60 * 60 * 1000,\n    dayDate = new Date(day),\n    current = (new Date(dayDate.getUTCFullYear(), dayDate.getUTCMonth(), dayDate.getUTCDate())).getTime(),\n    end = current + 24 * hourMilliseconds\n  ;\n\n  while (current <= end) {\n    yield current;\n    current += hourMilliseconds;\n  }\n}\n\n// function eachHour*(start, end, step = 60 * 60 * 1000) {\n//   let current = start;\n//   while (current <= end) {\n//     yield current;\n//     current += step;\n//   }\n// }\n\nfunction findStartAndEndTimes(data) {\n  let \n    start = new Date(),\n    end = new Date()\n  ;\n\n  end.setYear(1000) // Maybe there's a better way?\n\n  for (let k in data) {\n    if (k < start) start = k;\n    if (k > end) end = k;\n  }\n\n  return { start: start, end: end }\n}\n\nfunction ensureEpochKeys(data) {\n  let r = {}\n  Object.keys(data).forEach(k => {\n    let d = new Date(k),\n      offset = d.getTimezoneOffset() * 60 * 1000;\n    \n    r[d.getTime() + offset] = data[k]\n  });\n  return r;\n}\n\nfunction calculateValueSteps(data, stepCount) {\n  const \n    values = getValues(data).sort((a, b) => a === b ? 0 : a < b ? -1 : 1),\n    stepSize = Math.round(values.length / stepCount)\n  ;\n\n  let steps = [];\n\n  for (let i = 0; i < stepCount; i++) {\n    let index = stepSize * (i + 1);\n    if (index >= values.length) break;\n    steps.push(values[index]);\n  }\n\n  console.log('foo')\n  console.log(values[values.length - 50]);\n\n  return steps;\n}\n\nfunction getValues(obj) {\n  return Object.keys(obj).map(k => obj[k]);\n}\n\nfunction calculateColorSteps(min, max, stepCount) {\n  // TODO Put this in its own module.\n  const\n    minRed = min & 0xff0000,\n    minGreen = min & 0x00ff00,\n    minBlue = min & 0x0000ff,\n\n    maxRed = max & 0xff0000,\n    maxGreen = max & 0x00ff00,\n    maxBlue = max & 0x0000ff,\n  \n    redStepSize = ((minRed - maxRed) / stepCount) & 0xff0000,\n    greenStepSize = ((minGreen - maxGreen) / stepCount) & 0x00ff00,\n    blueStepSize = ((minBlue - maxBlue) / stepCount) & 0x0000ff\n  ;\n\n  let steps = [];\n\n  for (let i = 0; i < stepCount; i++) {\n    let \n      r = maxRed + (redStepSize * i),\n      g = maxGreen + (greenStepSize * i),\n      b = maxBlue + (blueStepSize * i)\n    ;\n\n    steps.push(r | g | b);\n  }\n\n  return steps.map((n) => `#${n.toString(16)}`).reverse();\n}\n\nfunction createCanvas(width, height) {\n  const canvas = document.createElement('canvas');\n  // TODO Maybe do some checks for viability here\n  canvas.width = width;\n  canvas.height = height;\n  return canvas;\n}\n\n\nmodule.exports = {\n  visualize: visualize\n}\n","module.exports = { \"default\": require(\"core-js/library/fn/get-iterator\"), __esModule: true };","module.exports = { \"default\": require(\"core-js/library/fn/object/keys\"), __esModule: true };","module.exports = require(\"regenerator-runtime\");\n","require('../modules/web.dom.iterable');\nrequire('../modules/es6.string.iterator');\nmodule.exports = require('../modules/core.get-iterator');","require('../../modules/es6.object.keys');\nmodule.exports = require('../../modules/_core').Object.keys;","module.exports = function(it){\n  if(typeof it != 'function')throw TypeError(it + ' is not a function!');\n  return it;\n};","module.exports = function(){ /* empty */ };","var isObject = require('./_is-object');\nmodule.exports = function(it){\n  if(!isObject(it))throw TypeError(it + ' is not an object!');\n  return it;\n};","// false -> Array#indexOf\n// true  -> Array#includes\nvar toIObject = require('./_to-iobject')\n  , toLength  = require('./_to-length')\n  , toIndex   = require('./_to-index');\nmodule.exports = function(IS_INCLUDES){\n  return function($this, el, fromIndex){\n    var O      = toIObject($this)\n      , length = toLength(O.length)\n      , index  = toIndex(fromIndex, length)\n      , value;\n    // Array#includes uses SameValueZero equality algorithm\n    if(IS_INCLUDES && el != el)while(length > index){\n      value = O[index++];\n      if(value != value)return true;\n    // Array#toIndex ignores holes, Array#includes - not\n    } else for(;length > index; index++)if(IS_INCLUDES || index in O){\n      if(O[index] === el)return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};","// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = require('./_cof')\n  , TAG = require('./_wks')('toStringTag')\n  // ES3 wrong here\n  , ARG = cof(function(){ return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function(it, key){\n  try {\n    return it[key];\n  } catch(e){ /* empty */ }\n};\n\nmodule.exports = function(it){\n  var O, T, B;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n    // builtinTag case\n    : ARG ? cof(O)\n    // ES3 arguments fallback\n    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};","var toString = {}.toString;\n\nmodule.exports = function(it){\n  return toString.call(it).slice(8, -1);\n};","var core = module.exports = {version: '2.4.0'};\nif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef","// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function(fn, that, length){\n  aFunction(fn);\n  if(that === undefined)return fn;\n  switch(length){\n    case 1: return function(a){\n      return fn.call(that, a);\n    };\n    case 2: return function(a, b){\n      return fn.call(that, a, b);\n    };\n    case 3: return function(a, b, c){\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function(/* ...args */){\n    return fn.apply(that, arguments);\n  };\n};","// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function(it){\n  if(it == undefined)throw TypeError(\"Can't call method on  \" + it);\n  return it;\n};","// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function(){\n  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;\n});","var isObject = require('./_is-object')\n  , document = require('./_global').document\n  // in old IE typeof document.createElement is 'object'\n  , is = isObject(document) && isObject(document.createElement);\nmodule.exports = function(it){\n  return is ? document.createElement(it) : {};\n};","// IE 8- don't enum bug keys\r\nmodule.exports = (\r\n  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\r\n).split(',');","var global    = require('./_global')\n  , core      = require('./_core')\n  , ctx       = require('./_ctx')\n  , hide      = require('./_hide')\n  , PROTOTYPE = 'prototype';\n\nvar $export = function(type, name, source){\n  var IS_FORCED = type & $export.F\n    , IS_GLOBAL = type & $export.G\n    , IS_STATIC = type & $export.S\n    , IS_PROTO  = type & $export.P\n    , IS_BIND   = type & $export.B\n    , IS_WRAP   = type & $export.W\n    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})\n    , expProto  = exports[PROTOTYPE]\n    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]\n    , key, own, out;\n  if(IS_GLOBAL)source = name;\n  for(key in source){\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    if(own && key in exports)continue;\n    // export native or passed\n    out = own ? target[key] : source[key];\n    // prevent global pollution for namespaces\n    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n    // bind timers to global for call from export context\n    : IS_BIND && own ? ctx(out, global)\n    // wrap global constructors for prevent change them in library\n    : IS_WRAP && target[key] == out ? (function(C){\n      var F = function(a, b, c){\n        if(this instanceof C){\n          switch(arguments.length){\n            case 0: return new C;\n            case 1: return new C(a);\n            case 2: return new C(a, b);\n          } return new C(a, b, c);\n        } return C.apply(this, arguments);\n      };\n      F[PROTOTYPE] = C[PROTOTYPE];\n      return F;\n    // make static versions for prototype methods\n    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n    if(IS_PROTO){\n      (exports.virtual || (exports.virtual = {}))[key] = out;\n      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n      if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);\n    }\n  }\n};\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library` \nmodule.exports = $export;","module.exports = function(exec){\n  try {\n    return !!exec();\n  } catch(e){\n    return true;\n  }\n};","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\nif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function(it, key){\n  return hasOwnProperty.call(it, key);\n};","var dP         = require('./_object-dp')\n  , createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function(object, key, value){\n  return dP.f(object, key, createDesc(1, value));\n} : function(object, key, value){\n  object[key] = value;\n  return object;\n};","module.exports = require('./_global').document && document.documentElement;","module.exports = !require('./_descriptors') && !require('./_fails')(function(){\r\n  return Object.defineProperty(require('./_dom-create')('div'), 'a', {get: function(){ return 7; }}).a != 7;\r\n});","// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = require('./_cof');\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){\n  return cof(it) == 'String' ? it.split('') : Object(it);\n};","module.exports = function(it){\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};","'use strict';\nvar create         = require('./_object-create')\n  , descriptor     = require('./_property-desc')\n  , setToStringTag = require('./_set-to-string-tag')\n  , IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nrequire('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function(){ return this; });\n\nmodule.exports = function(Constructor, NAME, next){\n  Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});\n  setToStringTag(Constructor, NAME + ' Iterator');\n};","'use strict';\nvar LIBRARY        = require('./_library')\n  , $export        = require('./_export')\n  , redefine       = require('./_redefine')\n  , hide           = require('./_hide')\n  , has            = require('./_has')\n  , Iterators      = require('./_iterators')\n  , $iterCreate    = require('./_iter-create')\n  , setToStringTag = require('./_set-to-string-tag')\n  , getPrototypeOf = require('./_object-gpo')\n  , ITERATOR       = require('./_wks')('iterator')\n  , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`\n  , FF_ITERATOR    = '@@iterator'\n  , KEYS           = 'keys'\n  , VALUES         = 'values';\n\nvar returnThis = function(){ return this; };\n\nmodule.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){\n  $iterCreate(Constructor, NAME, next);\n  var getMethod = function(kind){\n    if(!BUGGY && kind in proto)return proto[kind];\n    switch(kind){\n      case KEYS: return function keys(){ return new Constructor(this, kind); };\n      case VALUES: return function values(){ return new Constructor(this, kind); };\n    } return function entries(){ return new Constructor(this, kind); };\n  };\n  var TAG        = NAME + ' Iterator'\n    , DEF_VALUES = DEFAULT == VALUES\n    , VALUES_BUG = false\n    , proto      = Base.prototype\n    , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]\n    , $default   = $native || getMethod(DEFAULT)\n    , $entries   = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined\n    , $anyNative = NAME == 'Array' ? proto.entries || $native : $native\n    , methods, key, IteratorPrototype;\n  // Fix native\n  if($anyNative){\n    IteratorPrototype = getPrototypeOf($anyNative.call(new Base));\n    if(IteratorPrototype !== Object.prototype){\n      // Set @@toStringTag to native iterators\n      setToStringTag(IteratorPrototype, TAG, true);\n      // fix for some old engines\n      if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);\n    }\n  }\n  // fix Array#{values, @@iterator}.name in V8 / FF\n  if(DEF_VALUES && $native && $native.name !== VALUES){\n    VALUES_BUG = true;\n    $default = function values(){ return $native.call(this); };\n  }\n  // Define iterator\n  if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){\n    hide(proto, ITERATOR, $default);\n  }\n  // Plug for library\n  Iterators[NAME] = $default;\n  Iterators[TAG]  = returnThis;\n  if(DEFAULT){\n    methods = {\n      values:  DEF_VALUES ? $default : getMethod(VALUES),\n      keys:    IS_SET     ? $default : getMethod(KEYS),\n      entries: $entries\n    };\n    if(FORCED)for(key in methods){\n      if(!(key in proto))redefine(proto, key, methods[key]);\n    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n  }\n  return methods;\n};","module.exports = function(done, value){\n  return {value: value, done: !!done};\n};","module.exports = {};","module.exports = true;","// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\r\nvar anObject    = require('./_an-object')\r\n  , dPs         = require('./_object-dps')\r\n  , enumBugKeys = require('./_enum-bug-keys')\r\n  , IE_PROTO    = require('./_shared-key')('IE_PROTO')\r\n  , Empty       = function(){ /* empty */ }\r\n  , PROTOTYPE   = 'prototype';\r\n\r\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\r\nvar createDict = function(){\r\n  // Thrash, waste and sodomy: IE GC bug\r\n  var iframe = require('./_dom-create')('iframe')\r\n    , i      = enumBugKeys.length\r\n    , gt     = '>'\r\n    , iframeDocument;\r\n  iframe.style.display = 'none';\r\n  require('./_html').appendChild(iframe);\r\n  iframe.src = 'javascript:'; // eslint-disable-line no-script-url\r\n  // createDict = iframe.contentWindow.Object;\r\n  // html.removeChild(iframe);\r\n  iframeDocument = iframe.contentWindow.document;\r\n  iframeDocument.open();\r\n  iframeDocument.write('<script>document.F=Object</script' + gt);\r\n  iframeDocument.close();\r\n  createDict = iframeDocument.F;\r\n  while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];\r\n  return createDict();\r\n};\r\n\r\nmodule.exports = Object.create || function create(O, Properties){\r\n  var result;\r\n  if(O !== null){\r\n    Empty[PROTOTYPE] = anObject(O);\r\n    result = new Empty;\r\n    Empty[PROTOTYPE] = null;\r\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\r\n    result[IE_PROTO] = O;\r\n  } else result = createDict();\r\n  return Properties === undefined ? result : dPs(result, Properties);\r\n};","var anObject       = require('./_an-object')\n  , IE8_DOM_DEFINE = require('./_ie8-dom-define')\n  , toPrimitive    = require('./_to-primitive')\n  , dP             = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes){\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if(IE8_DOM_DEFINE)try {\n    return dP(O, P, Attributes);\n  } catch(e){ /* empty */ }\n  if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');\n  if('value' in Attributes)O[P] = Attributes.value;\n  return O;\n};","var dP       = require('./_object-dp')\r\n  , anObject = require('./_an-object')\r\n  , getKeys  = require('./_object-keys');\r\n\r\nmodule.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties){\r\n  anObject(O);\r\n  var keys   = getKeys(Properties)\r\n    , length = keys.length\r\n    , i = 0\r\n    , P;\r\n  while(length > i)dP.f(O, P = keys[i++], Properties[P]);\r\n  return O;\r\n};","// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\r\nvar has         = require('./_has')\r\n  , toObject    = require('./_to-object')\r\n  , IE_PROTO    = require('./_shared-key')('IE_PROTO')\r\n  , ObjectProto = Object.prototype;\r\n\r\nmodule.exports = Object.getPrototypeOf || function(O){\r\n  O = toObject(O);\r\n  if(has(O, IE_PROTO))return O[IE_PROTO];\r\n  if(typeof O.constructor == 'function' && O instanceof O.constructor){\r\n    return O.constructor.prototype;\r\n  } return O instanceof Object ? ObjectProto : null;\r\n};","var has          = require('./_has')\r\n  , toIObject    = require('./_to-iobject')\r\n  , arrayIndexOf = require('./_array-includes')(false)\r\n  , IE_PROTO     = require('./_shared-key')('IE_PROTO');\r\n\r\nmodule.exports = function(object, names){\r\n  var O      = toIObject(object)\r\n    , i      = 0\r\n    , result = []\r\n    , key;\r\n  for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);\r\n  // Don't enum bug & hidden keys\r\n  while(names.length > i)if(has(O, key = names[i++])){\r\n    ~arrayIndexOf(result, key) || result.push(key);\r\n  }\r\n  return result;\r\n};","// 19.1.2.14 / 15.2.3.14 Object.keys(O)\r\nvar $keys       = require('./_object-keys-internal')\r\n  , enumBugKeys = require('./_enum-bug-keys');\r\n\r\nmodule.exports = Object.keys || function keys(O){\r\n  return $keys(O, enumBugKeys);\r\n};","// most Object methods by ES6 should accept primitives\nvar $export = require('./_export')\n  , core    = require('./_core')\n  , fails   = require('./_fails');\nmodule.exports = function(KEY, exec){\n  var fn  = (core.Object || {})[KEY] || Object[KEY]\n    , exp = {};\n  exp[KEY] = exec(fn);\n  $export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);\n};","module.exports = function(bitmap, value){\n  return {\n    enumerable  : !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable    : !(bitmap & 4),\n    value       : value\n  };\n};","module.exports = require('./_hide');","var def = require('./_object-dp').f\n  , has = require('./_has')\n  , TAG = require('./_wks')('toStringTag');\n\nmodule.exports = function(it, tag, stat){\n  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});\n};","var shared = require('./_shared')('keys')\r\n  , uid    = require('./_uid');\r\nmodule.exports = function(key){\r\n  return shared[key] || (shared[key] = uid(key));\r\n};","var global = require('./_global')\n  , SHARED = '__core-js_shared__'\n  , store  = global[SHARED] || (global[SHARED] = {});\nmodule.exports = function(key){\n  return store[key] || (store[key] = {});\n};","var toInteger = require('./_to-integer')\n  , defined   = require('./_defined');\n// true  -> String#at\n// false -> String#codePointAt\nmodule.exports = function(TO_STRING){\n  return function(that, pos){\n    var s = String(defined(that))\n      , i = toInteger(pos)\n      , l = s.length\n      , a, b;\n    if(i < 0 || i >= l)return TO_STRING ? '' : undefined;\n    a = s.charCodeAt(i);\n    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n      ? TO_STRING ? s.charAt(i) : a\n      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n  };\n};","var toInteger = require('./_to-integer')\n  , max       = Math.max\n  , min       = Math.min;\nmodule.exports = function(index, length){\n  index = toInteger(index);\n  return index < 0 ? max(index + length, 0) : min(index, length);\n};","// 7.1.4 ToInteger\nvar ceil  = Math.ceil\n  , floor = Math.floor;\nmodule.exports = function(it){\n  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./_iobject')\n  , defined = require('./_defined');\nmodule.exports = function(it){\n  return IObject(defined(it));\n};","// 7.1.15 ToLength\nvar toInteger = require('./_to-integer')\n  , min       = Math.min;\nmodule.exports = function(it){\n  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function(it){\n  return Object(defined(it));\n};","// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function(it, S){\n  if(!isObject(it))return it;\n  var fn, val;\n  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};","var id = 0\n  , px = Math.random();\nmodule.exports = function(key){\n  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};","var store      = require('./_shared')('wks')\n  , uid        = require('./_uid')\n  , Symbol     = require('./_global').Symbol\n  , USE_SYMBOL = typeof Symbol == 'function';\n\nvar $exports = module.exports = function(name){\n  return store[name] || (store[name] =\n    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n$exports.store = store;","var classof   = require('./_classof')\n  , ITERATOR  = require('./_wks')('iterator')\n  , Iterators = require('./_iterators');\nmodule.exports = require('./_core').getIteratorMethod = function(it){\n  if(it != undefined)return it[ITERATOR]\n    || it['@@iterator']\n    || Iterators[classof(it)];\n};","var anObject = require('./_an-object')\n  , get      = require('./core.get-iterator-method');\nmodule.exports = require('./_core').getIterator = function(it){\n  var iterFn = get(it);\n  if(typeof iterFn != 'function')throw TypeError(it + ' is not iterable!');\n  return anObject(iterFn.call(it));\n};","'use strict';\nvar addToUnscopables = require('./_add-to-unscopables')\n  , step             = require('./_iter-step')\n  , Iterators        = require('./_iterators')\n  , toIObject        = require('./_to-iobject');\n\n// 22.1.3.4 Array.prototype.entries()\n// 22.1.3.13 Array.prototype.keys()\n// 22.1.3.29 Array.prototype.values()\n// 22.1.3.30 Array.prototype[@@iterator]()\nmodule.exports = require('./_iter-define')(Array, 'Array', function(iterated, kind){\n  this._t = toIObject(iterated); // target\n  this._i = 0;                   // next index\n  this._k = kind;                // kind\n// 22.1.5.2.1 %ArrayIteratorPrototype%.next()\n}, function(){\n  var O     = this._t\n    , kind  = this._k\n    , index = this._i++;\n  if(!O || index >= O.length){\n    this._t = undefined;\n    return step(1);\n  }\n  if(kind == 'keys'  )return step(0, index);\n  if(kind == 'values')return step(0, O[index]);\n  return step(0, [index, O[index]]);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)\nIterators.Arguments = Iterators.Array;\n\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');","// 19.1.2.14 Object.keys(O)\nvar toObject = require('./_to-object')\n  , $keys    = require('./_object-keys');\n\nrequire('./_object-sap')('keys', function(){\n  return function keys(it){\n    return $keys(toObject(it));\n  };\n});","'use strict';\nvar $at  = require('./_string-at')(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\nrequire('./_iter-define')(String, 'String', function(iterated){\n  this._t = String(iterated); // target\n  this._i = 0;                // next index\n// 21.1.5.2.1 %StringIteratorPrototype%.next()\n}, function(){\n  var O     = this._t\n    , index = this._i\n    , point;\n  if(index >= O.length)return {value: undefined, done: true};\n  point = $at(O, index);\n  this._i += point.length;\n  return {value: point, done: false};\n});","require('./es6.array.iterator');\nvar global        = require('./_global')\n  , hide          = require('./_hide')\n  , Iterators     = require('./_iterators')\n  , TO_STRING_TAG = require('./_wks')('toStringTag');\n\nfor(var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++){\n  var NAME       = collections[i]\n    , Collection = global[NAME]\n    , proto      = Collection && Collection.prototype;\n  if(proto && !proto[TO_STRING_TAG])hide(proto, TO_STRING_TAG, NAME);\n  Iterators[NAME] = Iterators.Array;\n}","// This method of obtaining a reference to the global object needs to be\n// kept identical to the way it is obtained in runtime.js\nvar g =\n  typeof global === \"object\" ? global :\n  typeof window === \"object\" ? window :\n  typeof self === \"object\" ? self : this;\n\n// Use `getOwnPropertyNames` because not all browsers support calling\n// `hasOwnProperty` on the global `self` object in a worker. See #183.\nvar hadRuntime = g.regeneratorRuntime &&\n  Object.getOwnPropertyNames(g).indexOf(\"regeneratorRuntime\") >= 0;\n\n// Save the old regeneratorRuntime in case it needs to be restored later.\nvar oldRuntime = hadRuntime && g.regeneratorRuntime;\n\n// Force reevalutation of runtime.js.\ng.regeneratorRuntime = undefined;\n\nmodule.exports = require(\"./runtime\");\n\nif (hadRuntime) {\n  // Restore the original runtime.\n  g.regeneratorRuntime = oldRuntime;\n} else {\n  // Remove the global property added by runtime.js.\n  try {\n    delete g.regeneratorRuntime;\n  } catch(e) {\n    g.regeneratorRuntime = undefined;\n  }\n}\n","/**\n * Copyright (c) 2014, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * https://raw.github.com/facebook/regenerator/master/LICENSE file. An\n * additional grant of patent rights can be found in the PATENTS file in\n * the same directory.\n */\n\n!(function(global) {\n  \"use strict\";\n\n  var hasOwn = Object.prototype.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  var inModule = typeof module === \"object\";\n  var runtime = global.regeneratorRuntime;\n  if (runtime) {\n    if (inModule) {\n      // If regeneratorRuntime is defined globally and we're in a module,\n      // make the exports object identical to regeneratorRuntime.\n      module.exports = runtime;\n    }\n    // Don't bother evaluating the rest of this file if the runtime was\n    // already defined globally.\n    return;\n  }\n\n  // Define the runtime globally (as expected by generated code) as either\n  // module.exports (if we're in a module) or a new, empty object.\n  runtime = global.regeneratorRuntime = inModule ? module.exports : {};\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided, then outerFn.prototype instanceof Generator.\n    var generator = Object.create((outerFn || Generator).prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  runtime.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype;\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = \"GeneratorFunction\";\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      prototype[method] = function(arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  runtime.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  runtime.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `value instanceof AwaitArgument` to determine if the yielded value is\n  // meant to be awaited. Some may consider the name of this method too\n  // cutesy, but they are curmudgeons.\n  runtime.awrap = function(arg) {\n    return new AwaitArgument(arg);\n  };\n\n  function AwaitArgument(arg) {\n    this.arg = arg;\n  }\n\n  function AsyncIterator(generator) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value instanceof AwaitArgument) {\n          return Promise.resolve(value.arg).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return Promise.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration. If the Promise is rejected, however, the\n          // result for this iteration will be rejected with the same\n          // reason. Note that rejections of yielded Promises are not\n          // thrown back into the generator function, as is the case\n          // when an awaited Promise is rejected. This difference in\n          // behavior between yield and await is important, because it\n          // allows the consumer to decide what to do with the yielded\n          // rejection (swallow it and continue, manually .throw it back\n          // into the generator, abandon iteration, whatever). With\n          // await, by contrast, there is no opportunity to examine the\n          // rejection reason outside the generator function, so the\n          // only option is to throw it from the await expression, and\n          // let the generator function handle the exception.\n          result.value = unwrapped;\n          resolve(result);\n        }, reject);\n      }\n    }\n\n    if (typeof process === \"object\" && process.domain) {\n      invoke = process.domain.bind(invoke);\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new Promise(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  runtime.async = function(innerFn, outerFn, self, tryLocsList) {\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList)\n    );\n\n    return runtime.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          if (method === \"return\" ||\n              (method === \"throw\" && delegate.iterator[method] === undefined)) {\n            // A return or throw (when the delegate iterator has no throw\n            // method) always terminates the yield* loop.\n            context.delegate = null;\n\n            // If the delegate iterator has a return method, give it a\n            // chance to clean up.\n            var returnMethod = delegate.iterator[\"return\"];\n            if (returnMethod) {\n              var record = tryCatch(returnMethod, delegate.iterator, arg);\n              if (record.type === \"throw\") {\n                // If the return method threw an exception, let that\n                // exception prevail over the original return or throw.\n                method = \"throw\";\n                arg = record.arg;\n                continue;\n              }\n            }\n\n            if (method === \"return\") {\n              // Continue with the outer return, now that the delegate\n              // iterator has been terminated.\n              continue;\n            }\n          }\n\n          var record = tryCatch(\n            delegate.iterator[method],\n            delegate.iterator,\n            arg\n          );\n\n          if (record.type === \"throw\") {\n            context.delegate = null;\n\n            // Like returning generator.throw(uncaught), but without the\n            // overhead of an extra function call.\n            method = \"throw\";\n            arg = record.arg;\n            continue;\n          }\n\n          // Delegate generator ran and handled its own exceptions so\n          // regardless of what the method was, we continue as if it is\n          // \"next\" with an undefined arg.\n          method = \"next\";\n          arg = undefined;\n\n          var info = record.arg;\n          if (info.done) {\n            context[delegate.resultName] = info.value;\n            context.next = delegate.nextLoc;\n          } else {\n            state = GenStateSuspendedYield;\n            return info;\n          }\n\n          context.delegate = null;\n        }\n\n        if (method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = arg;\n\n        } else if (method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw arg;\n          }\n\n          if (context.dispatchException(arg)) {\n            // If the dispatched exception was caught by a catch block,\n            // then let that catch block handle the exception normally.\n            method = \"next\";\n            arg = undefined;\n          }\n\n        } else if (method === \"return\") {\n          context.abrupt(\"return\", arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          var info = {\n            value: record.arg,\n            done: context.done\n          };\n\n          if (record.arg === ContinueSentinel) {\n            if (context.delegate && method === \"next\") {\n              // Deliberately forget the last sent value so that we don't\n              // accidentally pass it on to the delegate.\n              arg = undefined;\n            }\n          } else {\n            return info;\n          }\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(arg) call above.\n          method = \"throw\";\n          arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp[toStringTagSymbol] = \"Generator\";\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  runtime.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  runtime.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n        return !!caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.next = finallyEntry.finallyLoc;\n      } else {\n        this.complete(record);\n      }\n\n      return ContinueSentinel;\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = record.arg;\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      return ContinueSentinel;\n    }\n  };\n})(\n  // Among the various tricks for obtaining a reference to the global\n  // object, this seems to be the most reliable technique that does not\n  // use indirect eval (which violates Content Security Policy).\n  typeof global === \"object\" ? global :\n  typeof window === \"object\" ? window :\n  typeof self === \"object\" ? self : this\n);\n"]}
diff --git a/index.html b/index.html
index b1d1a0d..28df082 100644
--- a/index.html
+++ b/index.html
@@ -2,7 +2,6 @@
   <title>Hello, Pheasant</title>
 </head>
 <body>
-  <div>Hello, World!</div>
   <div id="canvas_goes_here"></div>
 
   <script type="text/javascript" src="./build/app.js"></script>
diff --git a/lib/pheasant.js b/lib/pheasant.js
index 787a470..8ef5299 100644
--- a/lib/pheasant.js
+++ b/lib/pheasant.js
@@ -3,26 +3,191 @@
 // Creates the visualization
 function visualize(data, domElementId, opts) {
   
-  console.log('visualizing...')
-
   let options = {
-    minColor: 0xf0f0f0,
-    maxColor: 0x050505,
-    numSteps: 5    
+    minColor: 0xfbfbfb,
+    maxColor: 0x606060,
+    numSteps: 10,
+    cellWidth: 6,
+    cellHeight: 6,
+    cellSpacing: 2
   }
 
   const element = document.getElementById(domElementId);
-  const canvas = createCanvas(500, 200);
+  const canvas = createCanvas(365 * options.cellWidth, 1000);
   element.appendChild(canvas);
   const context = canvas.getContext('2d');
 
-  const steps = calculateColorSteps(options.minColor, options.maxColor, options.numSteps);
+  const stepColors = calculateColorSteps(options.minColor, options.maxColor, options.numSteps);
+  const valueSteps = calculateValueSteps(data, options.numSteps);
+
+  console.log(valueSteps)
+
+  // Ensure the data is keyed by Epoch time values - easier to work with
+  data = ensureEpochKeys(data);
+
+  // Find start and end keys
+  let {start, end} = findStartAndEndTimes(data);
+
+  let x = 0, y = 0, yearOffset = 0;
+  const w = options.cellWidth, h = options.cellHeight; // TODO dynamically calculate these from the time dimensions
+
+  for (let year of eachYear(parseInt(start), parseInt(end))) {
+    // Set x back to 0, and move y down if needed
+    x = 0;
+
+    for (let day of eachDay(year)) {
+      // Set x over one and move y back up to the year offset
+      y = yearOffset;
+
+      for (let hour of eachHour(day)) {
+        // Draw the block onto the canvas
+        let value = data[hour];
+        let color = getColor(value, valueSteps, stepColors);
+
+        context.fillStyle = color;
+        context.fillRect(x, y, w, h);
+        y += h + options.cellSpacing;
+      }
+
+      x += w + options.cellSpacing;
+    }
+
+    yearOffset += (h + options.cellSpacing) * 24;
+  }
 
-  context.fillRect(20, 20, 100, 100);
 }
 
-function calculateColorSteps(min, max, stepCount) {
+function getColor(value, valueSteps, stepColors) {
+  let 
+    index = 0,
+    color = '#ffffff'; // White is default
+
+  // TODO Handle negative numebers, or at least 0, a little better
+  if (value) {
+    do {
+      color = stepColors[index];
+    } while (index < valueSteps.length && value > valueSteps[index++]);
+  }
+
+  return color;
+}
+
+// Yields Jan 1 at Midnight in Epoch milliseconds starting at start year, ending with end year
+function* eachYear(start, end) {
+  let 
+    current = new Date((new Date(start)).getUTCFullYear(), 0),
+    endDate = new Date((new Date(end)).getUTCFullYear(), 12),
+    endYear = endDate.getUTCFullYear()
+  ;
+
+  while (current.getUTCFullYear() < endYear) {
+    yield current.getTime();
+    current.setUTCFullYear(current.getUTCFullYear() + 1);
+  }
+}
+
+// Yields midnight in milliseconds for each day in the year (handles leap year)
+function* eachDay(year) {
+  let
+    date = 1,
+    month = 0,
+    current = new Date((new Date(year)).getUTCFullYear(), 0),
+    end = new Date((new Date(year)).getUTCFullYear(), 12)
+  ;
+
+  while (current.getTime() < end.getTime()) {
+    
+    yield current.getTime();
+
+    current.setUTCDate(++date);
+
+    let currentMonth = current.getUTCMonth();
+    if (currentMonth > month) {
+      current.setUTCMonth(++month);
+      current.setUTCDate(date = 1);
+      month = currentMonth;
+    }
+  }
+}
+
+// Yields start of hour in milliseconds for each hour in the day
+function* eachHour(day) {
   let
+    hours = 0,
+    hourMilliseconds = 60 * 60 * 1000,
+    dayDate = new Date(day),
+    current = (new Date(dayDate.getUTCFullYear(), dayDate.getUTCMonth(), dayDate.getUTCDate())).getTime(),
+    end = current + 24 * hourMilliseconds
+  ;
+
+  while (current <= end) {
+    yield current;
+    current += hourMilliseconds;
+  }
+}
+
+// function eachHour*(start, end, step = 60 * 60 * 1000) {
+//   let current = start;
+//   while (current <= end) {
+//     yield current;
+//     current += step;
+//   }
+// }
+
+function findStartAndEndTimes(data) {
+  let 
+    start = new Date(),
+    end = new Date()
+  ;
+
+  end.setYear(1000) // Maybe there's a better way?
+
+  for (let k in data) {
+    if (k < start) start = k;
+    if (k > end) end = k;
+  }
+
+  return { start: start, end: end }
+}
+
+function ensureEpochKeys(data) {
+  let r = {}
+  Object.keys(data).forEach(k => {
+    let d = new Date(k),
+      offset = d.getTimezoneOffset() * 60 * 1000;
+    
+    r[d.getTime() + offset] = data[k]
+  });
+  return r;
+}
+
+function calculateValueSteps(data, stepCount) {
+  const 
+    values = getValues(data).sort((a, b) => a === b ? 0 : a < b ? -1 : 1),
+    stepSize = Math.round(values.length / stepCount)
+  ;
+
+  let steps = [];
+
+  for (let i = 0; i < stepCount; i++) {
+    let index = stepSize * (i + 1);
+    if (index >= values.length) break;
+    steps.push(values[index]);
+  }
+
+  console.log('foo')
+  console.log(values[values.length - 50]);
+
+  return steps;
+}
+
+function getValues(obj) {
+  return Object.keys(obj).map(k => obj[k]);
+}
+
+function calculateColorSteps(min, max, stepCount) {
+  // TODO Put this in its own module.
+  const
     minRed = min & 0xff0000,
     minGreen = min & 0x00ff00,
     minBlue = min & 0x0000ff,
@@ -30,25 +195,25 @@ function calculateColorSteps(min, max, stepCount) {
     maxRed = max & 0xff0000,
     maxGreen = max & 0x00ff00,
     maxBlue = max & 0x0000ff,
-
-    setps = []
+  
+    redStepSize = ((minRed - maxRed) / stepCount) & 0xff0000,
+    greenStepSize = ((minGreen - maxGreen) / stepCount) & 0x00ff00,
+    blueStepSize = ((minBlue - maxBlue) / stepCount) & 0x0000ff
   ;
 
-  const 
-    redStepSize = Math.floor((maxRed - minRed) / stepCount),
-    greenStepSize = Math.floor((maxGreen - minGreen) / stepCount),
-    blueStepSize = Math.floor((maxBlue - minBlue) / stepCount)
-  ;
+  let steps = [];
 
-  for (; i < stepCount; i++) {
+  for (let i = 0; i < stepCount; i++) {
     let 
-      r = minRed + (redStepSize * i+1),
-      g = minGreen + (greenStepSize * i+1),
-      b = minBlue + (blueStepSize * i+1)
+      r = maxRed + (redStepSize * i),
+      g = maxGreen + (greenStepSize * i),
+      b = maxBlue + (blueStepSize * i)
+    ;
+
     steps.push(r | g | b);
   }
 
-  return steps;
+  return steps.map((n) => `#${n.toString(16)}`).reverse();
 }
 
 function createCanvas(width, height) {
diff --git a/package.json b/package.json
index 3571093..8135014 100644
--- a/package.json
+++ b/package.json
@@ -3,8 +3,11 @@
   "version": "0.0.1",
   "description": "",
   "main": "index.js",
-  "dependencies": {},
+  "dependencies": {
+    "babel-runtime": "^6.9.2"
+  },
   "devDependencies": {
+    "babel-plugin-transform-runtime": "^6.9.0",
     "babel-preset-es2015": "^6.9.0",
     "babelify": "^7.3.0",
     "http-server": "^0.9.0"