text: require=(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){
  'use strict';
  var P = require('bluebird');
  var isArray = require('lodash/fp/isArray');
  var isPlainObject = require('lodash/fp/isPlainObject');
  var isFunction = require('lodash/fp/isFunction');
  var find = require('lodash/fp/find');
  var extend = require('lodash/fp/extend');
  var transform = require('lodash/fp/transform');
  var Inflector = require('./inflector');
  
  module.exports = function (jsonapi, data, opts) {
    function isComplexType(obj) {
      return isArray(obj) || isPlainObject(obj);
    }
  
    function getValueForRelationship(relationshipData, included) {
      if (opts && relationshipData && opts[relationshipData.type]) {
        var valueForRelationshipFct = opts[relationshipData.type]
          .valueForRelationship;
  
        return valueForRelationshipFct(relationshipData, included);
      } else {
        return included;
      }
    }
  
    function findIncluded(relationshipData) {
      return new P(function (resolve) {
        if (!jsonapi.included || !relationshipData) { resolve(null); }
  
        var included = find(jsonapi.included, {
          id: relationshipData.id,
          type: relationshipData.type
        });
  
        if (included) {
          return P
            .all([extractAttributes(included), extractRelationships(included)])
            .spread(function (attributes, relationships) {
              resolve(extend(attributes, relationships));
            });
        } else {
          return resolve(null);
        }
      });
    }
  
    function keyForAttribute(attribute) {
      if (isPlainObject(attribute)) {
        return transform(attribute, function (result, value, key) {
          if (isComplexType(value)) {
            result[keyForAttribute(key)] = keyForAttribute(value);
          } else {
            result[keyForAttribute(key)] = value;
          }
        });
      } else if (isArray(attribute)) {
        return attribute.map(function (attr) {
          if (isComplexType(attr)) {
            return keyForAttribute(attr);
          } else {
            return attr;
          }
        });
      } else {
        if (isFunction(opts.keyForAttribute)) {
          return opts.keyForAttribute(attribute);
        } else {
          return Inflector.caserize(attribute, opts);
        }
      }
    }
  
    function extractAttributes(from) {
      var dest = keyForAttribute(from.attributes || {});
      if ('id' in from) { dest.id = from.id; }
  
      return dest;
    }
  
    function extractLinks(from) {
      var dest = keyForAttribute(from.links || {});
  
      return dest;
    }
  
    function extractRelationships(from) {
      if (!from.relationships) { return; }
  
      var dest = {};
  
      return P
        .each(Object.keys(from.relationships), function (key) {
          var relationship = from.relationships[key];
  
          if (relationship.data === null) {
            dest[keyForAttribute(key)] = null;
          } else if (isArray(relationship.data)) {
            return P
              .map(relationship.data, function (relationshipData) {
                return extractIncludes(relationshipData);
              })
              .then(function (includes) {
                if (includes) { dest[keyForAttribute(key)] = includes; }
              });
          } else {
            return extractIncludes(relationship.data)
              .then(function (include) {
                if (include) { dest[keyForAttribute(key)] = include; }
              });
          }
        })
        .thenReturn(dest);
    }
  
    function extractIncludes(relationshipData) {
      return findIncluded(relationshipData)
        .then(function (included) {
          var valueForRelationship = getValueForRelationship(relationshipData,
            included);
  
          if (valueForRelationship && isFunction(valueForRelationship.then)) {
            return valueForRelationship.then(function (value) {
              return value;
            });
          } else {
            return valueForRelationship;
          }
        });
    }
  
    this.perform = function () {
      return P
        .all([extractAttributes(data), extractRelationships(data), extractLinks(data)])
        .spread(function (attributes, relationships, links) {
          return extend(attributes, relationships, links);
        });
    };
  };
  
  },{"./inflector":3,"bluebird":6,"lodash/fp/extend":214,"lodash/fp/find":215,"lodash/fp/isArray":217,"lodash/fp/isFunction":218,"lodash/fp/isPlainObject":220,"lodash/fp/transform":227}],2:[function(require,module,exports){
  'use strict';
  var isArray = require('lodash/fp/isArray');
  var isFunction = require('lodash/fp/isFunction');
  var P = require('bluebird');
  var DeserializerUtils = require('./deserializer-utils');
  
  module.exports = function (opts) {
    if (!opts) { opts = {}; }
  
    this.deserialize = function (jsonapi, callback) {
      function collection() {
        return P
          .map(jsonapi.data, function (d) {
            return new DeserializerUtils(jsonapi, d, opts).perform();
          })
          .then(function (result) {
            if (isFunction(callback)) {
              callback(null, result);
            }
  
            return result
          });
      }
  
      function resource() {
        return new DeserializerUtils(jsonapi, jsonapi.data, opts)
          .perform()
          .then(function (result) {
            if (isFunction(callback)) {
              callback(null, result);
            }
  
            return result
          });
      }
  
      if (isArray(jsonapi.data)) {
        return collection();
      } else {
        return resource();
      }
    };
  };
  
  },{"./deserializer-utils":1,"bluebird":6,"lodash/fp/isArray":217,"lodash/fp/isFunction":218}],3:[function(require,module,exports){
  'use strict';
  var Inflector = require('inflected');
  
  module.exports = {
    caserize: function (attribute, opts) {
      attribute = Inflector.underscore(attribute);
  
      switch (opts.keyForAttribute) {
        case 'dash-case':
        case 'lisp-case':
        case 'spinal-case':
        case 'kebab-case':
          return Inflector.dasherize(attribute);
        case 'underscore_case':
        case 'snake_case':
          return attribute;
        case 'CamelCase':
          return Inflector.camelize(attribute);
        case 'camelCase':
          return Inflector.camelize(attribute, false);
        default:
          return Inflector.dasherize(attribute);
      }
    },
    pluralize: function (type) {
      return Inflector.pluralize(type);
    }
  };
  
  },{"inflected":7}],4:[function(require,module,exports){
  'use strict';
  var isArray = require('lodash/fp/isArray');
  var isPlainObject = require('lodash/fp/isPlainObject');
  var isFunction = require('lodash/fp/isFunction');
  var isUndefined = require('lodash/fp/isUndefined');
  var isNull = require('lodash/fp/isNull');
  var transform = require('lodash/fp/transform');
  var mapValues = require('lodash/fp/mapValues');
  var mapKeys = require('lodash/fp/mapKeys');
  var pick = require('lodash/fp/pick');
  var find = require('lodash/fp/find');
  var keys = require('lodash/fp/keys');
  var each = require('lodash/fp/each');
  var Inflector = require('./inflector');
  
  module.exports = function (collectionName, record, payload, opts) {
    function isComplexType(obj) {
      return isArray(obj) || isPlainObject(obj);
    }
  
    function keyForAttribute(attribute) {
      if (isPlainObject(attribute)) {
        return transform(attribute, function (result, value, key) {
          if (isComplexType(value)) {
            result[keyForAttribute(key)] = keyForAttribute(value);
          } else {
            result[keyForAttribute(key)] = value;
          }
        });
      } else if (isArray(attribute)) {
        return attribute.map(function (attr) {
          if (isComplexType(attr)) {
            return keyForAttribute(attr);
          } else {
            return attr;
          }
        });
      } else {
        if (isFunction(opts.keyForAttribute)) {
          return opts.keyForAttribute(attribute);
        } else {
          return Inflector.caserize(attribute, opts);
        }
      }
    }
  
    function getId() {
      return opts.id || 'id';
    }
  
    function getRef(current, item, opts) {
      if (isFunction(opts.ref)) {
        return opts.ref(current, item);
      } else if (opts.ref === true) {
        if (isArray(item)) {
          return item.map(function (val) {
            return String(val);
          });
        } else if (item) {
          return String(item);
        }
      } else if (item && item[opts.ref]){
        return String(item[opts.ref]);
      }
    }
  
    function getType(str, attrVal) {
      var type;
      attrVal = attrVal || {};
  
      if (isFunction(opts.typeForAttribute)) {
        type = opts.typeForAttribute(str, attrVal);
      }
  
      // If the pluralize option is on, typeForAttribute returned undefined or wasn't used
      if ((isUndefined(opts.pluralizeType) || opts.pluralizeType) && isUndefined(type)) {
        type = Inflector.pluralize(str);
      }
  
      if (isUndefined(type)) {
        type = str;
      }
  
      return type;
    }
  
    function getLinks(current, links, dest) {
      return mapValues(links, function (value) {
        if (isFunction(value)) {
          return value(record, current, dest);
        } else {
          return value;
        }
      });
    }
  
    function getMeta(current, meta) {
      return mapValues(meta, function (value) {
        if (isFunction(value)) {
          return value(record, current);
        } else {
          return value;
        }
      });
    }
  
    function pick(obj, attributes) {
      return mapKeys(pick(obj, attributes), function (value, key) {
        return keyForAttribute(key);
      });
    }
  
    function isCompoundDocumentIncluded(included, item) {
      return find(payload.included, { id: item.id, type: item.type });
    }
  
    function pushToIncluded(dest, include) {
      if (!isCompoundDocumentIncluded(dest, include)) {
        if (!dest.included) { dest.included = []; }
        dest.included.push(include);
      }
    }
  
    this.serialize = function (dest, current, attribute, opts) {
      var that = this;
      var data = null;
  
      if (opts && opts.ref) {
        if (!dest.relationships) { dest.relationships = {}; }
  
        if (isArray(current[attribute])) {
          data = current[attribute].map(function (item) {
            return that.serializeRef(item, current, attribute, opts);
          });
        } else {
          data = that.serializeRef(current[attribute], current, attribute,
            opts);
        }
  
        dest.relationships[keyForAttribute(attribute)] = {};
        if (!opts.ignoreRelationshipData) {
          dest.relationships[keyForAttribute(attribute)].data = data;
        }
  
        if (opts.relationshipLinks) {
          dest.relationships[keyForAttribute(attribute)].links =
            getLinks(current[attribute], opts.relationshipLinks, dest);
        }
  
        if (opts.relationshipMeta) {
          dest.relationships[keyForAttribute(attribute)].meta =
            getMeta(current[attribute], opts.relationshipMeta);
        }
      } else {
        if (isArray(current[attribute])) {
          if (current[attribute].length && isPlainObject(current[attribute][0])) {
            data = current[attribute].map(function (item) {
              return that.serializeNested(item, current, attribute, opts);
            });
          } else {
            data = current[attribute];
          }
  
          dest.attributes[keyForAttribute(attribute)] = data;
        } else if (isPlainObject(current[attribute])) {
          data = that.serializeNested(current[attribute], current, attribute, opts);
          dest.attributes[keyForAttribute(attribute)] = data;
        } else {
          dest.attributes[keyForAttribute(attribute)] = current[attribute];
        }
      }
    };
  
    this.serializeRef = function (dest, current, attribute, opts) {
      var that = this;
      var id = getRef(current, dest, opts);
      var type = getType(attribute, dest);
  
      var relationships = [];
      var includedAttrs = [];
  
      if (opts.attributes) {
        relationships = opts.attributes.filter(function (attr) {
          return opts[attr];
        });
  
        includedAttrs = opts.attributes.filter(function (attr) {
          return !opts[attr];
        });
      }
  
      var included = { type: type, id: id };
      if (includedAttrs) { included.attributes = pick(dest, includedAttrs); }
  
      relationships.forEach(function (relationship) {
        if (dest && isComplexType(dest[relationship])) {
          that.serialize(included, dest, relationship, opts[relationship]);
        }
      });
  
      if (includedAttrs.length &&
        (isUndefined(opts.included) || opts.included)) {
        if (opts.includedLinks) {
          included.links = getLinks(dest, opts.includedLinks);
        }
  
        if (typeof id !== 'undefined') { pushToIncluded(payload, included); }
      }
  
      return typeof id !== 'undefined' ? { type: type, id: id } : null;
    };
  
    this.serializeNested = function (dest, current, attribute, opts) {
      var that = this;
  
      var embeds = [];
      var attributes = [];
  
      if (opts && opts.attributes) {
        embeds = opts.attributes.filter(function (attr) {
          return opts[attr];
        });
  
        attributes = opts.attributes.filter(function (attr) {
          return !opts[attr];
        });
      } else {
        attributes = keys(dest);
      }
  
      var ret = {};
      if (attributes) { ret.attributes = pick(dest, attributes); }
  
      embeds.forEach(function (embed) {
        if (isComplexType(dest[embed])) {
          that.serialize(ret, dest, embed, opts[embed]);
        }
      });
  
      return ret.attributes;
    };
  
    this.perform = function () {
      var that = this;
  
      if( isNull( record ) ){
          return null;
      }
  
      // Top-level data.
      var data = {
        type: getType(collectionName, record),
        id: String(record[getId()])
      };
  
      // Data links.
      if (opts.dataLinks) {
        data.links = getLinks(record, opts.dataLinks);
      }
  
      each(opts.attributes, function (attribute) {
        var splittedAttributes = attribute.split(':');
  
        if (splittedAttributes[0] in record ||
          (opts[attribute] && opts[attribute].nullIfMissing)) {
  
          if (!data.attributes) { data.attributes = {}; }
          var attributeMap = attribute;
          if (splittedAttributes.length > 1) {
            attribute = splittedAttributes[0];
            attributeMap = splittedAttributes[1];
          }
  
          that.serialize(data, record, attribute, opts[attributeMap]);
        }
      });
  
      return data;
    };
  };
  
  },{"./inflector":3,"lodash/fp/each":213,"lodash/fp/find":215,"lodash/fp/isArray":217,"lodash/fp/isFunction":218,"lodash/fp/isNull":219,"lodash/fp/isPlainObject":220,"lodash/fp/isUndefined":221,"lodash/fp/keys":222,"lodash/fp/mapKeys":223,"lodash/fp/mapValues":224,"lodash/fp/pick":225,"lodash/fp/transform":227}],5:[function(require,module,exports){
  'use strict';
  var isArray = require('lodash/fp/isArray');
  var isFunction = require('lodash/fp/isFunction');
  var mapValues = require('lodash/fp/mapValues');
  var SerializerUtils = require('./serializer-utils');
  
  module.exports = function (collectionName, records, opts) {
    this.serialize = function (records) {
      var that = this;
      var payload = {};
  
      function getLinks(links) {
        return mapValues(links, function (value) {
          if (isFunction(value)) {
            return value(records);
          } else {
            return value;
          }
        });
      }
  
      function collection() {
        payload.data = [];
  
        records.forEach(function (record) {
          var serializerUtils = new SerializerUtils(that.collectionName, record,
            payload, that.opts);
          payload.data.push(serializerUtils.perform());
        });
  
        return payload;
      }
  
      function resource() {
        payload.data = new SerializerUtils(that.collectionName, records, payload,
          that.opts).perform(records);
  
        return payload;
      }
  
      if (that.opts.topLevelLinks) {
        payload.links = getLinks(that.opts.topLevelLinks);
      }
  
      if (that.opts.meta) {
        payload.meta = that.opts.meta;
      }
  
      if (isArray(records)) {
        return collection(records);
      } else {
        return resource(records);
      }
    };
  
    if (arguments.length === 3) {
      // legacy behavior
      this.collectionName = collectionName;
      this.opts = opts;
      return this.serialize(records);
    } else {
      // treat as a reusable serializer
      this.collectionName = collectionName;
      this.opts = records;
    }
  };
  
  },{"./serializer-utils":4,"lodash/fp/isArray":217,"lodash/fp/isFunction":218,"lodash/fp/mapValues":224}],6:[function(require,module,exports){
  (function (process,global){
  /* @preserve
   * The MIT License (MIT)
   * 
   * Copyright (c) 2013-2015 Petka Antonov
   * 
   * Permission is hereby granted, free of charge, to any person obtaining a copy
   * of this software and associated documentation files (the "Software"), to deal
   * in the Software without restriction, including without limitation the rights
   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   * copies of the Software, and to permit persons to whom the Software is
   * furnished to do so, subject to the following conditions:
   * 
   * The above copyright notice and this permission notice shall be included in
   * all copies or substantial portions of the Software.
   * 
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   * THE SOFTWARE.
   * 
   */
  /**
   * bluebird build version 2.11.0
   * Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, cancel, using, filter, any, each, timers
  */
  !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Promise=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof _dereq_=="function"&&_dereq_;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 _dereq_=="function"&&_dereq_;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise) {
  var SomePromiseArray = Promise._SomePromiseArray;
  function any(promises) {
      var ret = new SomePromiseArray(promises);
      var promise = ret.promise();
      ret.setHowMany(1);
      ret.setUnwrap();
      ret.init();
      return promise;
  }
  
  Promise.any = function (promises) {
      return any(promises);
  };
  
  Promise.prototype.any = function () {
      return any(this);
  };
  
  };
  
  },{}],2:[function(_dereq_,module,exports){
  "use strict";
  var firstLineError;
  try {throw new Error(); } catch (e) {firstLineError = e;}
  var schedule = _dereq_("./schedule.js");
  var Queue = _dereq_("./queue.js");
  var util = _dereq_("./util.js");
  
  function Async() {
      this._isTickUsed = false;
      this._lateQueue = new Queue(16);
      this._normalQueue = new Queue(16);
      this._trampolineEnabled = true;
      var self = this;
      this.drainQueues = function () {
          self._drainQueues();
      };
      this._schedule =
          schedule.isStatic ? schedule(this.drainQueues) : schedule;
  }
  
  Async.prototype.disableTrampolineIfNecessary = function() {
      if (util.hasDevTools) {
          this._trampolineEnabled = false;
      }
  };
  
  Async.prototype.enableTrampoline = function() {
      if (!this._trampolineEnabled) {
          this._trampolineEnabled = true;
          this._schedule = function(fn) {
              setTimeout(fn, 0);
          };
      }
  };
  
  Async.prototype.haveItemsQueued = function () {
      return this._normalQueue.length() > 0;
  };
  
  Async.prototype.throwLater = function(fn, arg) {
      if (arguments.length === 1) {
          arg = fn;
          fn = function () { throw arg; };
      }
      if (typeof setTimeout !== "undefined") {
          setTimeout(function() {
              fn(arg);
          }, 0);
      } else try {
          this._schedule(function() {
              fn(arg);
          });
      } catch (e) {
          throw new Error("No async scheduler available\u000a\u000a    See http://goo.gl/m3OTXk\u000a");
      }
  };
  
  function AsyncInvokeLater(fn, receiver, arg) {
      this._lateQueue.push(fn, receiver, arg);
      this._queueTick();
  }
  
  function AsyncInvoke(fn, receiver, arg) {
      this._normalQueue.push(fn, receiver, arg);
      this._queueTick();
  }
  
  function AsyncSettlePromises(promise) {
      this._normalQueue._pushOne(promise);
      this._queueTick();
  }
  
  if (!util.hasDevTools) {
      Async.prototype.invokeLater = AsyncInvokeLater;
      Async.prototype.invoke = AsyncInvoke;
      Async.prototype.settlePromises = AsyncSettlePromises;
  } else {
      if (schedule.isStatic) {
          schedule = function(fn) { setTimeout(fn, 0); };
      }
      Async.prototype.invokeLater = function (fn, receiver, arg) {
          if (this._trampolineEnabled) {
              AsyncInvokeLater.call(this, fn, receiver, arg);
          } else {
              this._schedule(function() {
                  setTimeout(function() {
                      fn.call(receiver, arg);
                  }, 100);
              });
          }
      };
  
      Async.prototype.invoke = function (fn, receiver, arg) {
          if (this._trampolineEnabled) {
              AsyncInvoke.call(this, fn, receiver, arg);
          } else {
              this._schedule(function() {
                  fn.call(receiver, arg);
              });
          }
      };
  
      Async.prototype.settlePromises = function(promise) {
          if (this._trampolineEnabled) {
              AsyncSettlePromises.call(this, promise);
          } else {
              this._schedule(function() {
                  promise._settlePromises();
              });
          }
      };
  }
  
  Async.prototype.invokeFirst = function (fn, receiver, arg) {
      this._normalQueue.unshift(fn, receiver, arg);
      this._queueTick();
  };
  
  Async.prototype._drainQueue = function(queue) {
      while (queue.length() > 0) {
          var fn = queue.shift();
          if (typeof fn !== "function") {
              fn._settlePromises();
              continue;
          }
          var receiver = queue.shift();
          var arg = queue.shift();
          fn.call(receiver, arg);
      }
  };
  
  Async.prototype._drainQueues = function () {
      this._drainQueue(this._normalQueue);
      this._reset();
      this._drainQueue(this._lateQueue);
  };
  
  Async.prototype._queueTick = function () {
      if (!this._isTickUsed) {
          this._isTickUsed = true;
          this._schedule(this.drainQueues);
      }
  };
  
  Async.prototype._reset = function () {
      this._isTickUsed = false;
  };
  
  module.exports = new Async();
  module.exports.firstLineError = firstLineError;
  
  },{"./queue.js":28,"./schedule.js":31,"./util.js":38}],3:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise, INTERNAL, tryConvertToPromise) {
  var rejectThis = function(_, e) {
      this._reject(e);
  };
  
  var targetRejected = function(e, context) {
      context.promiseRejectionQueued = true;
      context.bindingPromise._then(rejectThis, rejectThis, null, this, e);
  };
  
  var bindingResolved = function(thisArg, context) {
      if (this._isPending()) {
          this._resolveCallback(context.target);
      }
  };
  
  var bindingRejected = function(e, context) {
      if (!context.promiseRejectionQueued) this._reject(e);
  };
  
  Promise.prototype.bind = function (thisArg) {
      var maybePromise = tryConvertToPromise(thisArg);
      var ret = new Promise(INTERNAL);
      ret._propagateFrom(this, 1);
      var target = this._target();
  
      ret._setBoundTo(maybePromise);
      if (maybePromise instanceof Promise) {
          var context = {
              promiseRejectionQueued: false,
              promise: ret,
              target: target,
              bindingPromise: maybePromise
          };
          target._then(INTERNAL, targetRejected, ret._progress, ret, context);
          maybePromise._then(
              bindingResolved, bindingRejected, ret._progress, ret, context);
      } else {
          ret._resolveCallback(target);
      }
      return ret;
  };
  
  Promise.prototype._setBoundTo = function (obj) {
      if (obj !== undefined) {
          this._bitField = this._bitField | 131072;
          this._boundTo = obj;
      } else {
          this._bitField = this._bitField & (~131072);
      }
  };
  
  Promise.prototype._isBound = function () {
      return (this._bitField & 131072) === 131072;
  };
  
  Promise.bind = function (thisArg, value) {
      var maybePromise = tryConvertToPromise(thisArg);
      var ret = new Promise(INTERNAL);
  
      ret._setBoundTo(maybePromise);
      if (maybePromise instanceof Promise) {
          maybePromise._then(function() {
              ret._resolveCallback(value);
          }, ret._reject, ret._progress, ret, null);
      } else {
          ret._resolveCallback(value);
      }
      return ret;
  };
  };
  
  },{}],4:[function(_dereq_,module,exports){
  "use strict";
  var old;
  if (typeof Promise !== "undefined") old = Promise;
  function noConflict() {
      try { if (Promise === bluebird) Promise = old; }
      catch (e) {}
      return bluebird;
  }
  var bluebird = _dereq_("./promise.js")();
  bluebird.noConflict = noConflict;
  module.exports = bluebird;
  
  },{"./promise.js":23}],5:[function(_dereq_,module,exports){
  "use strict";
  var cr = Object.create;
  if (cr) {
      var callerCache = cr(null);
      var getterCache = cr(null);
      callerCache[" size"] = getterCache[" size"] = 0;
  }
  
  module.exports = function(Promise) {
  var util = _dereq_("./util.js");
  var canEvaluate = util.canEvaluate;
  var isIdentifier = util.isIdentifier;
  
  var getMethodCaller;
  var getGetter;
  if (!true) {
  var makeMethodCaller = function (methodName) {
      return new Function("ensureMethod", "                                    \n\
          return function(obj) {                                               \n\
              'use strict'                                                     \n\
              var len = this.length;                                           \n\
              ensureMethod(obj, 'methodName');                                 \n\
              switch(len) {                                                    \n\
                  case 1: return obj.methodName(this[0]);                      \n\
                  case 2: return obj.methodName(this[0], this[1]);             \n\
                  case 3: return obj.methodName(this[0], this[1], this[2]);    \n\
                  case 0: return obj.methodName();                             \n\
                  default:                                                     \n\
                      return obj.methodName.apply(obj, this);                  \n\
              }                                                                \n\
          };                                                                   \n\
          ".replace(/methodName/g, methodName))(ensureMethod);
  };
  
  var makeGetter = function (propertyName) {
      return new Function("obj", "                                             \n\
          'use strict';                                                        \n\
          return obj.propertyName;                                             \n\
          ".replace("propertyName", propertyName));
  };
  
  var getCompiled = function(name, compiler, cache) {
      var ret = cache[name];
      if (typeof ret !== "function") {
          if (!isIdentifier(name)) {
              return null;
          }
          ret = compiler(name);
          cache[name] = ret;
          cache[" size"]++;
          if (cache[" size"] > 512) {
              var keys = Object.keys(cache);
              for (var i = 0; i < 256; ++i) delete cache[keys[i]];
              cache[" size"] = keys.length - 256;
          }
      }
      return ret;
  };
  
  getMethodCaller = function(name) {
      return getCompiled(name, makeMethodCaller, callerCache);
  };
  
  getGetter = function(name) {
      return getCompiled(name, makeGetter, getterCache);
  };
  }
  
  function ensureMethod(obj, methodName) {
      var fn;
      if (obj != null) fn = obj[methodName];
      if (typeof fn !== "function") {
          var message = "Object " + util.classString(obj) + " has no method '" +
              util.toString(methodName) + "'";
          throw new Promise.TypeError(message);
      }
      return fn;
  }
  
  function caller(obj) {
      var methodName = this.pop();
      var fn = ensureMethod(obj, methodName);
      return fn.apply(obj, this);
  }
  Promise.prototype.call = function (methodName) {
      var $_len = arguments.length;var args = new Array($_len - 1); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];}
      if (!true) {
          if (canEvaluate) {
              var maybeCaller = getMethodCaller(methodName);
              if (maybeCaller !== null) {
                  return this._then(
                      maybeCaller, undefined, undefined, args, undefined);
              }
          }
      }
      args.push(methodName);
      return this._then(caller, undefined, undefined, args, undefined);
  };
  
  function namedGetter(obj) {
      return obj[this];
  }
  function indexedGetter(obj) {
      var index = +this;
      if (index < 0) index = Math.max(0, index + obj.length);
      return obj[index];
  }
  Promise.prototype.get = function (propertyName) {
      var isIndex = (typeof propertyName === "number");
      var getter;
      if (!isIndex) {
          if (canEvaluate) {
              var maybeGetter = getGetter(propertyName);
              getter = maybeGetter !== null ? maybeGetter : namedGetter;
          } else {
              getter = namedGetter;
          }
      } else {
          getter = indexedGetter;
      }
      return this._then(getter, undefined, undefined, propertyName, undefined);
  };
  };
  
  },{"./util.js":38}],6:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise) {
  var errors = _dereq_("./errors.js");
  var async = _dereq_("./async.js");
  var CancellationError = errors.CancellationError;
  
  Promise.prototype._cancel = function (reason) {
      if (!this.isCancellable()) return this;
      var parent;
      var promiseToReject = this;
      while ((parent = promiseToReject._cancellationParent) !== undefined &&
          parent.isCancellable()) {
          promiseToReject = parent;
      }
      this._unsetCancellable();
      promiseToReject._target()._rejectCallback(reason, false, true);
  };
  
  Promise.prototype.cancel = function (reason) {
      if (!this.isCancellable()) return this;
      if (reason === undefined) reason = new CancellationError();
      async.invokeLater(this._cancel, this, reason);
      return this;
  };
  
  Promise.prototype.cancellable = function () {
      if (this._cancellable()) return this;
      async.enableTrampoline();
      this._setCancellable();
      this._cancellationParent = undefined;
      return this;
  };
  
  Promise.prototype.uncancellable = function () {
      var ret = this.then();
      ret._unsetCancellable();
      return ret;
  };
  
  Promise.prototype.fork = function (didFulfill, didReject, didProgress) {
      var ret = this._then(didFulfill, didReject, didProgress,
                           undefined, undefined);
  
      ret._setCancellable();
      ret._cancellationParent = undefined;
      return ret;
  };
  };
  
  },{"./async.js":2,"./errors.js":13}],7:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function() {
  var async = _dereq_("./async.js");
  var util = _dereq_("./util.js");
  var bluebirdFramePattern =
      /[\\\/]bluebird[\\\/]js[\\\/](main|debug|zalgo|instrumented)/;
  var stackFramePattern = null;
  var formatStack = null;
  var indentStackFrames = false;
  var warn;
  
  function CapturedTrace(parent) {
      this._parent = parent;
      var length = this._length = 1 + (parent === undefined ? 0 : parent._length);
      captureStackTrace(this, CapturedTrace);
      if (length > 32) this.uncycle();
  }
  util.inherits(CapturedTrace, Error);
  
  CapturedTrace.prototype.uncycle = function() {
      var length = this._length;
      if (length < 2) return;
      var nodes = [];
      var stackToIndex = {};
  
      for (var i = 0, node = this; node !== undefined; ++i) {
          nodes.push(node);
          node = node._parent;
      }
      length = this._length = i;
      for (var i = length - 1; i >= 0; --i) {
          var stack = nodes[i].stack;
          if (stackToIndex[stack] === undefined) {
              stackToIndex[stack] = i;
          }
      }
      for (var i = 0; i < length; ++i) {
          var currentStack = nodes[i].stack;
          var index = stackToIndex[currentStack];
          if (index !== undefined && index !== i) {
              if (index > 0) {
                  nodes[index - 1]._parent = undefined;
                  nodes[index - 1]._length = 1;
              }
              nodes[i]._parent = undefined;
              nodes[i]._length = 1;
              var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;
  
              if (index < length - 1) {
                  cycleEdgeNode._parent = nodes[index + 1];
                  cycleEdgeNode._parent.uncycle();
                  cycleEdgeNode._length =
                      cycleEdgeNode._parent._length + 1;
              } else {
                  cycleEdgeNode._parent = undefined;
                  cycleEdgeNode._length = 1;
              }
              var currentChildLength = cycleEdgeNode._length + 1;
              for (var j = i - 2; j >= 0; --j) {
                  nodes[j]._length = currentChildLength;
                  currentChildLength++;
              }
              return;
          }
      }
  };
  
  CapturedTrace.prototype.parent = function() {
      return this._parent;
  };
  
  CapturedTrace.prototype.hasParent = function() {
      return this._parent !== undefined;
  };
  
  CapturedTrace.prototype.attachExtraTrace = function(error) {
      if (error.__stackCleaned__) return;
      this.uncycle();
      var parsed = CapturedTrace.parseStackAndMessage(error);
      var message = parsed.message;
      var stacks = [parsed.stack];
  
      var trace = this;
      while (trace !== undefined) {
          stacks.push(cleanStack(trace.stack.split("\n")));
          trace = trace._parent;
      }
      removeCommonRoots(stacks);
      removeDuplicateOrEmptyJumps(stacks);
      util.notEnumerableProp(error, "stack", reconstructStack(message, stacks));
      util.notEnumerableProp(error, "__stackCleaned__", true);
  };
  
  function reconstructStack(message, stacks) {
      for (var i = 0; i < stacks.length - 1; ++i) {
          stacks[i].push("From previous event:");
          stacks[i] = stacks[i].join("\n");
      }
      if (i < stacks.length) {
          stacks[i] = stacks[i].join("\n");
      }
      return message + "\n" + stacks.join("\n");
  }
  
  function removeDuplicateOrEmptyJumps(stacks) {
      for (var i = 0; i < stacks.length; ++i) {
          if (stacks[i].length === 0 ||
              ((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) {
              stacks.splice(i, 1);
              i--;
          }
      }
  }
  
  function removeCommonRoots(stacks) {
      var current = stacks[0];
      for (var i = 1; i < stacks.length; ++i) {
          var prev = stacks[i];
          var currentLastIndex = current.length - 1;
          var currentLastLine = current[currentLastIndex];
          var commonRootMeetPoint = -1;
  
          for (var j = prev.length - 1; j >= 0; --j) {
              if (prev[j] === currentLastLine) {
                  commonRootMeetPoint = j;
                  break;
              }
          }
  
          for (var j = commonRootMeetPoint; j >= 0; --j) {
              var line = prev[j];
              if (current[currentLastIndex] === line) {
                  current.pop();
                  currentLastIndex--;
              } else {
                  break;
              }
          }
          current = prev;
      }
  }
  
  function cleanStack(stack) {
      var ret = [];
      for (var i = 0; i < stack.length; ++i) {
          var line = stack[i];
          var isTraceLine = stackFramePattern.test(line) ||
              "    (No stack trace)" === line;
          var isInternalFrame = isTraceLine && shouldIgnore(line);
          if (isTraceLine && !isInternalFrame) {
              if (indentStackFrames && line.charAt(0) !== " ") {
                  line = "    " + line;
              }
              ret.push(line);
          }
      }
      return ret;
  }
  
  function stackFramesAsArray(error) {
      var stack = error.stack.replace(/\s+$/g, "").split("\n");
      for (var i = 0; i < stack.length; ++i) {
          var line = stack[i];
          if ("    (No stack trace)" === line || stackFramePattern.test(line)) {
              break;
          }
      }
      if (i > 0) {
          stack = stack.slice(i);
      }
      return stack;
  }
  
  CapturedTrace.parseStackAndMessage = function(error) {
      var stack = error.stack;
      var message = error.toString();
      stack = typeof stack === "string" && stack.length > 0
                  ? stackFramesAsArray(error) : ["    (No stack trace)"];
      return {
          message: message,
          stack: cleanStack(stack)
      };
  };
  
  CapturedTrace.formatAndLogError = function(error, title) {
      if (typeof console !== "undefined") {
          var message;
          if (typeof error === "object" || typeof error === "function") {
              var stack = error.stack;
              message = title + formatStack(stack, error);
          } else {
              message = title + String(error);
          }
          if (typeof warn === "function") {
              warn(message);
          } else if (typeof console.log === "function" ||
              typeof console.log === "object") {
              console.log(message);
          }
      }
  };
  
  CapturedTrace.unhandledRejection = function (reason) {
      CapturedTrace.formatAndLogError(reason, "^--- With additional stack trace: ");
  };
  
  CapturedTrace.isSupported = function () {
      return typeof captureStackTrace === "function";
  };
  
  CapturedTrace.fireRejectionEvent =
  function(name, localHandler, reason, promise) {
      var localEventFired = false;
      try {
          if (typeof localHandler === "function") {
              localEventFired = true;
              if (name === "rejectionHandled") {
                  localHandler(promise);
              } else {
                  localHandler(reason, promise);
              }
          }
      } catch (e) {
          async.throwLater(e);
      }
  
      var globalEventFired = false;
      try {
          globalEventFired = fireGlobalEvent(name, reason, promise);
      } catch (e) {
          globalEventFired = true;
          async.throwLater(e);
      }
  
      var domEventFired = false;
      if (fireDomEvent) {
          try {
              domEventFired = fireDomEvent(name.toLowerCase(), {
                  reason: reason,
                  promise: promise
              });
          } catch (e) {
              domEventFired = true;
              async.throwLater(e);
          }
      }
  
      if (!globalEventFired && !localEventFired && !domEventFired &&
          name === "unhandledRejection") {
          CapturedTrace.formatAndLogError(reason, "Unhandled rejection ");
      }
  };
  
  function formatNonError(obj) {
      var str;
      if (typeof obj === "function") {
          str = "[function " +
              (obj.name || "anonymous") +
              "]";
      } else {
          str = obj.toString();
          var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
          if (ruselessToString.test(str)) {
              try {
                  var newStr = JSON.stringify(obj);
                  str = newStr;
              }
              catch(e) {
  
              }
          }
          if (str.length === 0) {
              str = "(empty array)";
          }
      }
      return ("(<" + snip(str) + ">, no stack trace)");
  }
  
  function snip(str) {
      var maxChars = 41;
      if (str.length < maxChars) {
          return str;
      }
      return str.substr(0, maxChars - 3) + "...";
  }
  
  var shouldIgnore = function() { return false; };
  var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/;
  function parseLineInfo(line) {
      var matches = line.match(parseLineInfoRegex);
      if (matches) {
          return {
              fileName: matches[1],
              line: parseInt(matches[2], 10)
          };
      }
  }
  CapturedTrace.setBounds = function(firstLineError, lastLineError) {
      if (!CapturedTrace.isSupported()) return;
      var firstStackLines = firstLineError.stack.split("\n");
      var lastStackLines = lastLineError.stack.split("\n");
      var firstIndex = -1;
      var lastIndex = -1;
      var firstFileName;
      var lastFileName;
      for (var i = 0; i < firstStackLines.length; ++i) {
          var result = parseLineInfo(firstStackLines[i]);
          if (result) {
              firstFileName = result.fileName;
              firstIndex = result.line;
              break;
          }
      }
      for (var i = 0; i < lastStackLines.length; ++i) {
          var result = parseLineInfo(lastStackLines[i]);
          if (result) {
              lastFileName = result.fileName;
              lastIndex = result.line;
              break;
          }
      }
      if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName ||
          firstFileName !== lastFileName || firstIndex >= lastIndex) {
          return;
      }
  
      shouldIgnore = function(line) {
          if (bluebirdFramePattern.test(line)) return true;
          var info = parseLineInfo(line);
          if (info) {
              if (info.fileName === firstFileName &&
                  (firstIndex <= info.line && info.line <= lastIndex)) {
                  return true;
              }
          }
          return false;
      };
  };
  
  var captureStackTrace = (function stackDetection() {
      var v8stackFramePattern = /^\s*at\s*/;
      var v8stackFormatter = function(stack, error) {
          if (typeof stack === "string") return stack;
  
          if (error.name !== undefined &&
              error.message !== undefined) {
              return error.toString();
          }
          return formatNonError(error);
      };
  
      if (typeof Error.stackTraceLimit === "number" &&
          typeof Error.captureStackTrace === "function") {
          Error.stackTraceLimit = Error.stackTraceLimit + 6;
          stackFramePattern = v8stackFramePattern;
          formatStack = v8stackFormatter;
          var captureStackTrace = Error.captureStackTrace;
  
          shouldIgnore = function(line) {
              return bluebirdFramePattern.test(line);
          };
          return function(receiver, ignoreUntil) {
              Error.stackTraceLimit = Error.stackTraceLimit + 6;
              captureStackTrace(receiver, ignoreUntil);
              Error.stackTraceLimit = Error.stackTraceLimit - 6;
          };
      }
      var err = new Error();
  
      if (typeof err.stack === "string" &&
          err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) {
          stackFramePattern = /@/;
          formatStack = v8stackFormatter;
          indentStackFrames = true;
          return function captureStackTrace(o) {
              o.stack = new Error().stack;
          };
      }
  
      var hasStackAfterThrow;
      try { throw new Error(); }
      catch(e) {
          hasStackAfterThrow = ("stack" in e);
      }
      if (!("stack" in err) && hasStackAfterThrow &&
          typeof Error.stackTraceLimit === "number") {
          stackFramePattern = v8stackFramePattern;
          formatStack = v8stackFormatter;
          return function captureStackTrace(o) {
              Error.stackTraceLimit = Error.stackTraceLimit + 6;
              try { throw new Error(); }
              catch(e) { o.stack = e.stack; }
              Error.stackTraceLimit = Error.stackTraceLimit - 6;
          };
      }
  
      formatStack = function(stack, error) {
          if (typeof stack === "string") return stack;
  
          if ((typeof error === "object" ||
              typeof error === "function") &&
              error.name !== undefined &&
              error.message !== undefined) {
              return error.toString();
          }
          return formatNonError(error);
      };
  
      return null;
  
  })([]);
  
  var fireDomEvent;
  var fireGlobalEvent = (function() {
      if (util.isNode) {
          return function(name, reason, promise) {
              if (name === "rejectionHandled") {
                  return process.emit(name, promise);
              } else {
                  return process.emit(name, reason, promise);
              }
          };
      } else {
          var customEventWorks = false;
          var anyEventWorks = true;
          try {
              var ev = new self.CustomEvent("test");
              customEventWorks = ev instanceof CustomEvent;
          } catch (e) {}
          if (!customEventWorks) {
              try {
                  var event = document.createEvent("CustomEvent");
                  event.initCustomEvent("testingtheevent", false, true, {});
                  self.dispatchEvent(event);
              } catch (e) {
                  anyEventWorks = false;
              }
          }
          if (anyEventWorks) {
              fireDomEvent = function(type, detail) {
                  var event;
                  if (customEventWorks) {
                      event = new self.CustomEvent(type, {
                          detail: detail,
                          bubbles: false,
                          cancelable: true
                      });
                  } else if (self.dispatchEvent) {
                      event = document.createEvent("CustomEvent");
                      event.initCustomEvent(type, false, true, detail);
                  }
  
                  return event ? !self.dispatchEvent(event) : false;
              };
          }
  
          var toWindowMethodNameMap = {};
          toWindowMethodNameMap["unhandledRejection"] = ("on" +
              "unhandledRejection").toLowerCase();
          toWindowMethodNameMap["rejectionHandled"] = ("on" +
              "rejectionHandled").toLowerCase();
  
          return function(name, reason, promise) {
              var methodName = toWindowMethodNameMap[name];
              var method = self[methodName];
              if (!method) return false;
              if (name === "rejectionHandled") {
                  method.call(self, promise);
              } else {
                  method.call(self, reason, promise);
              }
              return true;
          };
      }
  })();
  
  if (typeof console !== "undefined" && typeof console.warn !== "undefined") {
      warn = function (message) {
          console.warn(message);
      };
      if (util.isNode && process.stderr.isTTY) {
          warn = function(message) {
              process.stderr.write("\u001b[31m" + message + "\u001b[39m\n");
          };
      } else if (!util.isNode && typeof (new Error().stack) === "string") {
          warn = function(message) {
              console.warn("%c" + message, "color: red");
          };
      }
  }
  
  return CapturedTrace;
  };
  
  },{"./async.js":2,"./util.js":38}],8:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(NEXT_FILTER) {
  var util = _dereq_("./util.js");
  var errors = _dereq_("./errors.js");
  var tryCatch = util.tryCatch;
  var errorObj = util.errorObj;
  var keys = _dereq_("./es5.js").keys;
  var TypeError = errors.TypeError;
  
  function CatchFilter(instances, callback, promise) {
      this._instances = instances;
      this._callback = callback;
      this._promise = promise;
  }
  
  function safePredicate(predicate, e) {
      var safeObject = {};
      var retfilter = tryCatch(predicate).call(safeObject, e);
  
      if (retfilter === errorObj) return retfilter;
  
      var safeKeys = keys(safeObject);
      if (safeKeys.length) {
          errorObj.e = new TypeError("Catch filter must inherit from Error or be a simple predicate function\u000a\u000a    See http://goo.gl/o84o68\u000a");
          return errorObj;
      }
      return retfilter;
  }
  
  CatchFilter.prototype.doFilter = function (e) {
      var cb = this._callback;
      var promise = this._promise;
      var boundTo = promise._boundValue();
      for (var i = 0, len = this._instances.length; i < len; ++i) {
          var item = this._instances[i];
          var itemIsErrorType = item === Error ||
              (item != null && item.prototype instanceof Error);
  
          if (itemIsErrorType && e instanceof item) {
              var ret = tryCatch(cb).call(boundTo, e);
              if (ret === errorObj) {
                  NEXT_FILTER.e = ret.e;
                  return NEXT_FILTER;
              }
              return ret;
          } else if (typeof item === "function" && !itemIsErrorType) {
              var shouldHandle = safePredicate(item, e);
              if (shouldHandle === errorObj) {
                  e = errorObj.e;
                  break;
              } else if (shouldHandle) {
                  var ret = tryCatch(cb).call(boundTo, e);
                  if (ret === errorObj) {
                      NEXT_FILTER.e = ret.e;
                      return NEXT_FILTER;
                  }
                  return ret;
              }
          }
      }
      NEXT_FILTER.e = e;
      return NEXT_FILTER;
  };
  
  return CatchFilter;
  };
  
  },{"./errors.js":13,"./es5.js":14,"./util.js":38}],9:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise, CapturedTrace, isDebugging) {
  var contextStack = [];
  function Context() {
      this._trace = new CapturedTrace(peekContext());
  }
  Context.prototype._pushContext = function () {
      if (!isDebugging()) return;
      if (this._trace !== undefined) {
          contextStack.push(this._trace);
      }
  };
  
  Context.prototype._popContext = function () {
      if (!isDebugging()) return;
      if (this._trace !== undefined) {
          contextStack.pop();
      }
  };
  
  function createContext() {
      if (isDebugging()) return new Context();
  }
  
  function peekContext() {
      var lastIndex = contextStack.length - 1;
      if (lastIndex >= 0) {
          return contextStack[lastIndex];
      }
      return undefined;
  }
  
  Promise.prototype._peekContext = peekContext;
  Promise.prototype._pushContext = Context.prototype._pushContext;
  Promise.prototype._popContext = Context.prototype._popContext;
  
  return createContext;
  };
  
  },{}],10:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise, CapturedTrace) {
  var getDomain = Promise._getDomain;
  var async = _dereq_("./async.js");
  var Warning = _dereq_("./errors.js").Warning;
  var util = _dereq_("./util.js");
  var canAttachTrace = util.canAttachTrace;
  var unhandledRejectionHandled;
  var possiblyUnhandledRejection;
  var debugging = false || (util.isNode &&
                      (!!process.env["BLUEBIRD_DEBUG"] ||
                       process.env["NODE_ENV"] === "development"));
  
  if (util.isNode && process.env["BLUEBIRD_DEBUG"] == 0) debugging = false;
  
  if (debugging) {
      async.disableTrampolineIfNecessary();
  }
  
  Promise.prototype._ignoreRejections = function() {
      this._unsetRejectionIsUnhandled();
      this._bitField = this._bitField | 16777216;
  };
  
  Promise.prototype._ensurePossibleRejectionHandled = function () {
      if ((this._bitField & 16777216) !== 0) return;
      this._setRejectionIsUnhandled();
      async.invokeLater(this._notifyUnhandledRejection, this, undefined);
  };
  
  Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
      CapturedTrace.fireRejectionEvent("rejectionHandled",
                                    unhandledRejectionHandled, undefined, this);
  };
  
  Promise.prototype._notifyUnhandledRejection = function () {
      if (this._isRejectionUnhandled()) {
          var reason = this._getCarriedStackTrace() || this._settledValue;
          this._setUnhandledRejectionIsNotified();
          CapturedTrace.fireRejectionEvent("unhandledRejection",
                                        possiblyUnhandledRejection, reason, this);
      }
  };
  
  Promise.prototype._setUnhandledRejectionIsNotified = function () {
      this._bitField = this._bitField | 524288;
  };
  
  Promise.prototype._unsetUnhandledRejectionIsNotified = function () {
      this._bitField = this._bitField & (~524288);
  };
  
  Promise.prototype._isUnhandledRejectionNotified = function () {
      return (this._bitField & 524288) > 0;
  };
  
  Promise.prototype._setRejectionIsUnhandled = function () {
      this._bitField = this._bitField | 2097152;
  };
  
  Promise.prototype._unsetRejectionIsUnhandled = function () {
      this._bitField = this._bitField & (~2097152);
      if (this._isUnhandledRejectionNotified()) {
          this._unsetUnhandledRejectionIsNotified();
          this._notifyUnhandledRejectionIsHandled();
      }
  };
  
  Promise.prototype._isRejectionUnhandled = function () {
      return (this._bitField & 2097152) > 0;
  };
  
  Promise.prototype._setCarriedStackTrace = function (capturedTrace) {
      this._bitField = this._bitField | 1048576;
      this._fulfillmentHandler0 = capturedTrace;
  };
  
  Promise.prototype._isCarryingStackTrace = function () {
      return (this._bitField & 1048576) > 0;
  };
  
  Promise.prototype._getCarriedStackTrace = function () {
      return this._isCarryingStackTrace()
          ? this._fulfillmentHandler0
          : undefined;
  };
  
  Promise.prototype._captureStackTrace = function () {
      if (debugging) {
          this._trace = new CapturedTrace(this._peekContext());
      }
      return this;
  };
  
  Promise.prototype._attachExtraTrace = function (error, ignoreSelf) {
      if (debugging && canAttachTrace(error)) {
          var trace = this._trace;
          if (trace !== undefined) {
              if (ignoreSelf) trace = trace._parent;
          }
          if (trace !== undefined) {
              trace.attachExtraTrace(error);
          } else if (!error.__stackCleaned__) {
              var parsed = CapturedTrace.parseStackAndMessage(error);
              util.notEnumerableProp(error, "stack",
                  parsed.message + "\n" + parsed.stack.join("\n"));
              util.notEnumerableProp(error, "__stackCleaned__", true);
          }
      }
  };
  
  Promise.prototype._warn = function(message) {
      var warning = new Warning(message);
      var ctx = this._peekContext();
      if (ctx) {
          ctx.attachExtraTrace(warning);
      } else {
          var parsed = CapturedTrace.parseStackAndMessage(warning);
          warning.stack = parsed.message + "\n" + parsed.stack.join("\n");
      }
      CapturedTrace.formatAndLogError(warning, "");
  };
  
  Promise.onPossiblyUnhandledRejection = function (fn) {
      var domain = getDomain();
      possiblyUnhandledRejection =
          typeof fn === "function" ? (domain === null ? fn : domain.bind(fn))
                                   : undefined;
  };
  
  Promise.onUnhandledRejectionHandled = function (fn) {
      var domain = getDomain();
      unhandledRejectionHandled =
          typeof fn === "function" ? (domain === null ? fn : domain.bind(fn))
                                   : undefined;
  };
  
  Promise.longStackTraces = function () {
      if (async.haveItemsQueued() &&
          debugging === false
     ) {
          throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a    See http://goo.gl/DT1qyG\u000a");
      }
      debugging = CapturedTrace.isSupported();
      if (debugging) {
          async.disableTrampolineIfNecessary();
      }
  };
  
  Promise.hasLongStackTraces = function () {
      return debugging && CapturedTrace.isSupported();
  };
  
  if (!CapturedTrace.isSupported()) {
      Promise.longStackTraces = function(){};
      debugging = false;
  }
  
  return function() {
      return debugging;
  };
  };
  
  },{"./async.js":2,"./errors.js":13,"./util.js":38}],11:[function(_dereq_,module,exports){
  "use strict";
  var util = _dereq_("./util.js");
  var isPrimitive = util.isPrimitive;
  
  module.exports = function(Promise) {
  var returner = function () {
      return this;
  };
  var thrower = function () {
      throw this;
  };
  var returnUndefined = function() {};
  var throwUndefined = function() {
      throw undefined;
  };
  
  var wrapper = function (value, action) {
      if (action === 1) {
          return function () {
              throw value;
          };
      } else if (action === 2) {
          return function () {
              return value;
          };
      }
  };
  
  
  Promise.prototype["return"] =
  Promise.prototype.thenReturn = function (value) {
      if (value === undefined) return this.then(returnUndefined);
  
      if (isPrimitive(value)) {
          return this._then(
              wrapper(value, 2),
              undefined,
              undefined,
              undefined,
              undefined
         );
      } else if (value instanceof Promise) {
          value._ignoreRejections();
      }
      return this._then(returner, undefined, undefined, value, undefined);
  };
  
  Promise.prototype["throw"] =
  Promise.prototype.thenThrow = function (reason) {
      if (reason === undefined) return this.then(throwUndefined);
  
      if (isPrimitive(reason)) {
          return this._then(
              wrapper(reason, 1),
              undefined,
              undefined,
              undefined,
              undefined
         );
      }
      return this._then(thrower, undefined, undefined, reason, undefined);
  };
  };
  
  },{"./util.js":38}],12:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise, INTERNAL) {
  var PromiseReduce = Promise.reduce;
  
  Promise.prototype.each = function (fn) {
      return PromiseReduce(this, fn, null, INTERNAL);
  };
  
  Promise.each = function (promises, fn) {
      return PromiseReduce(promises, fn, null, INTERNAL);
  };
  };
  
  },{}],13:[function(_dereq_,module,exports){
  "use strict";
  var es5 = _dereq_("./es5.js");
  var Objectfreeze = es5.freeze;
  var util = _dereq_("./util.js");
  var inherits = util.inherits;
  var notEnumerableProp = util.notEnumerableProp;
  
  function subError(nameProperty, defaultMessage) {
      function SubError(message) {
          if (!(this instanceof SubError)) return new SubError(message);
          notEnumerableProp(this, "message",
              typeof message === "string" ? message : defaultMessage);
          notEnumerableProp(this, "name", nameProperty);
          if (Error.captureStackTrace) {
              Error.captureStackTrace(this, this.constructor);
          } else {
              Error.call(this);
          }
      }
      inherits(SubError, Error);
      return SubError;
  }
  
  var _TypeError, _RangeError;
  var Warning = subError("Warning", "warning");
  var CancellationError = subError("CancellationError", "cancellation error");
  var TimeoutError = subError("TimeoutError", "timeout error");
  var AggregateError = subError("AggregateError", "aggregate error");
  try {
      _TypeError = TypeError;
      _RangeError = RangeError;
  } catch(e) {
      _TypeError = subError("TypeError", "type error");
      _RangeError = subError("RangeError", "range error");
  }
  
  var methods = ("join pop push shift unshift slice filter forEach some " +
      "every map indexOf lastIndexOf reduce reduceRight sort reverse").split(" ");
  
  for (var i = 0; i < methods.length; ++i) {
      if (typeof Array.prototype[methods[i]] === "function") {
          AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];
      }
  }
  
  es5.defineProperty(AggregateError.prototype, "length", {
      value: 0,
      configurable: false,
      writable: true,
      enumerable: true
  });
  AggregateError.prototype["isOperational"] = true;
  var level = 0;
  AggregateError.prototype.toString = function() {
      var indent = Array(level * 4 + 1).join(" ");
      var ret = "\n" + indent + "AggregateError of:" + "\n";
      level++;
      indent = Array(level * 4 + 1).join(" ");
      for (var i = 0; i < this.length; ++i) {
          var str = this[i] === this ? "[Circular AggregateError]" : this[i] + "";
          var lines = str.split("\n");
          for (var j = 0; j < lines.length; ++j) {
              lines[j] = indent + lines[j];
          }
          str = lines.join("\n");
          ret += str + "\n";
      }
      level--;
      return ret;
  };
  
  function OperationalError(message) {
      if (!(this instanceof OperationalError))
          return new OperationalError(message);
      notEnumerableProp(this, "name", "OperationalError");
      notEnumerableProp(this, "message", message);
      this.cause = message;
      this["isOperational"] = true;
  
      if (message instanceof Error) {
          notEnumerableProp(this, "message", message.message);
          notEnumerableProp(this, "stack", message.stack);
      } else if (Error.captureStackTrace) {
          Error.captureStackTrace(this, this.constructor);
      }
  
  }
  inherits(OperationalError, Error);
  
  var errorTypes = Error["__BluebirdErrorTypes__"];
  if (!errorTypes) {
      errorTypes = Objectfreeze({
          CancellationError: CancellationError,
          TimeoutError: TimeoutError,
          OperationalError: OperationalError,
          RejectionError: OperationalError,
          AggregateError: AggregateError
      });
      notEnumerableProp(Error, "__BluebirdErrorTypes__", errorTypes);
  }
  
  module.exports = {
      Error: Error,
      TypeError: _TypeError,
      RangeError: _RangeError,
      CancellationError: errorTypes.CancellationError,
      OperationalError: errorTypes.OperationalError,
      TimeoutError: errorTypes.TimeoutError,
      AggregateError: errorTypes.AggregateError,
      Warning: Warning
  };
  
  },{"./es5.js":14,"./util.js":38}],14:[function(_dereq_,module,exports){
  var isES5 = (function(){
      "use strict";
      return this === undefined;
  })();
  
  if (isES5) {
      module.exports = {
          freeze: Object.freeze,
          defineProperty: Object.defineProperty,
          getDescriptor: Object.getOwnPropertyDescriptor,
          keys: Object.keys,
          names: Object.getOwnPropertyNames,
          getPrototypeOf: Object.getPrototypeOf,
          isArray: Array.isArray,
          isES5: isES5,
          propertyIsWritable: function(obj, prop) {
              var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
              return !!(!descriptor || descriptor.writable || descriptor.set);
          }
      };
  } else {
      var has = {}.hasOwnProperty;
      var str = {}.toString;
      var proto = {}.constructor.prototype;
  
      var ObjectKeys = function (o) {
          var ret = [];
          for (var key in o) {
              if (has.call(o, key)) {
                  ret.push(key);
              }
          }
          return ret;
      };
  
      var ObjectGetDescriptor = function(o, key) {
          return {value: o[key]};
      };
  
      var ObjectDefineProperty = function (o, key, desc) {
          o[key] = desc.value;
          return o;
      };
  
      var ObjectFreeze = function (obj) {
          return obj;
      };
  
      var ObjectGetPrototypeOf = function (obj) {
          try {
              return Object(obj).constructor.prototype;
          }
          catch (e) {
              return proto;
          }
      };
  
      var ArrayIsArray = function (obj) {
          try {
              return str.call(obj) === "[object Array]";
          }
          catch(e) {
              return false;
          }
      };
  
      module.exports = {
          isArray: ArrayIsArray,
          keys: ObjectKeys,
          names: ObjectKeys,
          defineProperty: ObjectDefineProperty,
          getDescriptor: ObjectGetDescriptor,
          freeze: ObjectFreeze,
          getPrototypeOf: ObjectGetPrototypeOf,
          isES5: isES5,
          propertyIsWritable: function() {
              return true;
          }
      };
  }
  
  },{}],15:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise, INTERNAL) {
  var PromiseMap = Promise.map;
  
  Promise.prototype.filter = function (fn, options) {
      return PromiseMap(this, fn, options, INTERNAL);
  };
  
  Promise.filter = function (promises, fn, options) {
      return PromiseMap(promises, fn, options, INTERNAL);
  };
  };
  
  },{}],16:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise, NEXT_FILTER, tryConvertToPromise) {
  var util = _dereq_("./util.js");
  var isPrimitive = util.isPrimitive;
  var thrower = util.thrower;
  
  function returnThis() {
      return this;
  }
  function throwThis() {
      throw this;
  }
  function return$(r) {
      return function() {
          return r;
      };
  }
  function throw$(r) {
      return function() {
          throw r;
      };
  }
  function promisedFinally(ret, reasonOrValue, isFulfilled) {
      var then;
      if (isPrimitive(reasonOrValue)) {
          then = isFulfilled ? return$(reasonOrValue) : throw$(reasonOrValue);
      } else {
          then = isFulfilled ? returnThis : throwThis;
      }
      return ret._then(then, thrower, undefined, reasonOrValue, undefined);
  }
  
  function finallyHandler(reasonOrValue) {
      var promise = this.promise;
      var handler = this.handler;
  
      var ret = promise._isBound()
                      ? handler.call(promise._boundValue())
                      : handler();
  
      if (ret !== undefined) {
          var maybePromise = tryConvertToPromise(ret, promise);
          if (maybePromise instanceof Promise) {
              maybePromise = maybePromise._target();
              return promisedFinally(maybePromise, reasonOrValue,
                                      promise.isFulfilled());
          }
      }
  
      if (promise.isRejected()) {
          NEXT_FILTER.e = reasonOrValue;
          return NEXT_FILTER;
      } else {
          return reasonOrValue;
      }
  }
  
  function tapHandler(value) {
      var promise = this.promise;
      var handler = this.handler;
  
      var ret = promise._isBound()
                      ? handler.call(promise._boundValue(), value)
                      : handler(value);
  
      if (ret !== undefined) {
          var maybePromise = tryConvertToPromise(ret, promise);
          if (maybePromise instanceof Promise) {
              maybePromise = maybePromise._target();
              return promisedFinally(maybePromise, value, true);
          }
      }
      return value;
  }
  
  Promise.prototype._passThroughHandler = function (handler, isFinally) {
      if (typeof handler !== "function") return this.then();
  
      var promiseAndHandler = {
          promise: this,
          handler: handler
      };
  
      return this._then(
              isFinally ? finallyHandler : tapHandler,
              isFinally ? finallyHandler : undefined, undefined,
              promiseAndHandler, undefined);
  };
  
  Promise.prototype.lastly =
  Promise.prototype["finally"] = function (handler) {
      return this._passThroughHandler(handler, true);
  };
  
  Promise.prototype.tap = function (handler) {
      return this._passThroughHandler(handler, false);
  };
  };
  
  },{"./util.js":38}],17:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise,
                            apiRejection,
                            INTERNAL,
                            tryConvertToPromise) {
  var errors = _dereq_("./errors.js");
  var TypeError = errors.TypeError;
  var util = _dereq_("./util.js");
  var errorObj = util.errorObj;
  var tryCatch = util.tryCatch;
  var yieldHandlers = [];
  
  function promiseFromYieldHandler(value, yieldHandlers, traceParent) {
      for (var i = 0; i < yieldHandlers.length; ++i) {
          traceParent._pushContext();
          var result = tryCatch(yieldHandlers[i])(value);
          traceParent._popContext();
          if (result === errorObj) {
              traceParent._pushContext();
              var ret = Promise.reject(errorObj.e);
              traceParent._popContext();
              return ret;
          }
          var maybePromise = tryConvertToPromise(result, traceParent);
          if (maybePromise instanceof Promise) return maybePromise;
      }
      return null;
  }
  
  function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) {
      var promise = this._promise = new Promise(INTERNAL);
      promise._captureStackTrace();
      this._stack = stack;
      this._generatorFunction = generatorFunction;
      this._receiver = receiver;
      this._generator = undefined;
      this._yieldHandlers = typeof yieldHandler === "function"
          ? [yieldHandler].concat(yieldHandlers)
          : yieldHandlers;
  }
  
  PromiseSpawn.prototype.promise = function () {
      return this._promise;
  };
  
  PromiseSpawn.prototype._run = function () {
      this._generator = this._generatorFunction.call(this._receiver);
      this._receiver =
          this._generatorFunction = undefined;
      this._next(undefined);
  };
  
  PromiseSpawn.prototype._continue = function (result) {
      if (result === errorObj) {
          return this._promise._rejectCallback(result.e, false, true);
      }
  
      var value = result.value;
      if (result.done === true) {
          this._promise._resolveCallback(value);
      } else {
          var maybePromise = tryConvertToPromise(value, this._promise);
          if (!(maybePromise instanceof Promise)) {
              maybePromise =
                  promiseFromYieldHandler(maybePromise,
                                          this._yieldHandlers,
                                          this._promise);
              if (maybePromise === null) {
                  this._throw(
                      new TypeError(
                          "A value %s was yielded that could not be treated as a promise\u000a\u000a    See http://goo.gl/4Y4pDk\u000a\u000a".replace("%s", value) +
                          "From coroutine:\u000a" +
                          this._stack.split("\n").slice(1, -7).join("\n")
                      )
                  );
                  return;
              }
          }
          maybePromise._then(
              this._next,
              this._throw,
              undefined,
              this,
              null
         );
      }
  };
  
  PromiseSpawn.prototype._throw = function (reason) {
      this._promise._attachExtraTrace(reason);
      this._promise._pushContext();
      var result = tryCatch(this._generator["throw"])
          .call(this._generator, reason);
      this._promise._popContext();
      this._continue(result);
  };
  
  PromiseSpawn.prototype._next = function (value) {
      this._promise._pushContext();
      var result = tryCatch(this._generator.next).call(this._generator, value);
      this._promise._popContext();
      this._continue(result);
  };
  
  Promise.coroutine = function (generatorFunction, options) {
      if (typeof generatorFunction !== "function") {
          throw new TypeError("generatorFunction must be a function\u000a\u000a    See http://goo.gl/6Vqhm0\u000a");
      }
      var yieldHandler = Object(options).yieldHandler;
      var PromiseSpawn$ = PromiseSpawn;
      var stack = new Error().stack;
      return function () {
          var generator = generatorFunction.apply(this, arguments);
          var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler,
                                        stack);
          spawn._generator = generator;
          spawn._next(undefined);
          return spawn.promise();
      };
  };
  
  Promise.coroutine.addYieldHandler = function(fn) {
      if (typeof fn !== "function") throw new TypeError("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
      yieldHandlers.push(fn);
  };
  
  Promise.spawn = function (generatorFunction) {
      if (typeof generatorFunction !== "function") {
          return apiRejection("generatorFunction must be a function\u000a\u000a    See http://goo.gl/6Vqhm0\u000a");
      }
      var spawn = new PromiseSpawn(generatorFunction, this);
      var ret = spawn.promise();
      spawn._run(Promise.spawn);
      return ret;
  };
  };
  
  },{"./errors.js":13,"./util.js":38}],18:[function(_dereq_,module,exports){
  "use strict";
  module.exports =
  function(Promise, PromiseArray, tryConvertToPromise, INTERNAL) {
  var util = _dereq_("./util.js");
  var canEvaluate = util.canEvaluate;
  var tryCatch = util.tryCatch;
  var errorObj = util.errorObj;
  var reject;
  
  if (!true) {
  if (canEvaluate) {
      var thenCallback = function(i) {
          return new Function("value", "holder", "                             \n\
              'use strict';                                                    \n\
              holder.pIndex = value;                                           \n\
              holder.checkFulfillment(this);                                   \n\
              ".replace(/Index/g, i));
      };
  
      var caller = function(count) {
          var values = [];
          for (var i = 1; i <= count; ++i) values.push("holder.p" + i);
          return new Function("holder", "                                      \n\
              'use strict';                                                    \n\
              var callback = holder.fn;                                        \n\
              return callback(values);                                         \n\
              ".replace(/values/g, values.join(", ")));
      };
      var thenCallbacks = [];
      var callers = [undefined];
      for (var i = 1; i <= 5; ++i) {
          thenCallbacks.push(thenCallback(i));
          callers.push(caller(i));
      }
  
      var Holder = function(total, fn) {
          this.p1 = this.p2 = this.p3 = this.p4 = this.p5 = null;
          this.fn = fn;
          this.total = total;
          this.now = 0;
      };
  
      Holder.prototype.callers = callers;
      Holder.prototype.checkFulfillment = function(promise) {
          var now = this.now;
          now++;
          var total = this.total;
          if (now >= total) {
              var handler = this.callers[total];
              promise._pushContext();
              var ret = tryCatch(handler)(this);
              promise._popContext();
              if (ret === errorObj) {
                  promise._rejectCallback(ret.e, false, true);
              } else {
                  promise._resolveCallback(ret);
              }
          } else {
              this.now = now;
          }
      };
  
      var reject = function (reason) {
          this._reject(reason);
      };
  }
  }
  
  Promise.join = function () {
      var last = arguments.length - 1;
      var fn;
      if (last > 0 && typeof arguments[last] === "function") {
          fn = arguments[last];
          if (!true) {
              if (last < 6 && canEvaluate) {
                  var ret = new Promise(INTERNAL);
                  ret._captureStackTrace();
                  var holder = new Holder(last, fn);
                  var callbacks = thenCallbacks;
                  for (var i = 0; i < last; ++i) {
                      var maybePromise = tryConvertToPromise(arguments[i], ret);
                      if (maybePromise instanceof Promise) {
                          maybePromise = maybePromise._target();
                          if (maybePromise._isPending()) {
                              maybePromise._then(callbacks[i], reject,
                                                 undefined, ret, holder);
                          } else if (maybePromise._isFulfilled()) {
                              callbacks[i].call(ret,
                                                maybePromise._value(), holder);
                          } else {
                              ret._reject(maybePromise._reason());
                          }
                      } else {
                          callbacks[i].call(ret, maybePromise, holder);
                      }
                  }
                  return ret;
              }
          }
      }
      var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];}
      if (fn) args.pop();
      var ret = new PromiseArray(args).promise();
      return fn !== undefined ? ret.spread(fn) : ret;
  };
  
  };
  
  },{"./util.js":38}],19:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise,
                            PromiseArray,
                            apiRejection,
                            tryConvertToPromise,
                            INTERNAL) {
  var getDomain = Promise._getDomain;
  var async = _dereq_("./async.js");
  var util = _dereq_("./util.js");
  var tryCatch = util.tryCatch;
  var errorObj = util.errorObj;
  var PENDING = {};
  var EMPTY_ARRAY = [];
  
  function MappingPromiseArray(promises, fn, limit, _filter) {
      this.constructor$(promises);
      this._promise._captureStackTrace();
      var domain = getDomain();
      this._callback = domain === null ? fn : domain.bind(fn);
      this._preservedValues = _filter === INTERNAL
          ? new Array(this.length())
          : null;
      this._limit = limit;
      this._inFlight = 0;
      this._queue = limit >= 1 ? [] : EMPTY_ARRAY;
      async.invoke(init, this, undefined);
  }
  util.inherits(MappingPromiseArray, PromiseArray);
  function init() {this._init$(undefined, -2);}
  
  MappingPromiseArray.prototype._init = function () {};
  
  MappingPromiseArray.prototype._promiseFulfilled = function (value, index) {
      var values = this._values;
      var length = this.length();
      var preservedValues = this._preservedValues;
      var limit = this._limit;
      if (values[index] === PENDING) {
          values[index] = value;
          if (limit >= 1) {
              this._inFlight--;
              this._drainQueue();
              if (this._isResolved()) return;
          }
      } else {
          if (limit >= 1 && this._inFlight >= limit) {
              values[index] = value;
              this._queue.push(index);
              return;
          }
          if (preservedValues !== null) preservedValues[index] = value;
  
          var callback = this._callback;
          var receiver = this._promise._boundValue();
          this._promise._pushContext();
          var ret = tryCatch(callback).call(receiver, value, index, length);
          this._promise._popContext();
          if (ret === errorObj) return this._reject(ret.e);
  
          var maybePromise = tryConvertToPromise(ret, this._promise);
          if (maybePromise instanceof Promise) {
              maybePromise = maybePromise._target();
              if (maybePromise._isPending()) {
                  if (limit >= 1) this._inFlight++;
                  values[index] = PENDING;
                  return maybePromise._proxyPromiseArray(this, index);
              } else if (maybePromise._isFulfilled()) {
                  ret = maybePromise._value();
              } else {
                  return this._reject(maybePromise._reason());
              }
          }
          values[index] = ret;
      }
      var totalResolved = ++this._totalResolved;
      if (totalResolved >= length) {
          if (preservedValues !== null) {
              this._filter(values, preservedValues);
          } else {
              this._resolve(values);
          }
  
      }
  };
  
  MappingPromiseArray.prototype._drainQueue = function () {
      var queue = this._queue;
      var limit = this._limit;
      var values = this._values;
      while (queue.length > 0 && this._inFlight < limit) {
          if (this._isResolved()) return;
          var index = queue.pop();
          this._promiseFulfilled(values[index], index);
      }
  };
  
  MappingPromiseArray.prototype._filter = function (booleans, values) {
      var len = values.length;
      var ret = new Array(len);
      var j = 0;
      for (var i = 0; i < len; ++i) {
          if (booleans[i]) ret[j++] = values[i];
      }
      ret.length = j;
      this._resolve(ret);
  };
  
  MappingPromiseArray.prototype.preservedValues = function () {
      return this._preservedValues;
  };
  
  function map(promises, fn, options, _filter) {
      var limit = typeof options === "object" && options !== null
          ? options.concurrency
          : 0;
      limit = typeof limit === "number" &&
          isFinite(limit) && limit >= 1 ? limit : 0;
      return new MappingPromiseArray(promises, fn, limit, _filter);
  }
  
  Promise.prototype.map = function (fn, options) {
      if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
  
      return map(this, fn, options, null).promise();
  };
  
  Promise.map = function (promises, fn, options, _filter) {
      if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
      return map(promises, fn, options, _filter).promise();
  };
  
  
  };
  
  },{"./async.js":2,"./util.js":38}],20:[function(_dereq_,module,exports){
  "use strict";
  module.exports =
  function(Promise, INTERNAL, tryConvertToPromise, apiRejection) {
  var util = _dereq_("./util.js");
  var tryCatch = util.tryCatch;
  
  Promise.method = function (fn) {
      if (typeof fn !== "function") {
          throw new Promise.TypeError("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
      }
      return function () {
          var ret = new Promise(INTERNAL);
          ret._captureStackTrace();
          ret._pushContext();
          var value = tryCatch(fn).apply(this, arguments);
          ret._popContext();
          ret._resolveFromSyncValue(value);
          return ret;
      };
  };
  
  Promise.attempt = Promise["try"] = function (fn, args, ctx) {
      if (typeof fn !== "function") {
          return apiRejection("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
      }
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._pushContext();
      var value = util.isArray(args)
          ? tryCatch(fn).apply(ctx, args)
          : tryCatch(fn).call(ctx, args);
      ret._popContext();
      ret._resolveFromSyncValue(value);
      return ret;
  };
  
  Promise.prototype._resolveFromSyncValue = function (value) {
      if (value === util.errorObj) {
          this._rejectCallback(value.e, false, true);
      } else {
          this._resolveCallback(value, true);
      }
  };
  };
  
  },{"./util.js":38}],21:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise) {
  var util = _dereq_("./util.js");
  var async = _dereq_("./async.js");
  var tryCatch = util.tryCatch;
  var errorObj = util.errorObj;
  
  function spreadAdapter(val, nodeback) {
      var promise = this;
      if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback);
      var ret =
          tryCatch(nodeback).apply(promise._boundValue(), [null].concat(val));
      if (ret === errorObj) {
          async.throwLater(ret.e);
      }
  }
  
  function successAdapter(val, nodeback) {
      var promise = this;
      var receiver = promise._boundValue();
      var ret = val === undefined
          ? tryCatch(nodeback).call(receiver, null)
          : tryCatch(nodeback).call(receiver, null, val);
      if (ret === errorObj) {
          async.throwLater(ret.e);
      }
  }
  function errorAdapter(reason, nodeback) {
      var promise = this;
      if (!reason) {
          var target = promise._target();
          var newReason = target._getCarriedStackTrace();
          newReason.cause = reason;
          reason = newReason;
      }
      var ret = tryCatch(nodeback).call(promise._boundValue(), reason);
      if (ret === errorObj) {
          async.throwLater(ret.e);
      }
  }
  
  Promise.prototype.asCallback =
  Promise.prototype.nodeify = function (nodeback, options) {
      if (typeof nodeback == "function") {
          var adapter = successAdapter;
          if (options !== undefined && Object(options).spread) {
              adapter = spreadAdapter;
          }
          this._then(
              adapter,
              errorAdapter,
              undefined,
              this,
              nodeback
          );
      }
      return this;
  };
  };
  
  },{"./async.js":2,"./util.js":38}],22:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise, PromiseArray) {
  var util = _dereq_("./util.js");
  var async = _dereq_("./async.js");
  var tryCatch = util.tryCatch;
  var errorObj = util.errorObj;
  
  Promise.prototype.progressed = function (handler) {
      return this._then(undefined, undefined, handler, undefined, undefined);
  };
  
  Promise.prototype._progress = function (progressValue) {
      if (this._isFollowingOrFulfilledOrRejected()) return;
      this._target()._progressUnchecked(progressValue);
  
  };
  
  Promise.prototype._progressHandlerAt = function (index) {
      return index === 0
          ? this._progressHandler0
          : this[(index << 2) + index - 5 + 2];
  };
  
  Promise.prototype._doProgressWith = function (progression) {
      var progressValue = progression.value;
      var handler = progression.handler;
      var promise = progression.promise;
      var receiver = progression.receiver;
  
      var ret = tryCatch(handler).call(receiver, progressValue);
      if (ret === errorObj) {
          if (ret.e != null &&
              ret.e.name !== "StopProgressPropagation") {
              var trace = util.canAttachTrace(ret.e)
                  ? ret.e : new Error(util.toString(ret.e));
              promise._attachExtraTrace(trace);
              promise._progress(ret.e);
          }
      } else if (ret instanceof Promise) {
          ret._then(promise._progress, null, null, promise, undefined);
      } else {
          promise._progress(ret);
      }
  };
  
  
  Promise.prototype._progressUnchecked = function (progressValue) {
      var len = this._length();
      var progress = this._progress;
      for (var i = 0; i < len; i++) {
          var handler = this._progressHandlerAt(i);
          var promise = this._promiseAt(i);
          if (!(promise instanceof Promise)) {
              var receiver = this._receiverAt(i);
              if (typeof handler === "function") {
                  handler.call(receiver, progressValue, promise);
              } else if (receiver instanceof PromiseArray &&
                         !receiver._isResolved()) {
                  receiver._promiseProgressed(progressValue, promise);
              }
              continue;
          }
  
          if (typeof handler === "function") {
              async.invoke(this._doProgressWith, this, {
                  handler: handler,
                  promise: promise,
                  receiver: this._receiverAt(i),
                  value: progressValue
              });
          } else {
              async.invoke(progress, promise, progressValue);
          }
      }
  };
  };
  
  },{"./async.js":2,"./util.js":38}],23:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function() {
  var makeSelfResolutionError = function () {
      return new TypeError("circular promise resolution chain\u000a\u000a    See http://goo.gl/LhFpo0\u000a");
  };
  var reflect = function() {
      return new Promise.PromiseInspection(this._target());
  };
  var apiRejection = function(msg) {
      return Promise.reject(new TypeError(msg));
  };
  
  var util = _dereq_("./util.js");
  
  var getDomain;
  if (util.isNode) {
      getDomain = function() {
          var ret = process.domain;
          if (ret === undefined) ret = null;
          return ret;
      };
  } else {
      getDomain = function() {
          return null;
      };
  }
  util.notEnumerableProp(Promise, "_getDomain", getDomain);
  
  var UNDEFINED_BINDING = {};
  var async = _dereq_("./async.js");
  var errors = _dereq_("./errors.js");
  var TypeError = Promise.TypeError = errors.TypeError;
  Promise.RangeError = errors.RangeError;
  Promise.CancellationError = errors.CancellationError;
  Promise.TimeoutError = errors.TimeoutError;
  Promise.OperationalError = errors.OperationalError;
  Promise.RejectionError = errors.OperationalError;
  Promise.AggregateError = errors.AggregateError;
  var INTERNAL = function(){};
  var APPLY = {};
  var NEXT_FILTER = {e: null};
  var tryConvertToPromise = _dereq_("./thenables.js")(Promise, INTERNAL);
  var PromiseArray =
      _dereq_("./promise_array.js")(Promise, INTERNAL,
                                      tryConvertToPromise, apiRejection);
  var CapturedTrace = _dereq_("./captured_trace.js")();
  var isDebugging = _dereq_("./debuggability.js")(Promise, CapturedTrace);
   /*jshint unused:false*/
  var createContext =
      _dereq_("./context.js")(Promise, CapturedTrace, isDebugging);
  var CatchFilter = _dereq_("./catch_filter.js")(NEXT_FILTER);
  var PromiseResolver = _dereq_("./promise_resolver.js");
  var nodebackForPromise = PromiseResolver._nodebackForPromise;
  var errorObj = util.errorObj;
  var tryCatch = util.tryCatch;
  
  function Promise(resolver) {
      if (typeof resolver !== "function") {
          throw new TypeError("the promise constructor requires a resolver function\u000a\u000a    See http://goo.gl/EC22Yn\u000a");
      }
      if (this.constructor !== Promise) {
          throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a    See http://goo.gl/KsIlge\u000a");
      }
      this._bitField = 0;
      this._fulfillmentHandler0 = undefined;
      this._rejectionHandler0 = undefined;
      this._progressHandler0 = undefined;
      this._promise0 = undefined;
      this._receiver0 = undefined;
      this._settledValue = undefined;
      if (resolver !== INTERNAL) this._resolveFromResolver(resolver);
  }
  
  Promise.prototype.toString = function () {
      return "[object Promise]";
  };
  
  Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
      var len = arguments.length;
      if (len > 1) {
          var catchInstances = new Array(len - 1),
              j = 0, i;
          for (i = 0; i < len - 1; ++i) {
              var item = arguments[i];
              if (typeof item === "function") {
                  catchInstances[j++] = item;
              } else {
                  return Promise.reject(
                      new TypeError("Catch filter must inherit from Error or be a simple predicate function\u000a\u000a    See http://goo.gl/o84o68\u000a"));
              }
          }
          catchInstances.length = j;
          fn = arguments[i];
          var catchFilter = new CatchFilter(catchInstances, fn, this);
          return this._then(undefined, catchFilter.doFilter, undefined,
              catchFilter, undefined);
      }
      return this._then(undefined, fn, undefined, undefined, undefined);
  };
  
  Promise.prototype.reflect = function () {
      return this._then(reflect, reflect, undefined, this, undefined);
  };
  
  Promise.prototype.then = function (didFulfill, didReject, didProgress) {
      if (isDebugging() && arguments.length > 0 &&
          typeof didFulfill !== "function" &&
          typeof didReject !== "function") {
          var msg = ".then() only accepts functions but was passed: " +
                  util.classString(didFulfill);
          if (arguments.length > 1) {
              msg += ", " + util.classString(didReject);
          }
          this._warn(msg);
      }
      return this._then(didFulfill, didReject, didProgress,
          undefined, undefined);
  };
  
  Promise.prototype.done = function (didFulfill, didReject, didProgress) {
      var promise = this._then(didFulfill, didReject, didProgress,
          undefined, undefined);
      promise._setIsFinal();
  };
  
  Promise.prototype.spread = function (didFulfill, didReject) {
      return this.all()._then(didFulfill, didReject, undefined, APPLY, undefined);
  };
  
  Promise.prototype.isCancellable = function () {
      return !this.isResolved() &&
          this._cancellable();
  };
  
  Promise.prototype.toJSON = function () {
      var ret = {
          isFulfilled: false,
          isRejected: false,
          fulfillmentValue: undefined,
          rejectionReason: undefined
      };
      if (this.isFulfilled()) {
          ret.fulfillmentValue = this.value();
          ret.isFulfilled = true;
      } else if (this.isRejected()) {
          ret.rejectionReason = this.reason();
          ret.isRejected = true;
      }
      return ret;
  };
  
  Promise.prototype.all = function () {
      return new PromiseArray(this).promise();
  };
  
  Promise.prototype.error = function (fn) {
      return this.caught(util.originatesFromRejection, fn);
  };
  
  Promise.getNewLibraryCopy = module.exports;
  
  Promise.is = function (val) {
      return val instanceof Promise;
  };
  
  Promise.fromNode = function(fn) {
      var ret = new Promise(INTERNAL);
      var result = tryCatch(fn)(nodebackForPromise(ret));
      if (result === errorObj) {
          ret._rejectCallback(result.e, true, true);
      }
      return ret;
  };
  
  Promise.all = function (promises) {
      return new PromiseArray(promises).promise();
  };
  
  Promise.defer = Promise.pending = function () {
      var promise = new Promise(INTERNAL);
      return new PromiseResolver(promise);
  };
  
  Promise.cast = function (obj) {
      var ret = tryConvertToPromise(obj);
      if (!(ret instanceof Promise)) {
          var val = ret;
          ret = new Promise(INTERNAL);
          ret._fulfillUnchecked(val);
      }
      return ret;
  };
  
  Promise.resolve = Promise.fulfilled = Promise.cast;
  
  Promise.reject = Promise.rejected = function (reason) {
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._rejectCallback(reason, true);
      return ret;
  };
  
  Promise.setScheduler = function(fn) {
      if (typeof fn !== "function") throw new TypeError("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
      var prev = async._schedule;
      async._schedule = fn;
      return prev;
  };
  
  Promise.prototype._then = function (
      didFulfill,
      didReject,
      didProgress,
      receiver,
      internalData
  ) {
      var haveInternalData = internalData !== undefined;
      var ret = haveInternalData ? internalData : new Promise(INTERNAL);
  
      if (!haveInternalData) {
          ret._propagateFrom(this, 4 | 1);
          ret._captureStackTrace();
      }
  
      var target = this._target();
      if (target !== this) {
          if (receiver === undefined) receiver = this._boundTo;
          if (!haveInternalData) ret._setIsMigrated();
      }
  
      var callbackIndex = target._addCallbacks(didFulfill,
                                               didReject,
                                               didProgress,
                                               ret,
                                               receiver,
                                               getDomain());
  
      if (target._isResolved() && !target._isSettlePromisesQueued()) {
          async.invoke(
              target._settlePromiseAtPostResolution, target, callbackIndex);
      }
  
      return ret;
  };
  
  Promise.prototype._settlePromiseAtPostResolution = function (index) {
      if (this._isRejectionUnhandled()) this._unsetRejectionIsUnhandled();
      this._settlePromiseAt(index);
  };
  
  Promise.prototype._length = function () {
      return this._bitField & 131071;
  };
  
  Promise.prototype._isFollowingOrFulfilledOrRejected = function () {
      return (this._bitField & 939524096) > 0;
  };
  
  Promise.prototype._isFollowing = function () {
      return (this._bitField & 536870912) === 536870912;
  };
  
  Promise.prototype._setLength = function (len) {
      this._bitField = (this._bitField & -131072) |
          (len & 131071);
  };
  
  Promise.prototype._setFulfilled = function () {
      this._bitField = this._bitField | 268435456;
  };
  
  Promise.prototype._setRejected = function () {
      this._bitField = this._bitField | 134217728;
  };
  
  Promise.prototype._setFollowing = function () {
      this._bitField = this._bitField | 536870912;
  };
  
  Promise.prototype._setIsFinal = function () {
      this._bitField = this._bitField | 33554432;
  };
  
  Promise.prototype._isFinal = function () {
      return (this._bitField & 33554432) > 0;
  };
  
  Promise.prototype._cancellable = function () {
      return (this._bitField & 67108864) > 0;
  };
  
  Promise.prototype._setCancellable = function () {
      this._bitField = this._bitField | 67108864;
  };
  
  Promise.prototype._unsetCancellable = function () {
      this._bitField = this._bitField & (~67108864);
  };
  
  Promise.prototype._setIsMigrated = function () {
      this._bitField = this._bitField | 4194304;
  };
  
  Promise.prototype._unsetIsMigrated = function () {
      this._bitField = this._bitField & (~4194304);
  };
  
  Promise.prototype._isMigrated = function () {
      return (this._bitField & 4194304) > 0;
  };
  
  Promise.prototype._receiverAt = function (index) {
      var ret = index === 0
          ? this._receiver0
          : this[
              index * 5 - 5 + 4];
      if (ret === UNDEFINED_BINDING) {
          return undefined;
      } else if (ret === undefined && this._isBound()) {
          return this._boundValue();
      }
      return ret;
  };
  
  Promise.prototype._promiseAt = function (index) {
      return index === 0
          ? this._promise0
          : this[index * 5 - 5 + 3];
  };
  
  Promise.prototype._fulfillmentHandlerAt = function (index) {
      return index === 0
          ? this._fulfillmentHandler0
          : this[index * 5 - 5 + 0];
  };
  
  Promise.prototype._rejectionHandlerAt = function (index) {
      return index === 0
          ? this._rejectionHandler0
          : this[index * 5 - 5 + 1];
  };
  
  Promise.prototype._boundValue = function() {
      var ret = this._boundTo;
      if (ret !== undefined) {
          if (ret instanceof Promise) {
              if (ret.isFulfilled()) {
                  return ret.value();
              } else {
                  return undefined;
              }
          }
      }
      return ret;
  };
  
  Promise.prototype._migrateCallbacks = function (follower, index) {
      var fulfill = follower._fulfillmentHandlerAt(index);
      var reject = follower._rejectionHandlerAt(index);
      var progress = follower._progressHandlerAt(index);
      var promise = follower._promiseAt(index);
      var receiver = follower._receiverAt(index);
      if (promise instanceof Promise) promise._setIsMigrated();
      if (receiver === undefined) receiver = UNDEFINED_BINDING;
      this._addCallbacks(fulfill, reject, progress, promise, receiver, null);
  };
  
  Promise.prototype._addCallbacks = function (
      fulfill,
      reject,
      progress,
      promise,
      receiver,
      domain
  ) {
      var index = this._length();
  
      if (index >= 131071 - 5) {
          index = 0;
          this._setLength(0);
      }
  
      if (index === 0) {
          this._promise0 = promise;
          if (receiver !== undefined) this._receiver0 = receiver;
          if (typeof fulfill === "function" && !this._isCarryingStackTrace()) {
              this._fulfillmentHandler0 =
                  domain === null ? fulfill : domain.bind(fulfill);
          }
          if (typeof reject === "function") {
              this._rejectionHandler0 =
                  domain === null ? reject : domain.bind(reject);
          }
          if (typeof progress === "function") {
              this._progressHandler0 =
                  domain === null ? progress : domain.bind(progress);
          }
      } else {
          var base = index * 5 - 5;
          this[base + 3] = promise;
          this[base + 4] = receiver;
          if (typeof fulfill === "function") {
              this[base + 0] =
                  domain === null ? fulfill : domain.bind(fulfill);
          }
          if (typeof reject === "function") {
              this[base + 1] =
                  domain === null ? reject : domain.bind(reject);
          }
          if (typeof progress === "function") {
              this[base + 2] =
                  domain === null ? progress : domain.bind(progress);
          }
      }
      this._setLength(index + 1);
      return index;
  };
  
  Promise.prototype._setProxyHandlers = function (receiver, promiseSlotValue) {
      var index = this._length();
  
      if (index >= 131071 - 5) {
          index = 0;
          this._setLength(0);
      }
      if (index === 0) {
          this._promise0 = promiseSlotValue;
          this._receiver0 = receiver;
      } else {
          var base = index * 5 - 5;
          this[base + 3] = promiseSlotValue;
          this[base + 4] = receiver;
      }
      this._setLength(index + 1);
  };
  
  Promise.prototype._proxyPromiseArray = function (promiseArray, index) {
      this._setProxyHandlers(promiseArray, index);
  };
  
  Promise.prototype._resolveCallback = function(value, shouldBind) {
      if (this._isFollowingOrFulfilledOrRejected()) return;
      if (value === this)
          return this._rejectCallback(makeSelfResolutionError(), false, true);
      var maybePromise = tryConvertToPromise(value, this);
      if (!(maybePromise instanceof Promise)) return this._fulfill(value);
  
      var propagationFlags = 1 | (shouldBind ? 4 : 0);
      this._propagateFrom(maybePromise, propagationFlags);
      var promise = maybePromise._target();
      if (promise._isPending()) {
          var len = this._length();
          for (var i = 0; i < len; ++i) {
              promise._migrateCallbacks(this, i);
          }
          this._setFollowing();
          this._setLength(0);
          this._setFollowee(promise);
      } else if (promise._isFulfilled()) {
          this._fulfillUnchecked(promise._value());
      } else {
          this._rejectUnchecked(promise._reason(),
              promise._getCarriedStackTrace());
      }
  };
  
  Promise.prototype._rejectCallback =
  function(reason, synchronous, shouldNotMarkOriginatingFromRejection) {
      if (!shouldNotMarkOriginatingFromRejection) {
          util.markAsOriginatingFromRejection(reason);
      }
      var trace = util.ensureErrorObject(reason);
      var hasStack = trace === reason;
      this._attachExtraTrace(trace, synchronous ? hasStack : false);
      this._reject(reason, hasStack ? undefined : trace);
  };
  
  Promise.prototype._resolveFromResolver = function (resolver) {
      var promise = this;
      this._captureStackTrace();
      this._pushContext();
      var synchronous = true;
      var r = tryCatch(resolver)(function(value) {
          if (promise === null) return;
          promise._resolveCallback(value);
          promise = null;
      }, function (reason) {
          if (promise === null) return;
          promise._rejectCallback(reason, synchronous);
          promise = null;
      });
      synchronous = false;
      this._popContext();
  
      if (r !== undefined && r === errorObj && promise !== null) {
          promise._rejectCallback(r.e, true, true);
          promise = null;
      }
  };
  
  Promise.prototype._settlePromiseFromHandler = function (
      handler, receiver, value, promise
  ) {
      if (promise._isRejected()) return;
      promise._pushContext();
      var x;
      if (receiver === APPLY && !this._isRejected()) {
          x = tryCatch(handler).apply(this._boundValue(), value);
      } else {
          x = tryCatch(handler).call(receiver, value);
      }
      promise._popContext();
  
      if (x === errorObj || x === promise || x === NEXT_FILTER) {
          var err = x === promise ? makeSelfResolutionError() : x.e;
          promise._rejectCallback(err, false, true);
      } else {
          promise._resolveCallback(x);
      }
  };
  
  Promise.prototype._target = function() {
      var ret = this;
      while (ret._isFollowing()) ret = ret._followee();
      return ret;
  };
  
  Promise.prototype._followee = function() {
      return this._rejectionHandler0;
  };
  
  Promise.prototype._setFollowee = function(promise) {
      this._rejectionHandler0 = promise;
  };
  
  Promise.prototype._cleanValues = function () {
      if (this._cancellable()) {
          this._cancellationParent = undefined;
      }
  };
  
  Promise.prototype._propagateFrom = function (parent, flags) {
      if ((flags & 1) > 0 && parent._cancellable()) {
          this._setCancellable();
          this._cancellationParent = parent;
      }
      if ((flags & 4) > 0 && parent._isBound()) {
          this._setBoundTo(parent._boundTo);
      }
  };
  
  Promise.prototype._fulfill = function (value) {
      if (this._isFollowingOrFulfilledOrRejected()) return;
      this._fulfillUnchecked(value);
  };
  
  Promise.prototype._reject = function (reason, carriedStackTrace) {
      if (this._isFollowingOrFulfilledOrRejected()) return;
      this._rejectUnchecked(reason, carriedStackTrace);
  };
  
  Promise.prototype._settlePromiseAt = function (index) {
      var promise = this._promiseAt(index);
      var isPromise = promise instanceof Promise;
  
      if (isPromise && promise._isMigrated()) {
          promise._unsetIsMigrated();
          return async.invoke(this._settlePromiseAt, this, index);
      }
      var handler = this._isFulfilled()
          ? this._fulfillmentHandlerAt(index)
          : this._rejectionHandlerAt(index);
  
      var carriedStackTrace =
          this._isCarryingStackTrace() ? this._getCarriedStackTrace() : undefined;
      var value = this._settledValue;
      var receiver = this._receiverAt(index);
      this._clearCallbackDataAtIndex(index);
  
      if (typeof handler === "function") {
          if (!isPromise) {
              handler.call(receiver, value, promise);
          } else {
              this._settlePromiseFromHandler(handler, receiver, value, promise);
          }
      } else if (receiver instanceof PromiseArray) {
          if (!receiver._isResolved()) {
              if (this._isFulfilled()) {
                  receiver._promiseFulfilled(value, promise);
              }
              else {
                  receiver._promiseRejected(value, promise);
              }
          }
      } else if (isPromise) {
          if (this._isFulfilled()) {
              promise._fulfill(value);
          } else {
              promise._reject(value, carriedStackTrace);
          }
      }
  
      if (index >= 4 && (index & 31) === 4)
          async.invokeLater(this._setLength, this, 0);
  };
  
  Promise.prototype._clearCallbackDataAtIndex = function(index) {
      if (index === 0) {
          if (!this._isCarryingStackTrace()) {
              this._fulfillmentHandler0 = undefined;
          }
          this._rejectionHandler0 =
          this._progressHandler0 =
          this._receiver0 =
          this._promise0 = undefined;
      } else {
          var base = index * 5 - 5;
          this[base + 3] =
          this[base + 4] =
          this[base + 0] =
          this[base + 1] =
          this[base + 2] = undefined;
      }
  };
  
  Promise.prototype._isSettlePromisesQueued = function () {
      return (this._bitField &
              -1073741824) === -1073741824;
  };
  
  Promise.prototype._setSettlePromisesQueued = function () {
      this._bitField = this._bitField | -1073741824;
  };
  
  Promise.prototype._unsetSettlePromisesQueued = function () {
      this._bitField = this._bitField & (~-1073741824);
  };
  
  Promise.prototype._queueSettlePromises = function() {
      async.settlePromises(this);
      this._setSettlePromisesQueued();
  };
  
  Promise.prototype._fulfillUnchecked = function (value) {
      if (value === this) {
          var err = makeSelfResolutionError();
          this._attachExtraTrace(err);
          return this._rejectUnchecked(err, undefined);
      }
      this._setFulfilled();
      this._settledValue = value;
      this._cleanValues();
  
      if (this._length() > 0) {
          this._queueSettlePromises();
      }
  };
  
  Promise.prototype._rejectUncheckedCheckError = function (reason) {
      var trace = util.ensureErrorObject(reason);
      this._rejectUnchecked(reason, trace === reason ? undefined : trace);
  };
  
  Promise.prototype._rejectUnchecked = function (reason, trace) {
      if (reason === this) {
          var err = makeSelfResolutionError();
          this._attachExtraTrace(err);
          return this._rejectUnchecked(err);
      }
      this._setRejected();
      this._settledValue = reason;
      this._cleanValues();
  
      if (this._isFinal()) {
          async.throwLater(function(e) {
              if ("stack" in e) {
                  async.invokeFirst(
                      CapturedTrace.unhandledRejection, undefined, e);
              }
              throw e;
          }, trace === undefined ? reason : trace);
          return;
      }
  
      if (trace !== undefined && trace !== reason) {
          this._setCarriedStackTrace(trace);
      }
  
      if (this._length() > 0) {
          this._queueSettlePromises();
      } else {
          this._ensurePossibleRejectionHandled();
      }
  };
  
  Promise.prototype._settlePromises = function () {
      this._unsetSettlePromisesQueued();
      var len = this._length();
      for (var i = 0; i < len; i++) {
          this._settlePromiseAt(i);
      }
  };
  
  
  util.notEnumerableProp(Promise,
                         "_makeSelfResolutionError",
                         makeSelfResolutionError);
  
  _dereq_("./progress.js")(Promise, PromiseArray);
  _dereq_("./method.js")(Promise, INTERNAL, tryConvertToPromise, apiRejection);
  _dereq_("./bind.js")(Promise, INTERNAL, tryConvertToPromise);
  _dereq_("./finally.js")(Promise, NEXT_FILTER, tryConvertToPromise);
  _dereq_("./direct_resolve.js")(Promise);
  _dereq_("./synchronous_inspection.js")(Promise);
  _dereq_("./join.js")(Promise, PromiseArray, tryConvertToPromise, INTERNAL);
  Promise.version = "2.11.0";
  Promise.Promise = Promise;
  _dereq_('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL);
  _dereq_('./cancel.js')(Promise);
  _dereq_('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext);
  _dereq_('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise);
  _dereq_('./nodeify.js')(Promise);
  _dereq_('./call_get.js')(Promise);
  _dereq_('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection);
  _dereq_('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection);
  _dereq_('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL);
  _dereq_('./settle.js')(Promise, PromiseArray);
  _dereq_('./some.js')(Promise, PromiseArray, apiRejection);
  _dereq_('./promisify.js')(Promise, INTERNAL);
  _dereq_('./any.js')(Promise);
  _dereq_('./each.js')(Promise, INTERNAL);
  _dereq_('./timers.js')(Promise, INTERNAL);
  _dereq_('./filter.js')(Promise, INTERNAL);
                                                           
      util.toFastProperties(Promise);                                          
      util.toFastProperties(Promise.prototype);                                
      function fillTypes(value) {                                              
          var p = new Promise(INTERNAL);                                       
          p._fulfillmentHandler0 = value;                                      
          p._rejectionHandler0 = value;                                        
          p._progressHandler0 = value;                                         
          p._promise0 = value;                                                 
          p._receiver0 = value;                                                
          p._settledValue = value;                                             
      }                                                                        
      // Complete slack tracking, opt out of field-type tracking and           
      // stabilize map                                                         
      fillTypes({a: 1});                                                       
      fillTypes({b: 2});                                                       
      fillTypes({c: 3});                                                       
      fillTypes(1);                                                            
      fillTypes(function(){});                                                 
      fillTypes(undefined);                                                    
      fillTypes(false);                                                        
      fillTypes(new Promise(INTERNAL));                                        
      CapturedTrace.setBounds(async.firstLineError, util.lastLineError);       
      return Promise;                                                          
  
  };
  
  },{"./any.js":1,"./async.js":2,"./bind.js":3,"./call_get.js":5,"./cancel.js":6,"./captured_trace.js":7,"./catch_filter.js":8,"./context.js":9,"./debuggability.js":10,"./direct_resolve.js":11,"./each.js":12,"./errors.js":13,"./filter.js":15,"./finally.js":16,"./generators.js":17,"./join.js":18,"./map.js":19,"./method.js":20,"./nodeify.js":21,"./progress.js":22,"./promise_array.js":24,"./promise_resolver.js":25,"./promisify.js":26,"./props.js":27,"./race.js":29,"./reduce.js":30,"./settle.js":32,"./some.js":33,"./synchronous_inspection.js":34,"./thenables.js":35,"./timers.js":36,"./using.js":37,"./util.js":38}],24:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise, INTERNAL, tryConvertToPromise,
      apiRejection) {
  var util = _dereq_("./util.js");
  var isArray = util.isArray;
  
  function toResolutionValue(val) {
      switch(val) {
      case -2: return [];
      case -3: return {};
      }
  }
  
  function PromiseArray(values) {
      var promise = this._promise = new Promise(INTERNAL);
      var parent;
      if (values instanceof Promise) {
          parent = values;
          promise._propagateFrom(parent, 1 | 4);
      }
      this._values = values;
      this._length = 0;
      this._totalResolved = 0;
      this._init(undefined, -2);
  }
  PromiseArray.prototype.length = function () {
      return this._length;
  };
  
  PromiseArray.prototype.promise = function () {
      return this._promise;
  };
  
  PromiseArray.prototype._init = function init(_, resolveValueIfEmpty) {
      var values = tryConvertToPromise(this._values, this._promise);
      if (values instanceof Promise) {
          values = values._target();
          this._values = values;
          if (values._isFulfilled()) {
              values = values._value();
              if (!isArray(values)) {
                  var err = new Promise.TypeError("expecting an array, a promise or a thenable\u000a\u000a    See http://goo.gl/s8MMhc\u000a");
                  this.__hardReject__(err);
                  return;
              }
          } else if (values._isPending()) {
              values._then(
                  init,
                  this._reject,
                  undefined,
                  this,
                  resolveValueIfEmpty
             );
              return;
          } else {
              this._reject(values._reason());
              return;
          }
      } else if (!isArray(values)) {
          this._promise._reject(apiRejection("expecting an array, a promise or a thenable\u000a\u000a    See http://goo.gl/s8MMhc\u000a")._reason());
          return;
      }
  
      if (values.length === 0) {
          if (resolveValueIfEmpty === -5) {
              this._resolveEmptyArray();
          }
          else {
              this._resolve(toResolutionValue(resolveValueIfEmpty));
          }
          return;
      }
      var len = this.getActualLength(values.length);
      this._length = len;
      this._values = this.shouldCopyValues() ? new Array(len) : this._values;
      var promise = this._promise;
      for (var i = 0; i < len; ++i) {
          var isResolved = this._isResolved();
          var maybePromise = tryConvertToPromise(values[i], promise);
          if (maybePromise instanceof Promise) {
              maybePromise = maybePromise._target();
              if (isResolved) {
                  maybePromise._ignoreRejections();
              } else if (maybePromise._isPending()) {
                  maybePromise._proxyPromiseArray(this, i);
              } else if (maybePromise._isFulfilled()) {
                  this._promiseFulfilled(maybePromise._value(), i);
              } else {
                  this._promiseRejected(maybePromise._reason(), i);
              }
          } else if (!isResolved) {
              this._promiseFulfilled(maybePromise, i);
          }
      }
  };
  
  PromiseArray.prototype._isResolved = function () {
      return this._values === null;
  };
  
  PromiseArray.prototype._resolve = function (value) {
      this._values = null;
      this._promise._fulfill(value);
  };
  
  PromiseArray.prototype.__hardReject__ =
  PromiseArray.prototype._reject = function (reason) {
      this._values = null;
      this._promise._rejectCallback(reason, false, true);
  };
  
  PromiseArray.prototype._promiseProgressed = function (progressValue, index) {
      this._promise._progress({
          index: index,
          value: progressValue
      });
  };
  
  
  PromiseArray.prototype._promiseFulfilled = function (value, index) {
      this._values[index] = value;
      var totalResolved = ++this._totalResolved;
      if (totalResolved >= this._length) {
          this._resolve(this._values);
      }
  };
  
  PromiseArray.prototype._promiseRejected = function (reason, index) {
      this._totalResolved++;
      this._reject(reason);
  };
  
  PromiseArray.prototype.shouldCopyValues = function () {
      return true;
  };
  
  PromiseArray.prototype.getActualLength = function (len) {
      return len;
  };
  
  return PromiseArray;
  };
  
  },{"./util.js":38}],25:[function(_dereq_,module,exports){
  "use strict";
  var util = _dereq_("./util.js");
  var maybeWrapAsError = util.maybeWrapAsError;
  var errors = _dereq_("./errors.js");
  var TimeoutError = errors.TimeoutError;
  var OperationalError = errors.OperationalError;
  var haveGetters = util.haveGetters;
  var es5 = _dereq_("./es5.js");
  
  function isUntypedError(obj) {
      return obj instanceof Error &&
          es5.getPrototypeOf(obj) === Error.prototype;
  }
  
  var rErrorKey = /^(?:name|message|stack|cause)$/;
  function wrapAsOperationalError(obj) {
      var ret;
      if (isUntypedError(obj)) {
          ret = new OperationalError(obj);
          ret.name = obj.name;
          ret.message = obj.message;
          ret.stack = obj.stack;
          var keys = es5.keys(obj);
          for (var i = 0; i < keys.length; ++i) {
              var key = keys[i];
              if (!rErrorKey.test(key)) {
                  ret[key] = obj[key];
              }
          }
          return ret;
      }
      util.markAsOriginatingFromRejection(obj);
      return obj;
  }
  
  function nodebackForPromise(promise) {
      return function(err, value) {
          if (promise === null) return;
  
          if (err) {
              var wrapped = wrapAsOperationalError(maybeWrapAsError(err));
              promise._attachExtraTrace(wrapped);
              promise._reject(wrapped);
          } else if (arguments.length > 2) {
              var $_len = arguments.length;var args = new Array($_len - 1); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];}
              promise._fulfill(args);
          } else {
              promise._fulfill(value);
          }
  
          promise = null;
      };
  }
  
  
  var PromiseResolver;
  if (!haveGetters) {
      PromiseResolver = function (promise) {
          this.promise = promise;
          this.asCallback = nodebackForPromise(promise);
          this.callback = this.asCallback;
      };
  }
  else {
      PromiseResolver = function (promise) {
          this.promise = promise;
      };
  }
  if (haveGetters) {
      var prop = {
          get: function() {
              return nodebackForPromise(this.promise);
          }
      };
      es5.defineProperty(PromiseResolver.prototype, "asCallback", prop);
      es5.defineProperty(PromiseResolver.prototype, "callback", prop);
  }
  
  PromiseResolver._nodebackForPromise = nodebackForPromise;
  
  PromiseResolver.prototype.toString = function () {
      return "[object PromiseResolver]";
  };
  
  PromiseResolver.prototype.resolve =
  PromiseResolver.prototype.fulfill = function (value) {
      if (!(this instanceof PromiseResolver)) {
          throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.\u000a\u000a    See http://goo.gl/sdkXL9\u000a");
      }
      this.promise._resolveCallback(value);
  };
  
  PromiseResolver.prototype.reject = function (reason) {
      if (!(this instanceof PromiseResolver)) {
          throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.\u000a\u000a    See http://goo.gl/sdkXL9\u000a");
      }
      this.promise._rejectCallback(reason);
  };
  
  PromiseResolver.prototype.progress = function (value) {
      if (!(this instanceof PromiseResolver)) {
          throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.\u000a\u000a    See http://goo.gl/sdkXL9\u000a");
      }
      this.promise._progress(value);
  };
  
  PromiseResolver.prototype.cancel = function (err) {
      this.promise.cancel(err);
  };
  
  PromiseResolver.prototype.timeout = function () {
      this.reject(new TimeoutError("timeout"));
  };
  
  PromiseResolver.prototype.isResolved = function () {
      return this.promise.isResolved();
  };
  
  PromiseResolver.prototype.toJSON = function () {
      return this.promise.toJSON();
  };
  
  module.exports = PromiseResolver;
  
  },{"./errors.js":13,"./es5.js":14,"./util.js":38}],26:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise, INTERNAL) {
  var THIS = {};
  var util = _dereq_("./util.js");
  var nodebackForPromise = _dereq_("./promise_resolver.js")
      ._nodebackForPromise;
  var withAppended = util.withAppended;
  var maybeWrapAsError = util.maybeWrapAsError;
  var canEvaluate = util.canEvaluate;
  var TypeError = _dereq_("./errors").TypeError;
  var defaultSuffix = "Async";
  var defaultPromisified = {__isPromisified__: true};
  var noCopyProps = [
      "arity",    "length",
      "name",
      "arguments",
      "caller",
      "callee",
      "prototype",
      "__isPromisified__"
  ];
  var noCopyPropsPattern = new RegExp("^(?:" + noCopyProps.join("|") + ")$");
  
  var defaultFilter = function(name) {
      return util.isIdentifier(name) &&
          name.charAt(0) !== "_" &&
          name !== "constructor";
  };
  
  function propsFilter(key) {
      return !noCopyPropsPattern.test(key);
  }
  
  function isPromisified(fn) {
      try {
          return fn.__isPromisified__ === true;
      }
      catch (e) {
          return false;
      }
  }
  
  function hasPromisified(obj, key, suffix) {
      var val = util.getDataPropertyOrDefault(obj, key + suffix,
                                              defaultPromisified);
      return val ? isPromisified(val) : false;
  }
  function checkValid(ret, suffix, suffixRegexp) {
      for (var i = 0; i < ret.length; i += 2) {
          var key = ret[i];
          if (suffixRegexp.test(key)) {
              var keyWithoutAsyncSuffix = key.replace(suffixRegexp, "");
              for (var j = 0; j < ret.length; j += 2) {
                  if (ret[j] === keyWithoutAsyncSuffix) {
                      throw new TypeError("Cannot promisify an API that has normal methods with '%s'-suffix\u000a\u000a    See http://goo.gl/iWrZbw\u000a"
                          .replace("%s", suffix));
                  }
              }
          }
      }
  }
  
  function promisifiableMethods(obj, suffix, suffixRegexp, filter) {
      var keys = util.inheritedDataKeys(obj);
      var ret = [];
      for (var i = 0; i < keys.length; ++i) {
          var key = keys[i];
          var value = obj[key];
          var passesDefaultFilter = filter === defaultFilter
              ? true : defaultFilter(key, value, obj);
          if (typeof value === "function" &&
              !isPromisified(value) &&
              !hasPromisified(obj, key, suffix) &&
              filter(key, value, obj, passesDefaultFilter)) {
              ret.push(key, value);
          }
      }
      checkValid(ret, suffix, suffixRegexp);
      return ret;
  }
  
  var escapeIdentRegex = function(str) {
      return str.replace(/([$])/, "\\$");
  };
  
  var makeNodePromisifiedEval;
  if (!true) {
  var switchCaseArgumentOrder = function(likelyArgumentCount) {
      var ret = [likelyArgumentCount];
      var min = Math.max(0, likelyArgumentCount - 1 - 3);
      for(var i = likelyArgumentCount - 1; i >= min; --i) {
          ret.push(i);
      }
      for(var i = likelyArgumentCount + 1; i <= 3; ++i) {
          ret.push(i);
      }
      return ret;
  };
  
  var argumentSequence = function(argumentCount) {
      return util.filledRange(argumentCount, "_arg", "");
  };
  
  var parameterDeclaration = function(parameterCount) {
      return util.filledRange(
          Math.max(parameterCount, 3), "_arg", "");
  };
  
  var parameterCount = function(fn) {
      if (typeof fn.length === "number") {
          return Math.max(Math.min(fn.length, 1023 + 1), 0);
      }
      return 0;
  };
  
  makeNodePromisifiedEval =
  function(callback, receiver, originalName, fn) {
      var newParameterCount = Math.max(0, parameterCount(fn) - 1);
      var argumentOrder = switchCaseArgumentOrder(newParameterCount);
      var shouldProxyThis = typeof callback === "string" || receiver === THIS;
  
      function generateCallForArgumentCount(count) {
          var args = argumentSequence(count).join(", ");
          var comma = count > 0 ? ", " : "";
          var ret;
          if (shouldProxyThis) {
              ret = "ret = callback.call(this, {{args}}, nodeback); break;\n";
          } else {
              ret = receiver === undefined
                  ? "ret = callback({{args}}, nodeback); break;\n"
                  : "ret = callback.call(receiver, {{args}}, nodeback); break;\n";
          }
          return ret.replace("{{args}}", args).replace(", ", comma);
      }
  
      function generateArgumentSwitchCase() {
          var ret = "";
          for (var i = 0; i < argumentOrder.length; ++i) {
              ret += "case " + argumentOrder[i] +":" +
                  generateCallForArgumentCount(argumentOrder[i]);
          }
  
          ret += "                                                             \n\
          default:                                                             \n\
              var args = new Array(len + 1);                                   \n\
              var i = 0;                                                       \n\
              for (var i = 0; i < len; ++i) {                                  \n\
                 args[i] = arguments[i];                                       \n\
              }                                                                \n\
              args[i] = nodeback;                                              \n\
              [CodeForCall]                                                    \n\
              break;                                                           \n\
          ".replace("[CodeForCall]", (shouldProxyThis
                                  ? "ret = callback.apply(this, args);\n"
                                  : "ret = callback.apply(receiver, args);\n"));
          return ret;
      }
  
      var getFunctionCode = typeof callback === "string"
                                  ? ("this != null ? this['"+callback+"'] : fn")
                                  : "fn";
  
      return new Function("Promise",
                          "fn",
                          "receiver",
                          "withAppended",
                          "maybeWrapAsError",
                          "nodebackForPromise",
                          "tryCatch",
                          "errorObj",
                          "notEnumerableProp",
                          "INTERNAL","'use strict';                            \n\
          var ret = function (Parameters) {                                    \n\
              'use strict';                                                    \n\
              var len = arguments.length;                                      \n\
              var promise = new Promise(INTERNAL);                             \n\
              promise._captureStackTrace();                                    \n\
              var nodeback = nodebackForPromise(promise);                      \n\
              var ret;                                                         \n\
              var callback = tryCatch([GetFunctionCode]);                      \n\
              switch(len) {                                                    \n\
                  [CodeForSwitchCase]                                          \n\
              }                                                                \n\
              if (ret === errorObj) {                                          \n\
                  promise._rejectCallback(maybeWrapAsError(ret.e), true, true);\n\
              }                                                                \n\
              return promise;                                                  \n\
          };                                                                   \n\
          notEnumerableProp(ret, '__isPromisified__', true);                   \n\
          return ret;                                                          \n\
          "
          .replace("Parameters", parameterDeclaration(newParameterCount))
          .replace("[CodeForSwitchCase]", generateArgumentSwitchCase())
          .replace("[GetFunctionCode]", getFunctionCode))(
              Promise,
              fn,
              receiver,
              withAppended,
              maybeWrapAsError,
              nodebackForPromise,
              util.tryCatch,
              util.errorObj,
              util.notEnumerableProp,
              INTERNAL
          );
  };
  }
  
  function makeNodePromisifiedClosure(callback, receiver, _, fn) {
      var defaultThis = (function() {return this;})();
      var method = callback;
      if (typeof method === "string") {
          callback = fn;
      }
      function promisified() {
          var _receiver = receiver;
          if (receiver === THIS) _receiver = this;
          var promise = new Promise(INTERNAL);
          promise._captureStackTrace();
          var cb = typeof method === "string" && this !== defaultThis
              ? this[method] : callback;
          var fn = nodebackForPromise(promise);
          try {
              cb.apply(_receiver, withAppended(arguments, fn));
          } catch(e) {
              promise._rejectCallback(maybeWrapAsError(e), true, true);
          }
          return promise;
      }
      util.notEnumerableProp(promisified, "__isPromisified__", true);
      return promisified;
  }
  
  var makeNodePromisified = canEvaluate
      ? makeNodePromisifiedEval
      : makeNodePromisifiedClosure;
  
  function promisifyAll(obj, suffix, filter, promisifier) {
      var suffixRegexp = new RegExp(escapeIdentRegex(suffix) + "$");
      var methods =
          promisifiableMethods(obj, suffix, suffixRegexp, filter);
  
      for (var i = 0, len = methods.length; i < len; i+= 2) {
          var key = methods[i];
          var fn = methods[i+1];
          var promisifiedKey = key + suffix;
          if (promisifier === makeNodePromisified) {
              obj[promisifiedKey] =
                  makeNodePromisified(key, THIS, key, fn, suffix);
          } else {
              var promisified = promisifier(fn, function() {
                  return makeNodePromisified(key, THIS, key, fn, suffix);
              });
              util.notEnumerableProp(promisified, "__isPromisified__", true);
              obj[promisifiedKey] = promisified;
          }
      }
      util.toFastProperties(obj);
      return obj;
  }
  
  function promisify(callback, receiver) {
      return makeNodePromisified(callback, receiver, undefined, callback);
  }
  
  Promise.promisify = function (fn, receiver) {
      if (typeof fn !== "function") {
          throw new TypeError("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
      }
      if (isPromisified(fn)) {
          return fn;
      }
      var ret = promisify(fn, arguments.length < 2 ? THIS : receiver);
      util.copyDescriptors(fn, ret, propsFilter);
      return ret;
  };
  
  Promise.promisifyAll = function (target, options) {
      if (typeof target !== "function" && typeof target !== "object") {
          throw new TypeError("the target of promisifyAll must be an object or a function\u000a\u000a    See http://goo.gl/9ITlV0\u000a");
      }
      options = Object(options);
      var suffix = options.suffix;
      if (typeof suffix !== "string") suffix = defaultSuffix;
      var filter = options.filter;
      if (typeof filter !== "function") filter = defaultFilter;
      var promisifier = options.promisifier;
      if (typeof promisifier !== "function") promisifier = makeNodePromisified;
  
      if (!util.isIdentifier(suffix)) {
          throw new RangeError("suffix must be a valid identifier\u000a\u000a    See http://goo.gl/8FZo5V\u000a");
      }
  
      var keys = util.inheritedDataKeys(target);
      for (var i = 0; i < keys.length; ++i) {
          var value = target[keys[i]];
          if (keys[i] !== "constructor" &&
              util.isClass(value)) {
              promisifyAll(value.prototype, suffix, filter, promisifier);
              promisifyAll(value, suffix, filter, promisifier);
          }
      }
  
      return promisifyAll(target, suffix, filter, promisifier);
  };
  };
  
  
  },{"./errors":13,"./promise_resolver.js":25,"./util.js":38}],27:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(
      Promise, PromiseArray, tryConvertToPromise, apiRejection) {
  var util = _dereq_("./util.js");
  var isObject = util.isObject;
  var es5 = _dereq_("./es5.js");
  
  function PropertiesPromiseArray(obj) {
      var keys = es5.keys(obj);
      var len = keys.length;
      var values = new Array(len * 2);
      for (var i = 0; i < len; ++i) {
          var key = keys[i];
          values[i] = obj[key];
          values[i + len] = key;
      }
      this.constructor$(values);
  }
  util.inherits(PropertiesPromiseArray, PromiseArray);
  
  PropertiesPromiseArray.prototype._init = function () {
      this._init$(undefined, -3) ;
  };
  
  PropertiesPromiseArray.prototype._promiseFulfilled = function (value, index) {
      this._values[index] = value;
      var totalResolved = ++this._totalResolved;
      if (totalResolved >= this._length) {
          var val = {};
          var keyOffset = this.length();
          for (var i = 0, len = this.length(); i < len; ++i) {
              val[this._values[i + keyOffset]] = this._values[i];
          }
          this._resolve(val);
      }
  };
  
  PropertiesPromiseArray.prototype._promiseProgressed = function (value, index) {
      this._promise._progress({
          key: this._values[index + this.length()],
          value: value
      });
  };
  
  PropertiesPromiseArray.prototype.shouldCopyValues = function () {
      return false;
  };
  
  PropertiesPromiseArray.prototype.getActualLength = function (len) {
      return len >> 1;
  };
  
  function props(promises) {
      var ret;
      var castValue = tryConvertToPromise(promises);
  
      if (!isObject(castValue)) {
          return apiRejection("cannot await properties of a non-object\u000a\u000a    See http://goo.gl/OsFKC8\u000a");
      } else if (castValue instanceof Promise) {
          ret = castValue._then(
              Promise.props, undefined, undefined, undefined, undefined);
      } else {
          ret = new PropertiesPromiseArray(castValue).promise();
      }
  
      if (castValue instanceof Promise) {
          ret._propagateFrom(castValue, 4);
      }
      return ret;
  }
  
  Promise.prototype.props = function () {
      return props(this);
  };
  
  Promise.props = function (promises) {
      return props(promises);
  };
  };
  
  },{"./es5.js":14,"./util.js":38}],28:[function(_dereq_,module,exports){
  "use strict";
  function arrayMove(src, srcIndex, dst, dstIndex, len) {
      for (var j = 0; j < len; ++j) {
          dst[j + dstIndex] = src[j + srcIndex];
          src[j + srcIndex] = void 0;
      }
  }
  
  function Queue(capacity) {
      this._capacity = capacity;
      this._length = 0;
      this._front = 0;
  }
  
  Queue.prototype._willBeOverCapacity = function (size) {
      return this._capacity < size;
  };
  
  Queue.prototype._pushOne = function (arg) {
      var length = this.length();
      this._checkCapacity(length + 1);
      var i = (this._front + length) & (this._capacity - 1);
      this[i] = arg;
      this._length = length + 1;
  };
  
  Queue.prototype._unshiftOne = function(value) {
      var capacity = this._capacity;
      this._checkCapacity(this.length() + 1);
      var front = this._front;
      var i = (((( front - 1 ) &
                      ( capacity - 1) ) ^ capacity ) - capacity );
      this[i] = value;
      this._front = i;
      this._length = this.length() + 1;
  };
  
  Queue.prototype.unshift = function(fn, receiver, arg) {
      this._unshiftOne(arg);
      this._unshiftOne(receiver);
      this._unshiftOne(fn);
  };
  
  Queue.prototype.push = function (fn, receiver, arg) {
      var length = this.length() + 3;
      if (this._willBeOverCapacity(length)) {
          this._pushOne(fn);
          this._pushOne(receiver);
          this._pushOne(arg);
          return;
      }
      var j = this._front + length - 3;
      this._checkCapacity(length);
      var wrapMask = this._capacity - 1;
      this[(j + 0) & wrapMask] = fn;
      this[(j + 1) & wrapMask] = receiver;
      this[(j + 2) & wrapMask] = arg;
      this._length = length;
  };
  
  Queue.prototype.shift = function () {
      var front = this._front,
          ret = this[front];
  
      this[front] = undefined;
      this._front = (front + 1) & (this._capacity - 1);
      this._length--;
      return ret;
  };
  
  Queue.prototype.length = function () {
      return this._length;
  };
  
  Queue.prototype._checkCapacity = function (size) {
      if (this._capacity < size) {
          this._resizeTo(this._capacity << 1);
      }
  };
  
  Queue.prototype._resizeTo = function (capacity) {
      var oldCapacity = this._capacity;
      this._capacity = capacity;
      var front = this._front;
      var length = this._length;
      var moveItemsCount = (front + length) & (oldCapacity - 1);
      arrayMove(this, 0, this, oldCapacity, moveItemsCount);
  };
  
  module.exports = Queue;
  
  },{}],29:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(
      Promise, INTERNAL, tryConvertToPromise, apiRejection) {
  var isArray = _dereq_("./util.js").isArray;
  
  var raceLater = function (promise) {
      return promise.then(function(array) {
          return race(array, promise);
      });
  };
  
  function race(promises, parent) {
      var maybePromise = tryConvertToPromise(promises);
  
      if (maybePromise instanceof Promise) {
          return raceLater(maybePromise);
      } else if (!isArray(promises)) {
          return apiRejection("expecting an array, a promise or a thenable\u000a\u000a    See http://goo.gl/s8MMhc\u000a");
      }
  
      var ret = new Promise(INTERNAL);
      if (parent !== undefined) {
          ret._propagateFrom(parent, 4 | 1);
      }
      var fulfill = ret._fulfill;
      var reject = ret._reject;
      for (var i = 0, len = promises.length; i < len; ++i) {
          var val = promises[i];
  
          if (val === undefined && !(i in promises)) {
              continue;
          }
  
          Promise.cast(val)._then(fulfill, reject, undefined, ret, null);
      }
      return ret;
  }
  
  Promise.race = function (promises) {
      return race(promises, undefined);
  };
  
  Promise.prototype.race = function () {
      return race(this, undefined);
  };
  
  };
  
  },{"./util.js":38}],30:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise,
                            PromiseArray,
                            apiRejection,
                            tryConvertToPromise,
                            INTERNAL) {
  var getDomain = Promise._getDomain;
  var async = _dereq_("./async.js");
  var util = _dereq_("./util.js");
  var tryCatch = util.tryCatch;
  var errorObj = util.errorObj;
  function ReductionPromiseArray(promises, fn, accum, _each) {
      this.constructor$(promises);
      this._promise._captureStackTrace();
      this._preservedValues = _each === INTERNAL ? [] : null;
      this._zerothIsAccum = (accum === undefined);
      this._gotAccum = false;
      this._reducingIndex = (this._zerothIsAccum ? 1 : 0);
      this._valuesPhase = undefined;
      var maybePromise = tryConvertToPromise(accum, this._promise);
      var rejected = false;
      var isPromise = maybePromise instanceof Promise;
      if (isPromise) {
          maybePromise = maybePromise._target();
          if (maybePromise._isPending()) {
              maybePromise._proxyPromiseArray(this, -1);
          } else if (maybePromise._isFulfilled()) {
              accum = maybePromise._value();
              this._gotAccum = true;
          } else {
              this._reject(maybePromise._reason());
              rejected = true;
          }
      }
      if (!(isPromise || this._zerothIsAccum)) this._gotAccum = true;
      var domain = getDomain();
      this._callback = domain === null ? fn : domain.bind(fn);
      this._accum = accum;
      if (!rejected) async.invoke(init, this, undefined);
  }
  function init() {
      this._init$(undefined, -5);
  }
  util.inherits(ReductionPromiseArray, PromiseArray);
  
  ReductionPromiseArray.prototype._init = function () {};
  
  ReductionPromiseArray.prototype._resolveEmptyArray = function () {
      if (this._gotAccum || this._zerothIsAccum) {
          this._resolve(this._preservedValues !== null
                          ? [] : this._accum);
      }
  };
  
  ReductionPromiseArray.prototype._promiseFulfilled = function (value, index) {
      var values = this._values;
      values[index] = value;
      var length = this.length();
      var preservedValues = this._preservedValues;
      var isEach = preservedValues !== null;
      var gotAccum = this._gotAccum;
      var valuesPhase = this._valuesPhase;
      var valuesPhaseIndex;
      if (!valuesPhase) {
          valuesPhase = this._valuesPhase = new Array(length);
          for (valuesPhaseIndex=0; valuesPhaseIndex<length; ++valuesPhaseIndex) {
              valuesPhase[valuesPhaseIndex] = 0;
          }
      }
      valuesPhaseIndex = valuesPhase[index];
  
      if (index === 0 && this._zerothIsAccum) {
          this._accum = value;
          this._gotAccum = gotAccum = true;
          valuesPhase[index] = ((valuesPhaseIndex === 0)
              ? 1 : 2);
      } else if (index === -1) {
          this._accum = value;
          this._gotAccum = gotAccum = true;
      } else {
          if (valuesPhaseIndex === 0) {
              valuesPhase[index] = 1;
          } else {
              valuesPhase[index] = 2;
              this._accum = value;
          }
      }
      if (!gotAccum) return;
  
      var callback = this._callback;
      var receiver = this._promise._boundValue();
      var ret;
  
      for (var i = this._reducingIndex; i < length; ++i) {
          valuesPhaseIndex = valuesPhase[i];
          if (valuesPhaseIndex === 2) {
              this._reducingIndex = i + 1;
              continue;
          }
          if (valuesPhaseIndex !== 1) return;
          value = values[i];
          this._promise._pushContext();
          if (isEach) {
              preservedValues.push(value);
              ret = tryCatch(callback).call(receiver, value, i, length);
          }
          else {
              ret = tryCatch(callback)
                  .call(receiver, this._accum, value, i, length);
          }
          this._promise._popContext();
  
          if (ret === errorObj) return this._reject(ret.e);
  
          var maybePromise = tryConvertToPromise(ret, this._promise);
          if (maybePromise instanceof Promise) {
              maybePromise = maybePromise._target();
              if (maybePromise._isPending()) {
                  valuesPhase[i] = 4;
                  return maybePromise._proxyPromiseArray(this, i);
              } else if (maybePromise._isFulfilled()) {
                  ret = maybePromise._value();
              } else {
                  return this._reject(maybePromise._reason());
              }
          }
  
          this._reducingIndex = i + 1;
          this._accum = ret;
      }
  
      this._resolve(isEach ? preservedValues : this._accum);
  };
  
  function reduce(promises, fn, initialValue, _each) {
      if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
      var array = new ReductionPromiseArray(promises, fn, initialValue, _each);
      return array.promise();
  }
  
  Promise.prototype.reduce = function (fn, initialValue) {
      return reduce(this, fn, initialValue, null);
  };
  
  Promise.reduce = function (promises, fn, initialValue, _each) {
      return reduce(promises, fn, initialValue, _each);
  };
  };
  
  },{"./async.js":2,"./util.js":38}],31:[function(_dereq_,module,exports){
  "use strict";
  var schedule;
  var util = _dereq_("./util");
  var noAsyncScheduler = function() {
      throw new Error("No async scheduler available\u000a\u000a    See http://goo.gl/m3OTXk\u000a");
  };
  if (util.isNode && typeof MutationObserver === "undefined") {
      var GlobalSetImmediate = global.setImmediate;
      var ProcessNextTick = process.nextTick;
      schedule = util.isRecentNode
                  ? function(fn) { GlobalSetImmediate.call(global, fn); }
                  : function(fn) { ProcessNextTick.call(process, fn); };
  } else if ((typeof MutationObserver !== "undefined") &&
            !(typeof window !== "undefined" &&
              window.navigator &&
              window.navigator.standalone)) {
      schedule = function(fn) {
          var div = document.createElement("div");
          var observer = new MutationObserver(fn);
          observer.observe(div, {attributes: true});
          return function() { div.classList.toggle("foo"); };
      };
      schedule.isStatic = true;
  } else if (typeof setImmediate !== "undefined") {
      schedule = function (fn) {
          setImmediate(fn);
      };
  } else if (typeof setTimeout !== "undefined") {
      schedule = function (fn) {
          setTimeout(fn, 0);
      };
  } else {
      schedule = noAsyncScheduler;
  }
  module.exports = schedule;
  
  },{"./util":38}],32:[function(_dereq_,module,exports){
  "use strict";
  module.exports =
      function(Promise, PromiseArray) {
  var PromiseInspection = Promise.PromiseInspection;
  var util = _dereq_("./util.js");
  
  function SettledPromiseArray(values) {
      this.constructor$(values);
  }
  util.inherits(SettledPromiseArray, PromiseArray);
  
  SettledPromiseArray.prototype._promiseResolved = function (index, inspection) {
      this._values[index] = inspection;
      var totalResolved = ++this._totalResolved;
      if (totalResolved >= this._length) {
          this._resolve(this._values);
      }
  };
  
  SettledPromiseArray.prototype._promiseFulfilled = function (value, index) {
      var ret = new PromiseInspection();
      ret._bitField = 268435456;
      ret._settledValue = value;
      this._promiseResolved(index, ret);
  };
  SettledPromiseArray.prototype._promiseRejected = function (reason, index) {
      var ret = new PromiseInspection();
      ret._bitField = 134217728;
      ret._settledValue = reason;
      this._promiseResolved(index, ret);
  };
  
  Promise.settle = function (promises) {
      return new SettledPromiseArray(promises).promise();
  };
  
  Promise.prototype.settle = function () {
      return new SettledPromiseArray(this).promise();
  };
  };
  
  },{"./util.js":38}],33:[function(_dereq_,module,exports){
  "use strict";
  module.exports =
  function(Promise, PromiseArray, apiRejection) {
  var util = _dereq_("./util.js");
  var RangeError = _dereq_("./errors.js").RangeError;
  var AggregateError = _dereq_("./errors.js").AggregateError;
  var isArray = util.isArray;
  
  
  function SomePromiseArray(values) {
      this.constructor$(values);
      this._howMany = 0;
      this._unwrap = false;
      this._initialized = false;
  }
  util.inherits(SomePromiseArray, PromiseArray);
  
  SomePromiseArray.prototype._init = function () {
      if (!this._initialized) {
          return;
      }
      if (this._howMany === 0) {
          this._resolve([]);
          return;
      }
      this._init$(undefined, -5);
      var isArrayResolved = isArray(this._values);
      if (!this._isResolved() &&
          isArrayResolved &&
          this._howMany > this._canPossiblyFulfill()) {
          this._reject(this._getRangeError(this.length()));
      }
  };
  
  SomePromiseArray.prototype.init = function () {
      this._initialized = true;
      this._init();
  };
  
  SomePromiseArray.prototype.setUnwrap = function () {
      this._unwrap = true;
  };
  
  SomePromiseArray.prototype.howMany = function () {
      return this._howMany;
  };
  
  SomePromiseArray.prototype.setHowMany = function (count) {
      this._howMany = count;
  };
  
  SomePromiseArray.prototype._promiseFulfilled = function (value) {
      this._addFulfilled(value);
      if (this._fulfilled() === this.howMany()) {
          this._values.length = this.howMany();
          if (this.howMany() === 1 && this._unwrap) {
              this._resolve(this._values[0]);
          } else {
              this._resolve(this._values);
          }
      }
  
  };
  SomePromiseArray.prototype._promiseRejected = function (reason) {
      this._addRejected(reason);
      if (this.howMany() > this._canPossiblyFulfill()) {
          var e = new AggregateError();
          for (var i = this.length(); i < this._values.length; ++i) {
              e.push(this._values[i]);
          }
          this._reject(e);
      }
  };
  
  SomePromiseArray.prototype._fulfilled = function () {
      return this._totalResolved;
  };
  
  SomePromiseArray.prototype._rejected = function () {
      return this._values.length - this.length();
  };
  
  SomePromiseArray.prototype._addRejected = function (reason) {
      this._values.push(reason);
  };
  
  SomePromiseArray.prototype._addFulfilled = function (value) {
      this._values[this._totalResolved++] = value;
  };
  
  SomePromiseArray.prototype._canPossiblyFulfill = function () {
      return this.length() - this._rejected();
  };
  
  SomePromiseArray.prototype._getRangeError = function (count) {
      var message = "Input array must contain at least " +
              this._howMany + " items but contains only " + count + " items";
      return new RangeError(message);
  };
  
  SomePromiseArray.prototype._resolveEmptyArray = function () {
      this._reject(this._getRangeError(0));
  };
  
  function some(promises, howMany) {
      if ((howMany | 0) !== howMany || howMany < 0) {
          return apiRejection("expecting a positive integer\u000a\u000a    See http://goo.gl/1wAmHx\u000a");
      }
      var ret = new SomePromiseArray(promises);
      var promise = ret.promise();
      ret.setHowMany(howMany);
      ret.init();
      return promise;
  }
  
  Promise.some = function (promises, howMany) {
      return some(promises, howMany);
  };
  
  Promise.prototype.some = function (howMany) {
      return some(this, howMany);
  };
  
  Promise._SomePromiseArray = SomePromiseArray;
  };
  
  },{"./errors.js":13,"./util.js":38}],34:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise) {
  function PromiseInspection(promise) {
      if (promise !== undefined) {
          promise = promise._target();
          this._bitField = promise._bitField;
          this._settledValue = promise._settledValue;
      }
      else {
          this._bitField = 0;
          this._settledValue = undefined;
      }
  }
  
  PromiseInspection.prototype.value = function () {
      if (!this.isFulfilled()) {
          throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a    See http://goo.gl/hc1DLj\u000a");
      }
      return this._settledValue;
  };
  
  PromiseInspection.prototype.error =
  PromiseInspection.prototype.reason = function () {
      if (!this.isRejected()) {
          throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a    See http://goo.gl/hPuiwB\u000a");
      }
      return this._settledValue;
  };
  
  PromiseInspection.prototype.isFulfilled =
  Promise.prototype._isFulfilled = function () {
      return (this._bitField & 268435456) > 0;
  };
  
  PromiseInspection.prototype.isRejected =
  Promise.prototype._isRejected = function () {
      return (this._bitField & 134217728) > 0;
  };
  
  PromiseInspection.prototype.isPending =
  Promise.prototype._isPending = function () {
      return (this._bitField & 402653184) === 0;
  };
  
  PromiseInspection.prototype.isResolved =
  Promise.prototype._isResolved = function () {
      return (this._bitField & 402653184) > 0;
  };
  
  Promise.prototype.isPending = function() {
      return this._target()._isPending();
  };
  
  Promise.prototype.isRejected = function() {
      return this._target()._isRejected();
  };
  
  Promise.prototype.isFulfilled = function() {
      return this._target()._isFulfilled();
  };
  
  Promise.prototype.isResolved = function() {
      return this._target()._isResolved();
  };
  
  Promise.prototype._value = function() {
      return this._settledValue;
  };
  
  Promise.prototype._reason = function() {
      this._unsetRejectionIsUnhandled();
      return this._settledValue;
  };
  
  Promise.prototype.value = function() {
      var target = this._target();
      if (!target.isFulfilled()) {
          throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a    See http://goo.gl/hc1DLj\u000a");
      }
      return target._settledValue;
  };
  
  Promise.prototype.reason = function() {
      var target = this._target();
      if (!target.isRejected()) {
          throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a    See http://goo.gl/hPuiwB\u000a");
      }
      target._unsetRejectionIsUnhandled();
      return target._settledValue;
  };
  
  
  Promise.PromiseInspection = PromiseInspection;
  };
  
  },{}],35:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise, INTERNAL) {
  var util = _dereq_("./util.js");
  var errorObj = util.errorObj;
  var isObject = util.isObject;
  
  function tryConvertToPromise(obj, context) {
      if (isObject(obj)) {
          if (obj instanceof Promise) {
              return obj;
          }
          else if (isAnyBluebirdPromise(obj)) {
              var ret = new Promise(INTERNAL);
              obj._then(
                  ret._fulfillUnchecked,
                  ret._rejectUncheckedCheckError,
                  ret._progressUnchecked,
                  ret,
                  null
              );
              return ret;
          }
          var then = util.tryCatch(getThen)(obj);
          if (then === errorObj) {
              if (context) context._pushContext();
              var ret = Promise.reject(then.e);
              if (context) context._popContext();
              return ret;
          } else if (typeof then === "function") {
              return doThenable(obj, then, context);
          }
      }
      return obj;
  }
  
  function getThen(obj) {
      return obj.then;
  }
  
  var hasProp = {}.hasOwnProperty;
  function isAnyBluebirdPromise(obj) {
      return hasProp.call(obj, "_promise0");
  }
  
  function doThenable(x, then, context) {
      var promise = new Promise(INTERNAL);
      var ret = promise;
      if (context) context._pushContext();
      promise._captureStackTrace();
      if (context) context._popContext();
      var synchronous = true;
      var result = util.tryCatch(then).call(x,
                                          resolveFromThenable,
                                          rejectFromThenable,
                                          progressFromThenable);
      synchronous = false;
      if (promise && result === errorObj) {
          promise._rejectCallback(result.e, true, true);
          promise = null;
      }
  
      function resolveFromThenable(value) {
          if (!promise) return;
          promise._resolveCallback(value);
          promise = null;
      }
  
      function rejectFromThenable(reason) {
          if (!promise) return;
          promise._rejectCallback(reason, synchronous, true);
          promise = null;
      }
  
      function progressFromThenable(value) {
          if (!promise) return;
          if (typeof promise._progress === "function") {
              promise._progress(value);
          }
      }
      return ret;
  }
  
  return tryConvertToPromise;
  };
  
  },{"./util.js":38}],36:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise, INTERNAL) {
  var util = _dereq_("./util.js");
  var TimeoutError = Promise.TimeoutError;
  
  var afterTimeout = function (promise, message) {
      if (!promise.isPending()) return;
      
      var err;
      if(!util.isPrimitive(message) && (message instanceof Error)) {
          err = message;
      } else {
          if (typeof message !== "string") {
              message = "operation timed out";
          }
          err = new TimeoutError(message);
      }
      util.markAsOriginatingFromRejection(err);
      promise._attachExtraTrace(err);
      promise._cancel(err);
  };
  
  var afterValue = function(value) { return delay(+this).thenReturn(value); };
  var delay = Promise.delay = function (value, ms) {
      if (ms === undefined) {
          ms = value;
          value = undefined;
          var ret = new Promise(INTERNAL);
          setTimeout(function() { ret._fulfill(); }, ms);
          return ret;
      }
      ms = +ms;
      return Promise.resolve(value)._then(afterValue, null, null, ms, undefined);
  };
  
  Promise.prototype.delay = function (ms) {
      return delay(this, ms);
  };
  
  function successClear(value) {
      var handle = this;
      if (handle instanceof Number) handle = +handle;
      clearTimeout(handle);
      return value;
  }
  
  function failureClear(reason) {
      var handle = this;
      if (handle instanceof Number) handle = +handle;
      clearTimeout(handle);
      throw reason;
  }
  
  Promise.prototype.timeout = function (ms, message) {
      ms = +ms;
      var ret = this.then().cancellable();
      ret._cancellationParent = this;
      var handle = setTimeout(function timeoutTimeout() {
          afterTimeout(ret, message);
      }, ms);
      return ret._then(successClear, failureClear, undefined, handle, undefined);
  };
  
  };
  
  },{"./util.js":38}],37:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function (Promise, apiRejection, tryConvertToPromise,
      createContext) {
      var TypeError = _dereq_("./errors.js").TypeError;
      var inherits = _dereq_("./util.js").inherits;
      var PromiseInspection = Promise.PromiseInspection;
  
      function inspectionMapper(inspections) {
          var len = inspections.length;
          for (var i = 0; i < len; ++i) {
              var inspection = inspections[i];
              if (inspection.isRejected()) {
                  return Promise.reject(inspection.error());
              }
              inspections[i] = inspection._settledValue;
          }
          return inspections;
      }
  
      function thrower(e) {
          setTimeout(function(){throw e;}, 0);
      }
  
      function castPreservingDisposable(thenable) {
          var maybePromise = tryConvertToPromise(thenable);
          if (maybePromise !== thenable &&
              typeof thenable._isDisposable === "function" &&
              typeof thenable._getDisposer === "function" &&
              thenable._isDisposable()) {
              maybePromise._setDisposable(thenable._getDisposer());
          }
          return maybePromise;
      }
      function dispose(resources, inspection) {
          var i = 0;
          var len = resources.length;
          var ret = Promise.defer();
          function iterator() {
              if (i >= len) return ret.resolve();
              var maybePromise = castPreservingDisposable(resources[i++]);
              if (maybePromise instanceof Promise &&
                  maybePromise._isDisposable()) {
                  try {
                      maybePromise = tryConvertToPromise(
                          maybePromise._getDisposer().tryDispose(inspection),
                          resources.promise);
                  } catch (e) {
                      return thrower(e);
                  }
                  if (maybePromise instanceof Promise) {
                      return maybePromise._then(iterator, thrower,
                                                null, null, null);
                  }
              }
              iterator();
          }
          iterator();
          return ret.promise;
      }
  
      function disposerSuccess(value) {
          var inspection = new PromiseInspection();
          inspection._settledValue = value;
          inspection._bitField = 268435456;
          return dispose(this, inspection).thenReturn(value);
      }
  
      function disposerFail(reason) {
          var inspection = new PromiseInspection();
          inspection._settledValue = reason;
          inspection._bitField = 134217728;
          return dispose(this, inspection).thenThrow(reason);
      }
  
      function Disposer(data, promise, context) {
          this._data = data;
          this._promise = promise;
          this._context = context;
      }
  
      Disposer.prototype.data = function () {
          return this._data;
      };
  
      Disposer.prototype.promise = function () {
          return this._promise;
      };
  
      Disposer.prototype.resource = function () {
          if (this.promise().isFulfilled()) {
              return this.promise().value();
          }
          return null;
      };
  
      Disposer.prototype.tryDispose = function(inspection) {
          var resource = this.resource();
          var context = this._context;
          if (context !== undefined) context._pushContext();
          var ret = resource !== null
              ? this.doDispose(resource, inspection) : null;
          if (context !== undefined) context._popContext();
          this._promise._unsetDisposable();
          this._data = null;
          return ret;
      };
  
      Disposer.isDisposer = function (d) {
          return (d != null &&
                  typeof d.resource === "function" &&
                  typeof d.tryDispose === "function");
      };
  
      function FunctionDisposer(fn, promise, context) {
          this.constructor$(fn, promise, context);
      }
      inherits(FunctionDisposer, Disposer);
  
      FunctionDisposer.prototype.doDispose = function (resource, inspection) {
          var fn = this.data();
          return fn.call(resource, resource, inspection);
      };
  
      function maybeUnwrapDisposer(value) {
          if (Disposer.isDisposer(value)) {
              this.resources[this.index]._setDisposable(value);
              return value.promise();
          }
          return value;
      }
  
      Promise.using = function () {
          var len = arguments.length;
          if (len < 2) return apiRejection(
                          "you must pass at least 2 arguments to Promise.using");
          var fn = arguments[len - 1];
          if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
  
          var input;
          var spreadArgs = true;
          if (len === 2 && Array.isArray(arguments[0])) {
              input = arguments[0];
              len = input.length;
              spreadArgs = false;
          } else {
              input = arguments;
              len--;
          }
          var resources = new Array(len);
          for (var i = 0; i < len; ++i) {
              var resource = input[i];
              if (Disposer.isDisposer(resource)) {
                  var disposer = resource;
                  resource = resource.promise();
                  resource._setDisposable(disposer);
              } else {
                  var maybePromise = tryConvertToPromise(resource);
                  if (maybePromise instanceof Promise) {
                      resource =
                          maybePromise._then(maybeUnwrapDisposer, null, null, {
                              resources: resources,
                              index: i
                      }, undefined);
                  }
              }
              resources[i] = resource;
          }
  
          var promise = Promise.settle(resources)
              .then(inspectionMapper)
              .then(function(vals) {
                  promise._pushContext();
                  var ret;
                  try {
                      ret = spreadArgs
                          ? fn.apply(undefined, vals) : fn.call(undefined,  vals);
                  } finally {
                      promise._popContext();
                  }
                  return ret;
              })
              ._then(
                  disposerSuccess, disposerFail, undefined, resources, undefined);
          resources.promise = promise;
          return promise;
      };
  
      Promise.prototype._setDisposable = function (disposer) {
          this._bitField = this._bitField | 262144;
          this._disposer = disposer;
      };
  
      Promise.prototype._isDisposable = function () {
          return (this._bitField & 262144) > 0;
      };
  
      Promise.prototype._getDisposer = function () {
          return this._disposer;
      };
  
      Promise.prototype._unsetDisposable = function () {
          this._bitField = this._bitField & (~262144);
          this._disposer = undefined;
      };
  
      Promise.prototype.disposer = function (fn) {
          if (typeof fn === "function") {
              return new FunctionDisposer(fn, this, createContext());
          }
          throw new TypeError();
      };
  
  };
  
  },{"./errors.js":13,"./util.js":38}],38:[function(_dereq_,module,exports){
  "use strict";
  var es5 = _dereq_("./es5.js");
  var canEvaluate = typeof navigator == "undefined";
  var haveGetters = (function(){
      try {
          var o = {};
          es5.defineProperty(o, "f", {
              get: function () {
                  return 3;
              }
          });
          return o.f === 3;
      }
      catch (e) {
          return false;
      }
  
  })();
  
  var errorObj = {e: {}};
  var tryCatchTarget;
  function tryCatcher() {
      try {
          var target = tryCatchTarget;
          tryCatchTarget = null;
          return target.apply(this, arguments);
      } catch (e) {
          errorObj.e = e;
          return errorObj;
      }
  }
  function tryCatch(fn) {
      tryCatchTarget = fn;
      return tryCatcher;
  }
  
  var inherits = function(Child, Parent) {
      var hasProp = {}.hasOwnProperty;
  
      function T() {
          this.constructor = Child;
          this.constructor$ = Parent;
          for (var propertyName in Parent.prototype) {
              if (hasProp.call(Parent.prototype, propertyName) &&
                  propertyName.charAt(propertyName.length-1) !== "$"
             ) {
                  this[propertyName + "$"] = Parent.prototype[propertyName];
              }
          }
      }
      T.prototype = Parent.prototype;
      Child.prototype = new T();
      return Child.prototype;
  };
  
  
  function isPrimitive(val) {
      return val == null || val === true || val === false ||
          typeof val === "string" || typeof val === "number";
  
  }
  
  function isObject(value) {
      return !isPrimitive(value);
  }
  
  function maybeWrapAsError(maybeError) {
      if (!isPrimitive(maybeError)) return maybeError;
  
      return new Error(safeToString(maybeError));
  }
  
  function withAppended(target, appendee) {
      var len = target.length;
      var ret = new Array(len + 1);
      var i;
      for (i = 0; i < len; ++i) {
          ret[i] = target[i];
      }
      ret[i] = appendee;
      return ret;
  }
  
  function getDataPropertyOrDefault(obj, key, defaultValue) {
      if (es5.isES5) {
          var desc = Object.getOwnPropertyDescriptor(obj, key);
  
          if (desc != null) {
              return desc.get == null && desc.set == null
                      ? desc.value
                      : defaultValue;
          }
      } else {
          return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
      }
  }
  
  function notEnumerableProp(obj, name, value) {
      if (isPrimitive(obj)) return obj;
      var descriptor = {
          value: value,
          configurable: true,
          enumerable: false,
          writable: true
      };
      es5.defineProperty(obj, name, descriptor);
      return obj;
  }
  
  function thrower(r) {
      throw r;
  }
  
  var inheritedDataKeys = (function() {
      var excludedPrototypes = [
          Array.prototype,
          Object.prototype,
          Function.prototype
      ];
  
      var isExcludedProto = function(val) {
          for (var i = 0; i < excludedPrototypes.length; ++i) {
              if (excludedPrototypes[i] === val) {
                  return true;
              }
          }
          return false;
      };
  
      if (es5.isES5) {
          var getKeys = Object.getOwnPropertyNames;
          return function(obj) {
              var ret = [];
              var visitedKeys = Object.create(null);
              while (obj != null && !isExcludedProto(obj)) {
                  var keys;
                  try {
                      keys = getKeys(obj);
                  } catch (e) {
                      return ret;
                  }
                  for (var i = 0; i < keys.length; ++i) {
                      var key = keys[i];
                      if (visitedKeys[key]) continue;
                      visitedKeys[key] = true;
                      var desc = Object.getOwnPropertyDescriptor(obj, key);
                      if (desc != null && desc.get == null && desc.set == null) {
                          ret.push(key);
                      }
                  }
                  obj = es5.getPrototypeOf(obj);
              }
              return ret;
          };
      } else {
          var hasProp = {}.hasOwnProperty;
          return function(obj) {
              if (isExcludedProto(obj)) return [];
              var ret = [];
  
              /*jshint forin:false */
              enumeration: for (var key in obj) {
                  if (hasProp.call(obj, key)) {
                      ret.push(key);
                  } else {
                      for (var i = 0; i < excludedPrototypes.length; ++i) {
                          if (hasProp.call(excludedPrototypes[i], key)) {
                              continue enumeration;
                          }
                      }
                      ret.push(key);
                  }
              }
              return ret;
          };
      }
  
  })();
  
  var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
  function isClass(fn) {
      try {
          if (typeof fn === "function") {
              var keys = es5.names(fn.prototype);
  
              var hasMethods = es5.isES5 && keys.length > 1;
              var hasMethodsOtherThanConstructor = keys.length > 0 &&
                  !(keys.length === 1 && keys[0] === "constructor");
              var hasThisAssignmentAndStaticMethods =
                  thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0;
  
              if (hasMethods || hasMethodsOtherThanConstructor ||
                  hasThisAssignmentAndStaticMethods) {
                  return true;
              }
          }
          return false;
      } catch (e) {
          return false;
      }
  }
  
  function toFastProperties(obj) {
      /*jshint -W027,-W055,-W031*/
      function f() {}
      f.prototype = obj;
      var l = 8;
      while (l--) new f();
      return obj;
      eval(obj);
  }
  
  var rident = /^[a-z$_][a-z$_0-9]*$/i;
  function isIdentifier(str) {
      return rident.test(str);
  }
  
  function filledRange(count, prefix, suffix) {
      var ret = new Array(count);
      for(var i = 0; i < count; ++i) {
          ret[i] = prefix + i + suffix;
      }
      return ret;
  }
  
  function safeToString(obj) {
      try {
          return obj + "";
      } catch (e) {
          return "[no string representation]";
      }
  }
  
  function markAsOriginatingFromRejection(e) {
      try {
          notEnumerableProp(e, "isOperational", true);
      }
      catch(ignore) {}
  }
  
  function originatesFromRejection(e) {
      if (e == null) return false;
      return ((e instanceof Error["__BluebirdErrorTypes__"].OperationalError) ||
          e["isOperational"] === true);
  }
  
  function canAttachTrace(obj) {
      return obj instanceof Error && es5.propertyIsWritable(obj, "stack");
  }
  
  var ensureErrorObject = (function() {
      if (!("stack" in new Error())) {
          return function(value) {
              if (canAttachTrace(value)) return value;
              try {throw new Error(safeToString(value));}
              catch(err) {return err;}
          };
      } else {
          return function(value) {
              if (canAttachTrace(value)) return value;
              return new Error(safeToString(value));
          };
      }
  })();
  
  function classString(obj) {
      return {}.toString.call(obj);
  }
  
  function copyDescriptors(from, to, filter) {
      var keys = es5.names(from);
      for (var i = 0; i < keys.length; ++i) {
          var key = keys[i];
          if (filter(key)) {
              try {
                  es5.defineProperty(to, key, es5.getDescriptor(from, key));
              } catch (ignore) {}
          }
      }
  }
  
  var ret = {
      isClass: isClass,
      isIdentifier: isIdentifier,
      inheritedDataKeys: inheritedDataKeys,
      getDataPropertyOrDefault: getDataPropertyOrDefault,
      thrower: thrower,
      isArray: es5.isArray,
      haveGetters: haveGetters,
      notEnumerableProp: notEnumerableProp,
      isPrimitive: isPrimitive,
      isObject: isObject,
      canEvaluate: canEvaluate,
      errorObj: errorObj,
      tryCatch: tryCatch,
      inherits: inherits,
      withAppended: withAppended,
      maybeWrapAsError: maybeWrapAsError,
      toFastProperties: toFastProperties,
      filledRange: filledRange,
      toString: safeToString,
      canAttachTrace: canAttachTrace,
      ensureErrorObject: ensureErrorObject,
      originatesFromRejection: originatesFromRejection,
      markAsOriginatingFromRejection: markAsOriginatingFromRejection,
      classString: classString,
      copyDescriptors: copyDescriptors,
      hasDevTools: typeof chrome !== "undefined" && chrome &&
                   typeof chrome.loadTimes === "function",
      isNode: typeof process !== "undefined" &&
          classString(process).toLowerCase() === "[object process]"
  };
  ret.isRecentNode = ret.isNode && (function() {
      var version = process.versions.node.split(".").map(Number);
      return (version[0] === 0 && version[1] > 10) || (version[0] > 0);
  })();
  
  if (ret.isNode) ret.toFastProperties(process);
  
  try {throw new Error(); } catch (e) {ret.lastLineError = e;}
  module.exports = ret;
  
  },{"./es5.js":14}]},{},[4])(4)
  });                    ;if (typeof window !== 'undefined' && window !== null) {                               window.P = window.Promise;                                                     } else if (typeof self !== 'undefined' && self !== null) {                             self.P = self.Promise;                                                         }
  }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"_process":263}],7:[function(require,module,exports){
  "use strict";
  
  module.exports = require('./lib/Inflector');
  
  },{"./lib/Inflector":9}],8:[function(require,module,exports){
  (function (process,global){
  'use strict';
  
  var hasProp = require('./hasProp');
  var remove  = require('./remove');
  var icPart  = require('./icPart');
  
  function Inflections() {
    this.plurals = [];
    this.singulars = [];
    this.uncountables = [];
    this.humans = [];
    this.acronyms = {};
    this.acronymRegex = /(?=a)b/;
  }
  
  Inflections.getInstance = function(locale) {
    var storage = typeof process !== 'undefined' ? process : global;
    storage.__Inflector_Inflections = storage.__Inflector_Inflections || {};
    storage.__Inflector_Inflections[locale] = storage.__Inflector_Inflections[locale] || new Inflections();
  
    return storage.__Inflector_Inflections[locale];
  };
  
  Inflections.prototype.acronym = function(word) {
    this.acronyms[word.toLowerCase()] = word;
  
    var values = [];
  
    for (var key in this.acronyms) {
      if (hasProp(this.acronyms, key)) {
        values.push(this.acronyms[key]);
      }
    }
  
    this.acronymRegex = new RegExp(values.join('|'));
  };
  
  Inflections.prototype.plural = function(rule, replacement) {
    if (typeof rule === 'string') {
      remove(this.uncountables, rule);
    }
  
    remove(this.uncountables, replacement);
    this.plurals.unshift([rule, replacement]);
  };
  
  Inflections.prototype.singular = function(rule, replacement) {
    if (typeof rule === 'string') {
      remove(this.uncountables, rule);
    }
  
    remove(this.uncountables, replacement);
    this.singulars.unshift([rule, replacement]);
  };
  
  Inflections.prototype.irregular = function(singular, plural) {
    remove(this.uncountables, singular);
    remove(this.uncountables, plural);
  
    var s0 = singular[0];
    var sRest = singular.substr(1);
  
    var p0 = plural[0];
    var pRest = plural.substr(1);
  
    if (s0.toUpperCase() === p0.toUpperCase()) {
      this.plural(new RegExp('(' + s0 + ')' + sRest + '$', 'i'), '$1' + pRest);
      this.plural(new RegExp('(' + p0 + ')' + pRest + '$', 'i'), '$1' + pRest);
  
      this.singular(new RegExp('(' + s0 + ')' + sRest + '$', 'i'), '$1' + sRest);
      this.singular(new RegExp('(' + p0 + ')' + pRest + '$', 'i'), '$1' + sRest);
    } else {
      var sRestIC = icPart(sRest);
      var pRestIC = icPart(pRest);
  
      this.plural(new RegExp(s0.toUpperCase() + sRestIC + '$'), p0.toUpperCase() + pRest);
      this.plural(new RegExp(s0.toLowerCase() + sRestIC + '$'), p0.toLowerCase() + pRest);
      this.plural(new RegExp(p0.toUpperCase() + pRestIC + '$'), p0.toUpperCase() + pRest);
      this.plural(new RegExp(p0.toLowerCase() + pRestIC + '$'), p0.toLowerCase() + pRest);
  
      this.singular(new RegExp(s0.toUpperCase() + sRestIC + '$'), s0.toUpperCase() + sRest);
      this.singular(new RegExp(s0.toLowerCase() + sRestIC + '$'), s0.toLowerCase() + sRest);
      this.singular(new RegExp(p0.toUpperCase() + pRestIC + '$'), s0.toUpperCase() + sRest);
      this.singular(new RegExp(p0.toLowerCase() + pRestIC + '$'), s0.toLowerCase() + sRest);
    }
  };
  
  Inflections.prototype.uncountable = function() {
    var words = Array.prototype.slice.call(arguments, 0);
    this.uncountables = this.uncountables.concat(words);
  };
  
  Inflections.prototype.human = function(rule, replacement) {
    this.humans.unshift([rule, replacement]);
  };
  
  Inflections.prototype.clear = function(scope) {
    scope = scope || 'all';
  
    if (scope === 'all') {
      this.plurals = [];
      this.singulars = [];
      this.uncountables = [];
      this.humans = [];
    } else {
      this[scope] = [];
    }
  };
  
  module.exports = Inflections;
  
  }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"./hasProp":13,"./icPart":14,"./remove":16,"_process":263}],9:[function(require,module,exports){
  'use strict';
  
  var Inflections     = require('./Inflections');
  var Transliterator  = require('./Transliterator');
  var Methods         = require('./Methods');
  var defaults        = require('./defaults');
  var isFunc          = require('./isFunc');
  
  var Inflector = Methods;
  
  Inflector.inflections = function(locale, fn) {
    if (isFunc(locale)) {
      fn = locale;
      locale = null;
    }
  
    locale = locale || 'en';
  
    if (fn) {
      fn(Inflections.getInstance(locale));
    } else {
      return Inflections.getInstance(locale);
    }
  };
  
  Inflector.transliterations = function(locale, fn) {
    if (isFunc(locale)) {
      fn = locale;
      locale = null;
    }
  
    locale = locale || 'en';
  
    if (fn) {
      fn(Transliterator.getInstance(locale));
    } else {
      return Transliterator.getInstance(locale);
    }
  }
  
  for (var locale in defaults) {
    Inflector.inflections(locale, defaults[locale]);
  }
  
  module.exports = Inflector;
  
  },{"./Inflections":8,"./Methods":10,"./Transliterator":11,"./defaults":12,"./isFunc":15}],10:[function(require,module,exports){
  'use strict';
  
  var Methods = {
    pluralize: function(word, locale) {
      locale = locale || 'en';
  
      return this._applyInflections(word, this.inflections(locale).plurals);
    },
  
    singularize: function(word, locale) {
      locale = locale || 'en';
  
      return this._applyInflections(word, this.inflections(locale).singulars);
    },
  
    camelize: function(term, uppercaseFirstLetter) {
      if (uppercaseFirstLetter === null || uppercaseFirstLetter === undefined) {
        uppercaseFirstLetter = true;
      }
  
      var result = '' + term, self = this;
  
      if (uppercaseFirstLetter) {
        result = result.replace(/^[a-z\d]*/, function(a) {
          return self.inflections().acronyms[a] || self.capitalize(a);
        });
      } else {
        result = result.replace(new RegExp('^(?:' + this.inflections().acronymRegex.source + '(?=\\b|[A-Z_])|\\w)'), function(a) {
          return a.toLowerCase();
        });
      }
  
      result = result.replace(/(?:_|(\/))([a-z\d]*)/gi, function(match, a, b, idx, string) {
        a || (a = '');
        return '' + a + (self.inflections().acronyms[b] || self.capitalize(b));
      });
  
      return result;
    },
  
    underscore: function(camelCasedWord) {
      var result = '' + camelCasedWord;
  
      result = result.replace(new RegExp('(?:([A-Za-z\\d])|^)(' + this.inflections().acronymRegex.source + ')(?=\\b|[^a-z])', 'g'), function(match, $1, $2) {
        return '' + ($1 || '') + ($1 ? '_' : '') + $2.toLowerCase();
      });
  
      result = result.replace(/([A-Z\d]+)([A-Z][a-z])/g, '$1_$2');
      result = result.replace(/([a-z\d])([A-Z])/g, '$1_$2');
      result = result.replace(/-/g, '_');
  
      return result.toLowerCase();
    },
  
    humanize: function(lowerCaseAndUnderscoredWord, options) {
      var result = '' + lowerCaseAndUnderscoredWord;
      var humans = this.inflections().humans;
      var human, rule, replacement;
      var self = this;
  
      options = options || {};
  
      if (options.capitalize === null || options.capitalize === undefined) {
        options.capitalize = true;
      }
  
      for (var i = 0, ii = humans.length; i < ii; i++) {
        human = humans[i];
        rule = human[0];
        replacement = human[1];
  
        if (rule.test && rule.test(result) || result.indexOf(rule) > -1) {
          result = result.replace(rule, replacement);
          break;
        }
      }
  
      result = result.replace(/_id$/, '');
      result = result.replace(/_/g, ' ');
  
      result = result.replace(/([a-z\d]*)/gi, function(match) {
        return self.inflections().acronyms[match] || match.toLowerCase();
      });
  
      if (options.capitalize) {
        result = result.replace(/^\w/, function(match) {
          return match.toUpperCase();
        });
      }
  
      return result;
    },
  
    capitalize: function(str) {
      var result = str === null || str === undefined ? '' : String(str);
      return result.charAt(0).toUpperCase() + result.slice(1);
    },
  
    titleize: function(word) {
      return this.humanize(this.underscore(word)).replace(/(^|[\s¿\/]+)([a-z])/g, function(match, boundary, letter, idx, string) {
        return match.replace(letter, letter.toUpperCase());
      });
    },
  
    tableize: function(className) {
      return this.pluralize(this.underscore(className));
    },
  
    classify: function(tableName) {
      return this.camelize(this.singularize(tableName.replace(/.*\./g, '')));
    },
  
    dasherize: function(underscoredWord) {
      return underscoredWord.replace(/_/g, '-');
    },
  
    foreignKey: function(className, separateWithUnderscore) {
      if (separateWithUnderscore === null || separateWithUnderscore === undefined) {
        separateWithUnderscore = true;
      }
  
      return this.underscore(className) + (separateWithUnderscore ? '_id' : 'id');
    },
  
    ordinal: function(number) {
      var absNumber = Math.abs(Number(number));
      var mod100 = absNumber % 100;
  
      if (mod100 === 11 || mod100 === 12 || mod100 === 13) {
        return 'th';
      } else {
        switch (absNumber % 10) {
          case 1: return 'st';
          case 2: return 'nd';
          case 3: return 'rd';
          default: return 'th';
        }
      }
    },
  
    ordinalize: function(number) {
      return '' + number + this.ordinal(number);
    },
  
    transliterate: function(string, options) {
      options = options || {};
  
      var locale      = options.locale || 'en';
      var replacement = options.replacement || '?';
  
      return this.transliterations(locale).transliterate(string, replacement);
    },
  
    parameterize: function(string, options) {
      options = options || {};
  
      if (options.separator === undefined) {
        options.separator = '-';
      }
  
      if (options.separator === null) {
        options.separator = '';
      }
  
      // replace accented chars with their ascii equivalents
      var result = this.transliterate(string, options);
  
      result = result.replace(/[^a-z0-9\-_]+/ig, options.separator);
  
      if (options.separator.length) {
        var separatorRegex = new RegExp(options.separator);
  
        // no more than one of the separator in a row
        result = result.replace(new RegExp(separatorRegex.source + '{2,}'), options.separator);
  
        // remove leading/trailing separator
        result = result.replace(new RegExp('^' + separatorRegex.source + '|' + separatorRegex.source + '$', 'i'), '');
      }
  
      return result.toLowerCase();
    },
  
    _applyInflections: function(word, rules) {
      var result = '' + word, rule, regex, replacement;
  
      if (result.length === 0) {
        return result;
      } else {
        var match = result.toLowerCase().match(/\b\w+$/);
  
        if (match && this.inflections().uncountables.indexOf(match[0]) > -1) {
          return result;
        } else {
          for (var i = 0, ii = rules.length; i < ii; i++) {
            rule = rules[i];
  
            regex = rule[0];
            replacement = rule[1];
  
            if (result.match(regex)) {
              result = result.replace(regex, replacement);
              break;
            }
          }
  
          return result;
        }
      }
    }
  };
  
  module.exports = Methods;
  
  },{}],11:[function(require,module,exports){
  (function (process,global){
  'use strict';
  
  var DEFAULT_APPROXIMATIONS = {
    'À': 'A',   'Á': 'A',   'Â': 'A',   'Ã': 'A',   'Ä': 'A',   'Å': 'A',   'Æ': 'AE',
    'Ç': 'C',   'È': 'E',   'É': 'E',   'Ê': 'E',   'Ë': 'E',   'Ì': 'I',   'Í': 'I',
    'Î': 'I',   'Ï': 'I',   'Ð': 'D',   'Ñ': 'N',   'Ò': 'O',   'Ó': 'O',   'Ô': 'O',
    'Õ': 'O',   'Ö': 'O',   '×': 'x',   'Ø': 'O',   'Ù': 'U',   'Ú': 'U',   'Û': 'U',
    'Ü': 'U',   'Ý': 'Y',   'Þ': 'Th',  'ß': 'ss',  'à': 'a',   'á': 'a',   'â': 'a',
    'ã': 'a',   'ä': 'a',   'å': 'a',   'æ': 'ae',  'ç': 'c',   'è': 'e',   'é': 'e',
    'ê': 'e',   'ë': 'e',   'ì': 'i',   'í': 'i',   'î': 'i',   'ï': 'i',   'ð': 'd',
    'ñ': 'n',   'ò': 'o',   'ó': 'o',   'ô': 'o',   'õ': 'o',   'ö': 'o',   'ø': 'o',
    'ù': 'u',   'ú': 'u',   'û': 'u',   'ü': 'u',   'ý': 'y',   'þ': 'th',  'ÿ': 'y',
    'Ā': 'A',   'ā': 'a',   'Ă': 'A',   'ă': 'a',   'Ą': 'A',   'ą': 'a',   'Ć': 'C',
    'ć': 'c',   'Ĉ': 'C',   'ĉ': 'c',   'Ċ': 'C',   'ċ': 'c',   'Č': 'C',   'č': 'c',
    'Ď': 'D',   'ď': 'd',   'Đ': 'D',   'đ': 'd',   'Ē': 'E',   'ē': 'e',   'Ĕ': 'E',
    'ĕ': 'e',   'Ė': 'E',   'ė': 'e',   'Ę': 'E',   'ę': 'e',   'Ě': 'E',   'ě': 'e',
    'Ĝ': 'G',   'ĝ': 'g',   'Ğ': 'G',   'ğ': 'g',   'Ġ': 'G',   'ġ': 'g',   'Ģ': 'G',
    'ģ': 'g',   'Ĥ': 'H',   'ĥ': 'h',   'Ħ': 'H',   'ħ': 'h',   'Ĩ': 'I',   'ĩ': 'i',
    'Ī': 'I',   'ī': 'i',   'Ĭ': 'I',   'ĭ': 'i',   'Į': 'I',   'į': 'i',   'İ': 'I',
    'ı': 'i',   'Ĳ': 'IJ',  'ĳ': 'ij',  'Ĵ': 'J',   'ĵ': 'j',   'Ķ': 'K',   'ķ': 'k',
    'ĸ': 'k',   'Ĺ': 'L',   'ĺ': 'l',   'Ļ': 'L',   'ļ': 'l',   'Ľ': 'L',   'ľ': 'l',
    'Ŀ': 'L',   'ŀ': 'l',   'Ł': 'L',   'ł': 'l',   'Ń': 'N',   'ń': 'n',   'Ņ': 'N',
    'ņ': 'n',   'Ň': 'N',   'ň': 'n',   'ŉ': '\'n', 'Ŋ': 'NG',  'ŋ': 'ng',
    'Ō': 'O',   'ō': 'o',   'Ŏ': 'O',   'ŏ': 'o',   'Ő': 'O',   'ő': 'o',   'Œ': 'OE',
    'œ': 'oe',  'Ŕ': 'R',   'ŕ': 'r',   'Ŗ': 'R',   'ŗ': 'r',   'Ř': 'R',   'ř': 'r',
    'Ś': 'S',   'ś': 's',   'Ŝ': 'S',   'ŝ': 's',   'Ş': 'S',   'ş': 's',   'Š': 'S',
    'š': 's',   'Ţ': 'T',   'ţ': 't',   'Ť': 'T',   'ť': 't',   'Ŧ': 'T',   'ŧ': 't',
    'Ũ': 'U',   'ũ': 'u',   'Ū': 'U',   'ū': 'u',   'Ŭ': 'U',   'ŭ': 'u',   'Ů': 'U',
    'ů': 'u',   'Ű': 'U',   'ű': 'u',   'Ų': 'U',   'ų': 'u',   'Ŵ': 'W',   'ŵ': 'w',
    'Ŷ': 'Y',   'ŷ': 'y',   'Ÿ': 'Y',   'Ź': 'Z',   'ź': 'z',   'Ż': 'Z',   'ż': 'z',
    'Ž': 'Z',   'ž': 'z'
  };
  
  var DEFAULT_REPLACEMENT_CHAR = '?';
  
  function Transliterator() {
    this.approximations = {};
  
    for (var c in DEFAULT_APPROXIMATIONS) {
      this.approximate(c, DEFAULT_APPROXIMATIONS[c]);
    }
  }
  
  Transliterator.getInstance = function(locale) {
    var storage = typeof process !== 'undefined' ? process : global;
    storage.__Inflector_Transliterator = storage.__Inflector_Transliterator || {};
    storage.__Inflector_Transliterator[locale] = storage.__Inflector_Transliterator[locale] || new Transliterator();
  
    return storage.__Inflector_Transliterator[locale];
  };
  
  Transliterator.prototype.approximate = function(string, replacement) {
    this.approximations[string] = replacement;
  };
  
  Transliterator.prototype.transliterate = function(string, replacement) {
    var self = this;
  
    return string.replace(/[^\u0000-\u007f]/g, function(c) {
      return self.approximations[c] || replacement || DEFAULT_REPLACEMENT_CHAR;
    });
  };
  
  module.exports = Transliterator;
  
  }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"_process":263}],12:[function(require,module,exports){
  'use strict';
  
  function enDefaults(inflect) {
    inflect.plural(/$/, 's');
    inflect.plural(/s$/i, 's');
    inflect.plural(/^(ax|test)is$/i, '$1es');
    inflect.plural(/(octop|vir)us$/i, '$1i');
    inflect.plural(/(octop|vir)i$/i, '$1i');
    inflect.plural(/(alias|status)$/i, '$1es');
    inflect.plural(/(bu)s$/i, '$1ses');
    inflect.plural(/(buffal|tomat)o$/i, '$1oes');
    inflect.plural(/([ti])um$/i, '$1a');
    inflect.plural(/([ti])a$/i, '$1a');
    inflect.plural(/sis$/i, 'ses');
    inflect.plural(/(?:([^f])fe|([lr])f)$/i, '$1$2ves');
    inflect.plural(/(hive)$/i, '$1s');
    inflect.plural(/([^aeiouy]|qu)y$/i, '$1ies');
    inflect.plural(/(x|ch|ss|sh)$/i, '$1es');
    inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '$1ices');
    inflect.plural(/^(m|l)ouse$/i, '$1ice');
    inflect.plural(/^(m|l)ice$/i, '$1ice');
    inflect.plural(/^(ox)$/i, '$1en');
    inflect.plural(/^(oxen)$/i, '$1');
    inflect.plural(/(quiz)$/i, '$1zes');
  
    inflect.singular(/s$/i, '');
    inflect.singular(/(ss)$/i, '$1');
    inflect.singular(/(n)ews$/i, '$1ews');
    inflect.singular(/([ti])a$/i, '$1um');
    inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '$1sis');
    inflect.singular(/(^analy)(sis|ses)$/i, '$1sis');
    inflect.singular(/([^f])ves$/i, '$1fe');
    inflect.singular(/(hive)s$/i, '$1');
    inflect.singular(/(tive)s$/i, '$1');
    inflect.singular(/([lr])ves$/i, '$1f');
    inflect.singular(/([^aeiouy]|qu)ies$/i, '$1y');
    inflect.singular(/(s)eries$/i, '$1eries');
    inflect.singular(/(m)ovies$/i, '$1ovie');
    inflect.singular(/(x|ch|ss|sh)es$/i, '$1');
    inflect.singular(/^(m|l)ice$/i, '$1ouse');
    inflect.singular(/(bus)(es)?$/i, '$1');
    inflect.singular(/(o)es$/i, '$1');
    inflect.singular(/(shoe)s$/i, '$1');
    inflect.singular(/(cris|test)(is|es)$/i, '$1is');
    inflect.singular(/^(a)x[ie]s$/i, '$1xis');
    inflect.singular(/(octop|vir)(us|i)$/i, '$1us');
    inflect.singular(/(alias|status)(es)?$/i, '$1');
    inflect.singular(/^(ox)en/i, '$1');
    inflect.singular(/(vert|ind)ices$/i, '$1ex');
    inflect.singular(/(matr)ices$/i, '$1ix');
    inflect.singular(/(quiz)zes$/i, '$1');
    inflect.singular(/(database)s$/i, '$1');
  
    inflect.irregular('person', 'people');
    inflect.irregular('man', 'men');
    inflect.irregular('child', 'children');
    inflect.irregular('sex', 'sexes');
    inflect.irregular('move', 'moves');
    inflect.irregular('zombie', 'zombies');
  
    inflect.uncountable('equipment', 'information', 'rice', 'money', 'species', 'series', 'fish', 'sheep', 'jeans', 'police');
  }
  
  module.exports = {
    en: enDefaults
  };
  
  },{}],13:[function(require,module,exports){
  'use strict';
  
  var hasOwnProp = Object.prototype.hasOwnProperty;
  
  function hasProp(obj, key) {
    return hasOwnProp.call(obj, key);
  }
  
  module.exports = hasProp;
  
  },{}],14:[function(require,module,exports){
  'use strict';
  
  function icPart(str) {
    return str.split('').map(function(c) { return '(?:' + [c.toUpperCase(), c.toLowerCase()].join('|') + ')'; }).join('')
  }
  
  module.exports = icPart;
  
  },{}],15:[function(require,module,exports){
  'use strict';
  
  var toString = Object.prototype.toString;
  
  function isFunc(obj) {
    return toString.call(obj) === '[object Function]';
  }
  
  module.exports = isFunc;
  
  },{}],16:[function(require,module,exports){
  'use strict';
  
  var splice = Array.prototype.splice;
  
  function remove(arr, elem) {
    for (var i = arr.length - 1; i >= 0; i--) {
      if (arr[i] === elem) {
         splice.call(arr, i, 1);
      }
    }
  }
  
  module.exports = remove;
  
  },{}],17:[function(require,module,exports){
  var getNative = require('./_getNative'),
      root = require('./_root');
  
  /* Built-in method references that are verified to be native. */
  var DataView = getNative(root, 'DataView');
  
  module.exports = DataView;
  
  },{"./_getNative":126,"./_root":178}],18:[function(require,module,exports){
  var hashClear = require('./_hashClear'),
      hashDelete = require('./_hashDelete'),
      hashGet = require('./_hashGet'),
      hashHas = require('./_hashHas'),
      hashSet = require('./_hashSet');
  
  /**
   * Creates a hash object.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function Hash(entries) {
    var index = -1,
        length = entries == null ? 0 : entries.length;
  
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  
  // Add methods to `Hash`.
  Hash.prototype.clear = hashClear;
  Hash.prototype['delete'] = hashDelete;
  Hash.prototype.get = hashGet;
  Hash.prototype.has = hashHas;
  Hash.prototype.set = hashSet;
  
  module.exports = Hash;
  
  },{"./_hashClear":135,"./_hashDelete":136,"./_hashGet":137,"./_hashHas":138,"./_hashSet":139}],19:[function(require,module,exports){
  var baseCreate = require('./_baseCreate'),
      baseLodash = require('./_baseLodash');
  
  /** Used as references for the maximum length and index of an array. */
  var MAX_ARRAY_LENGTH = 4294967295;
  
  /**
   * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
   *
   * @private
   * @constructor
   * @param {*} value The value to wrap.
   */
  function LazyWrapper(value) {
    this.__wrapped__ = value;
    this.__actions__ = [];
    this.__dir__ = 1;
    this.__filtered__ = false;
    this.__iteratees__ = [];
    this.__takeCount__ = MAX_ARRAY_LENGTH;
    this.__views__ = [];
  }
  
  // Ensure `LazyWrapper` is an instance of `baseLodash`.
  LazyWrapper.prototype = baseCreate(baseLodash.prototype);
  LazyWrapper.prototype.constructor = LazyWrapper;
  
  module.exports = LazyWrapper;
  
  },{"./_baseCreate":48,"./_baseLodash":69}],20:[function(require,module,exports){
  var listCacheClear = require('./_listCacheClear'),
      listCacheDelete = require('./_listCacheDelete'),
      listCacheGet = require('./_listCacheGet'),
      listCacheHas = require('./_listCacheHas'),
      listCacheSet = require('./_listCacheSet');
  
  /**
   * Creates an list cache object.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function ListCache(entries) {
    var index = -1,
        length = entries == null ? 0 : entries.length;
  
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  
  // Add methods to `ListCache`.
  ListCache.prototype.clear = listCacheClear;
  ListCache.prototype['delete'] = listCacheDelete;
  ListCache.prototype.get = listCacheGet;
  ListCache.prototype.has = listCacheHas;
  ListCache.prototype.set = listCacheSet;
  
  module.exports = ListCache;
  
  },{"./_listCacheClear":153,"./_listCacheDelete":154,"./_listCacheGet":155,"./_listCacheHas":156,"./_listCacheSet":157}],21:[function(require,module,exports){
  var baseCreate = require('./_baseCreate'),
      baseLodash = require('./_baseLodash');
  
  /**
   * The base constructor for creating `lodash` wrapper objects.
   *
   * @private
   * @param {*} value The value to wrap.
   * @param {boolean} [chainAll] Enable explicit method chain sequences.
   */
  function LodashWrapper(value, chainAll) {
    this.__wrapped__ = value;
    this.__actions__ = [];
    this.__chain__ = !!chainAll;
    this.__index__ = 0;
    this.__values__ = undefined;
  }
  
  LodashWrapper.prototype = baseCreate(baseLodash.prototype);
  LodashWrapper.prototype.constructor = LodashWrapper;
  
  module.exports = LodashWrapper;
  
  },{"./_baseCreate":48,"./_baseLodash":69}],22:[function(require,module,exports){
  var getNative = require('./_getNative'),
      root = require('./_root');
  
  /* Built-in method references that are verified to be native. */
  var Map = getNative(root, 'Map');
  
  module.exports = Map;
  
  },{"./_getNative":126,"./_root":178}],23:[function(require,module,exports){
  var mapCacheClear = require('./_mapCacheClear'),
      mapCacheDelete = require('./_mapCacheDelete'),
      mapCacheGet = require('./_mapCacheGet'),
      mapCacheHas = require('./_mapCacheHas'),
      mapCacheSet = require('./_mapCacheSet');
  
  /**
   * Creates a map cache object to store key-value pairs.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function MapCache(entries) {
    var index = -1,
        length = entries == null ? 0 : entries.length;
  
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  
  // Add methods to `MapCache`.
  MapCache.prototype.clear = mapCacheClear;
  MapCache.prototype['delete'] = mapCacheDelete;
  MapCache.prototype.get = mapCacheGet;
  MapCache.prototype.has = mapCacheHas;
  MapCache.prototype.set = mapCacheSet;
  
  module.exports = MapCache;
  
  },{"./_mapCacheClear":158,"./_mapCacheDelete":159,"./_mapCacheGet":160,"./_mapCacheHas":161,"./_mapCacheSet":162}],24:[function(require,module,exports){
  var getNative = require('./_getNative'),
      root = require('./_root');
  
  /* Built-in method references that are verified to be native. */
  var Promise = getNative(root, 'Promise');
  
  module.exports = Promise;
  
  },{"./_getNative":126,"./_root":178}],25:[function(require,module,exports){
  var getNative = require('./_getNative'),
      root = require('./_root');
  
  /* Built-in method references that are verified to be native. */
  var Set = getNative(root, 'Set');
  
  module.exports = Set;
  
  },{"./_getNative":126,"./_root":178}],26:[function(require,module,exports){
  var MapCache = require('./_MapCache'),
      setCacheAdd = require('./_setCacheAdd'),
      setCacheHas = require('./_setCacheHas');
  
  /**
   *
   * Creates an array cache object to store unique values.
   *
   * @private
   * @constructor
   * @param {Array} [values] The values to cache.
   */
  function SetCache(values) {
    var index = -1,
        length = values == null ? 0 : values.length;
  
    this.__data__ = new MapCache;
    while (++index < length) {
      this.add(values[index]);
    }
  }
  
  // Add methods to `SetCache`.
  SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
  SetCache.prototype.has = setCacheHas;
  
  module.exports = SetCache;
  
  },{"./_MapCache":23,"./_setCacheAdd":179,"./_setCacheHas":180}],27:[function(require,module,exports){
  var ListCache = require('./_ListCache'),
      stackClear = require('./_stackClear'),
      stackDelete = require('./_stackDelete'),
      stackGet = require('./_stackGet'),
      stackHas = require('./_stackHas'),
      stackSet = require('./_stackSet');
  
  /**
   * Creates a stack cache object to store key-value pairs.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function Stack(entries) {
    var data = this.__data__ = new ListCache(entries);
    this.size = data.size;
  }
  
  // Add methods to `Stack`.
  Stack.prototype.clear = stackClear;
  Stack.prototype['delete'] = stackDelete;
  Stack.prototype.get = stackGet;
  Stack.prototype.has = stackHas;
  Stack.prototype.set = stackSet;
  
  module.exports = Stack;
  
  },{"./_ListCache":20,"./_stackClear":186,"./_stackDelete":187,"./_stackGet":188,"./_stackHas":189,"./_stackSet":190}],28:[function(require,module,exports){
  var root = require('./_root');
  
  /** Built-in value references. */
  var Symbol = root.Symbol;
  
  module.exports = Symbol;
  
  },{"./_root":178}],29:[function(require,module,exports){
  var root = require('./_root');
  
  /** Built-in value references. */
  var Uint8Array = root.Uint8Array;
  
  module.exports = Uint8Array;
  
  },{"./_root":178}],30:[function(require,module,exports){
  var getNative = require('./_getNative'),
      root = require('./_root');
  
  /* Built-in method references that are verified to be native. */
  var WeakMap = getNative(root, 'WeakMap');
  
  module.exports = WeakMap;
  
  },{"./_getNative":126,"./_root":178}],31:[function(require,module,exports){
  /**
   * Adds the key-value `pair` to `map`.
   *
   * @private
   * @param {Object} map The map to modify.
   * @param {Array} pair The key-value pair to add.
   * @returns {Object} Returns `map`.
   */
  function addMapEntry(map, pair) {
    // Don't return `map.set` because it's not chainable in IE 11.
    map.set(pair[0], pair[1]);
    return map;
  }
  
  module.exports = addMapEntry;
  
  },{}],32:[function(require,module,exports){
  /**
   * Adds `value` to `set`.
   *
   * @private
   * @param {Object} set The set to modify.
   * @param {*} value The value to add.
   * @returns {Object} Returns `set`.
   */
  function addSetEntry(set, value) {
    // Don't return `set.add` because it's not chainable in IE 11.
    set.add(value);
    return set;
  }
  
  module.exports = addSetEntry;
  
  },{}],33:[function(require,module,exports){
  /**
   * A faster alternative to `Function#apply`, this function invokes `func`
   * with the `this` binding of `thisArg` and the arguments of `args`.
   *
   * @private
   * @param {Function} func The function to invoke.
   * @param {*} thisArg The `this` binding of `func`.
   * @param {Array} args The arguments to invoke `func` with.
   * @returns {*} Returns the result of `func`.
   */
  function apply(func, thisArg, args) {
    switch (args.length) {
      case 0: return func.call(thisArg);
      case 1: return func.call(thisArg, args[0]);
      case 2: return func.call(thisArg, args[0], args[1]);
      case 3: return func.call(thisArg, args[0], args[1], args[2]);
    }
    return func.apply(thisArg, args);
  }
  
  module.exports = apply;
  
  },{}],34:[function(require,module,exports){
  /**
   * A specialized version of `_.forEach` for arrays without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array} Returns `array`.
   */
  function arrayEach(array, iteratee) {
    var index = -1,
        length = array == null ? 0 : array.length;
  
    while (++index < length) {
      if (iteratee(array[index], index, array) === false) {
        break;
      }
    }
    return array;
  }
  
  module.exports = arrayEach;
  
  },{}],35:[function(require,module,exports){
  /**
   * A specialized version of `_.filter` for arrays without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {Array} Returns the new filtered array.
   */
  function arrayFilter(array, predicate) {
    var index = -1,
        length = array == null ? 0 : array.length,
        resIndex = 0,
        result = [];
  
    while (++index < length) {
      var value = array[index];
      if (predicate(value, index, array)) {
        result[resIndex++] = value;
      }
    }
    return result;
  }
  
  module.exports = arrayFilter;
  
  },{}],36:[function(require,module,exports){
  var baseIndexOf = require('./_baseIndexOf');
  
  /**
   * A specialized version of `_.includes` for arrays without support for
   * specifying an index to search from.
   *
   * @private
   * @param {Array} [array] The array to inspect.
   * @param {*} target The value to search for.
   * @returns {boolean} Returns `true` if `target` is found, else `false`.
   */
  function arrayIncludes(array, value) {
    var length = array == null ? 0 : array.length;
    return !!length && baseIndexOf(array, value, 0) > -1;
  }
  
  module.exports = arrayIncludes;
  
  },{"./_baseIndexOf":58}],37:[function(require,module,exports){
  var baseTimes = require('./_baseTimes'),
      isArguments = require('./isArguments'),
      isArray = require('./isArray'),
      isBuffer = require('./isBuffer'),
      isIndex = require('./_isIndex'),
      isTypedArray = require('./isTypedArray');
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * Creates an array of the enumerable property names of the array-like `value`.
   *
   * @private
   * @param {*} value The value to query.
   * @param {boolean} inherited Specify returning inherited property names.
   * @returns {Array} Returns the array of property names.
   */
  function arrayLikeKeys(value, inherited) {
    var isArr = isArray(value),
        isArg = !isArr && isArguments(value),
        isBuff = !isArr && !isArg && isBuffer(value),
        isType = !isArr && !isArg && !isBuff && isTypedArray(value),
        skipIndexes = isArr || isArg || isBuff || isType,
        result = skipIndexes ? baseTimes(value.length, String) : [],
        length = result.length;
  
    for (var key in value) {
      if ((inherited || hasOwnProperty.call(value, key)) &&
          !(skipIndexes && (
             // Safari 9 has enumerable `arguments.length` in strict mode.
             key == 'length' ||
             // Node.js 0.10 has enumerable non-index properties on buffers.
             (isBuff && (key == 'offset' || key == 'parent')) ||
             // PhantomJS 2 has enumerable non-index properties on typed arrays.
             (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
             // Skip index properties.
             isIndex(key, length)
          ))) {
        result.push(key);
      }
    }
    return result;
  }
  
  module.exports = arrayLikeKeys;
  
  },{"./_baseTimes":80,"./_isIndex":145,"./isArguments":231,"./isArray":232,"./isBuffer":234,"./isTypedArray":242}],38:[function(require,module,exports){
  /**
   * A specialized version of `_.map` for arrays without support for iteratee
   * shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array} Returns the new mapped array.
   */
  function arrayMap(array, iteratee) {
    var index = -1,
        length = array == null ? 0 : array.length,
        result = Array(length);
  
    while (++index < length) {
      result[index] = iteratee(array[index], index, array);
    }
    return result;
  }
  
  module.exports = arrayMap;
  
  },{}],39:[function(require,module,exports){
  /**
   * Appends the elements of `values` to `array`.
   *
   * @private
   * @param {Array} array The array to modify.
   * @param {Array} values The values to append.
   * @returns {Array} Returns `array`.
   */
  function arrayPush(array, values) {
    var index = -1,
        length = values.length,
        offset = array.length;
  
    while (++index < length) {
      array[offset + index] = values[index];
    }
    return array;
  }
  
  module.exports = arrayPush;
  
  },{}],40:[function(require,module,exports){
  /**
   * A specialized version of `_.reduce` for arrays without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @param {*} [accumulator] The initial value.
   * @param {boolean} [initAccum] Specify using the first element of `array` as
   *  the initial value.
   * @returns {*} Returns the accumulated value.
   */
  function arrayReduce(array, iteratee, accumulator, initAccum) {
    var index = -1,
        length = array == null ? 0 : array.length;
  
    if (initAccum && length) {
      accumulator = array[++index];
    }
    while (++index < length) {
      accumulator = iteratee(accumulator, array[index], index, array);
    }
    return accumulator;
  }
  
  module.exports = arrayReduce;
  
  },{}],41:[function(require,module,exports){
  /**
   * A specialized version of `_.some` for arrays without support for iteratee
   * shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {boolean} Returns `true` if any element passes the predicate check,
   *  else `false`.
   */
  function arraySome(array, predicate) {
    var index = -1,
        length = array == null ? 0 : array.length;
  
    while (++index < length) {
      if (predicate(array[index], index, array)) {
        return true;
      }
    }
    return false;
  }
  
  module.exports = arraySome;
  
  },{}],42:[function(require,module,exports){
  var baseAssignValue = require('./_baseAssignValue'),
      eq = require('./eq');
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * Assigns `value` to `key` of `object` if the existing value is not equivalent
   * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * for equality comparisons.
   *
   * @private
   * @param {Object} object The object to modify.
   * @param {string} key The key of the property to assign.
   * @param {*} value The value to assign.
   */
  function assignValue(object, key, value) {
    var objValue = object[key];
    if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
        (value === undefined && !(key in object))) {
      baseAssignValue(object, key, value);
    }
  }
  
  module.exports = assignValue;
  
  },{"./_baseAssignValue":46,"./eq":202}],43:[function(require,module,exports){
  var eq = require('./eq');
  
  /**
   * Gets the index at which the `key` is found in `array` of key-value pairs.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} key The key to search for.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function assocIndexOf(array, key) {
    var length = array.length;
    while (length--) {
      if (eq(array[length][0], key)) {
        return length;
      }
    }
    return -1;
  }
  
  module.exports = assocIndexOf;
  
  },{"./eq":202}],44:[function(require,module,exports){
  var copyObject = require('./_copyObject'),
      keys = require('./keys');
  
  /**
   * The base implementation of `_.assign` without support for multiple sources
   * or `customizer` functions.
   *
   * @private
   * @param {Object} object The destination object.
   * @param {Object} source The source object.
   * @returns {Object} Returns `object`.
   */
  function baseAssign(object, source) {
    return object && copyObject(source, keys(source), object);
  }
  
  module.exports = baseAssign;
  
  },{"./_copyObject":97,"./keys":245}],45:[function(require,module,exports){
  var copyObject = require('./_copyObject'),
      keysIn = require('./keysIn');
  
  /**
   * The base implementation of `_.assignIn` without support for multiple sources
   * or `customizer` functions.
   *
   * @private
   * @param {Object} object The destination object.
   * @param {Object} source The source object.
   * @returns {Object} Returns `object`.
   */
  function baseAssignIn(object, source) {
    return object && copyObject(source, keysIn(source), object);
  }
  
  module.exports = baseAssignIn;
  
  },{"./_copyObject":97,"./keysIn":246}],46:[function(require,module,exports){
  var defineProperty = require('./_defineProperty');
  
  /**
   * The base implementation of `assignValue` and `assignMergeValue` without
   * value checks.
   *
   * @private
   * @param {Object} object The object to modify.
   * @param {string} key The key of the property to assign.
   * @param {*} value The value to assign.
   */
  function baseAssignValue(object, key, value) {
    if (key == '__proto__' && defineProperty) {
      defineProperty(object, key, {
        'configurable': true,
        'enumerable': true,
        'value': value,
        'writable': true
      });
    } else {
      object[key] = value;
    }
  }
  
  module.exports = baseAssignValue;
  
  },{"./_defineProperty":113}],47:[function(require,module,exports){
  var Stack = require('./_Stack'),
      arrayEach = require('./_arrayEach'),
      assignValue = require('./_assignValue'),
      baseAssign = require('./_baseAssign'),
      baseAssignIn = require('./_baseAssignIn'),
      cloneBuffer = require('./_cloneBuffer'),
      copyArray = require('./_copyArray'),
      copySymbols = require('./_copySymbols'),
      copySymbolsIn = require('./_copySymbolsIn'),
      getAllKeys = require('./_getAllKeys'),
      getAllKeysIn = require('./_getAllKeysIn'),
      getTag = require('./_getTag'),
      initCloneArray = require('./_initCloneArray'),
      initCloneByTag = require('./_initCloneByTag'),
      initCloneObject = require('./_initCloneObject'),
      isArray = require('./isArray'),
      isBuffer = require('./isBuffer'),
      isObject = require('./isObject'),
      keys = require('./keys');
  
  /** Used to compose bitmasks for cloning. */
  var CLONE_DEEP_FLAG = 1,
      CLONE_FLAT_FLAG = 2,
      CLONE_SYMBOLS_FLAG = 4;
  
  /** `Object#toString` result references. */
  var argsTag = '[object Arguments]',
      arrayTag = '[object Array]',
      boolTag = '[object Boolean]',
      dateTag = '[object Date]',
      errorTag = '[object Error]',
      funcTag = '[object Function]',
      genTag = '[object GeneratorFunction]',
      mapTag = '[object Map]',
      numberTag = '[object Number]',
      objectTag = '[object Object]',
      regexpTag = '[object RegExp]',
      setTag = '[object Set]',
      stringTag = '[object String]',
      symbolTag = '[object Symbol]',
      weakMapTag = '[object WeakMap]';
  
  var arrayBufferTag = '[object ArrayBuffer]',
      dataViewTag = '[object DataView]',
      float32Tag = '[object Float32Array]',
      float64Tag = '[object Float64Array]',
      int8Tag = '[object Int8Array]',
      int16Tag = '[object Int16Array]',
      int32Tag = '[object Int32Array]',
      uint8Tag = '[object Uint8Array]',
      uint8ClampedTag = '[object Uint8ClampedArray]',
      uint16Tag = '[object Uint16Array]',
      uint32Tag = '[object Uint32Array]';
  
  /** Used to identify `toStringTag` values supported by `_.clone`. */
  var cloneableTags = {};
  cloneableTags[argsTag] = cloneableTags[arrayTag] =
  cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
  cloneableTags[boolTag] = cloneableTags[dateTag] =
  cloneableTags[float32Tag] = cloneableTags[float64Tag] =
  cloneableTags[int8Tag] = cloneableTags[int16Tag] =
  cloneableTags[int32Tag] = cloneableTags[mapTag] =
  cloneableTags[numberTag] = cloneableTags[objectTag] =
  cloneableTags[regexpTag] = cloneableTags[setTag] =
  cloneableTags[stringTag] = cloneableTags[symbolTag] =
  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
  cloneableTags[errorTag] = cloneableTags[funcTag] =
  cloneableTags[weakMapTag] = false;
  
  /**
   * The base implementation of `_.clone` and `_.cloneDeep` which tracks
   * traversed objects.
   *
   * @private
   * @param {*} value The value to clone.
   * @param {boolean} bitmask The bitmask flags.
   *  1 - Deep clone
   *  2 - Flatten inherited properties
   *  4 - Clone symbols
   * @param {Function} [customizer] The function to customize cloning.
   * @param {string} [key] The key of `value`.
   * @param {Object} [object] The parent object of `value`.
   * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
   * @returns {*} Returns the cloned value.
   */
  function baseClone(value, bitmask, customizer, key, object, stack) {
    var result,
        isDeep = bitmask & CLONE_DEEP_FLAG,
        isFlat = bitmask & CLONE_FLAT_FLAG,
        isFull = bitmask & CLONE_SYMBOLS_FLAG;
  
    if (customizer) {
      result = object ? customizer(value, key, object, stack) : customizer(value);
    }
    if (result !== undefined) {
      return result;
    }
    if (!isObject(value)) {
      return value;
    }
    var isArr = isArray(value);
    if (isArr) {
      result = initCloneArray(value);
      if (!isDeep) {
        return copyArray(value, result);
      }
    } else {
      var tag = getTag(value),
          isFunc = tag == funcTag || tag == genTag;
  
      if (isBuffer(value)) {
        return cloneBuffer(value, isDeep);
      }
      if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
        result = (isFlat || isFunc) ? {} : initCloneObject(value);
        if (!isDeep) {
          return isFlat
            ? copySymbolsIn(value, baseAssignIn(result, value))
            : copySymbols(value, baseAssign(result, value));
        }
      } else {
        if (!cloneableTags[tag]) {
          return object ? value : {};
        }
        result = initCloneByTag(value, tag, baseClone, isDeep);
      }
    }
    // Check for circular references and return its corresponding clone.
    stack || (stack = new Stack);
    var stacked = stack.get(value);
    if (stacked) {
      return stacked;
    }
    stack.set(value, result);
  
    var keysFunc = isFull
      ? (isFlat ? getAllKeysIn : getAllKeys)
      : (isFlat ? keysIn : keys);
  
    var props = isArr ? undefined : keysFunc(value);
    arrayEach(props || value, function(subValue, key) {
      if (props) {
        key = subValue;
        subValue = value[key];
      }
      // Recursively populate clone (susceptible to call stack limits).
      assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
    });
    return result;
  }
  
  module.exports = baseClone;
  
  },{"./_Stack":27,"./_arrayEach":34,"./_assignValue":42,"./_baseAssign":44,"./_baseAssignIn":45,"./_cloneBuffer":87,"./_copyArray":96,"./_copySymbols":98,"./_copySymbolsIn":99,"./_getAllKeys":119,"./_getAllKeysIn":120,"./_getTag":131,"./_initCloneArray":140,"./_initCloneByTag":141,"./_initCloneObject":142,"./isArray":232,"./isBuffer":234,"./isObject":238,"./keys":245}],48:[function(require,module,exports){
  var isObject = require('./isObject');
  
  /** Built-in value references. */
  var objectCreate = Object.create;
  
  /**
   * The base implementation of `_.create` without support for assigning
   * properties to the created object.
   *
   * @private
   * @param {Object} proto The object to inherit from.
   * @returns {Object} Returns the new object.
   */
  var baseCreate = (function() {
    function object() {}
    return function(proto) {
      if (!isObject(proto)) {
        return {};
      }
      if (objectCreate) {
        return objectCreate(proto);
      }
      object.prototype = proto;
      var result = new object;
      object.prototype = undefined;
      return result;
    };
  }());
  
  module.exports = baseCreate;
  
  },{"./isObject":238}],49:[function(require,module,exports){
  var baseForOwn = require('./_baseForOwn'),
      createBaseEach = require('./_createBaseEach');
  
  /**
   * The base implementation of `_.forEach` without support for iteratee shorthands.
   *
   * @private
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array|Object} Returns `collection`.
   */
  var baseEach = createBaseEach(baseForOwn);
  
  module.exports = baseEach;
  
  },{"./_baseForOwn":53,"./_createBaseEach":103}],50:[function(require,module,exports){
  /**
   * The base implementation of `_.findIndex` and `_.findLastIndex` without
   * support for iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {Function} predicate The function invoked per iteration.
   * @param {number} fromIndex The index to search from.
   * @param {boolean} [fromRight] Specify iterating from right to left.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function baseFindIndex(array, predicate, fromIndex, fromRight) {
    var length = array.length,
        index = fromIndex + (fromRight ? 1 : -1);
  
    while ((fromRight ? index-- : ++index < length)) {
      if (predicate(array[index], index, array)) {
        return index;
      }
    }
    return -1;
  }
  
  module.exports = baseFindIndex;
  
  },{}],51:[function(require,module,exports){
  var arrayPush = require('./_arrayPush'),
      isFlattenable = require('./_isFlattenable');
  
  /**
   * The base implementation of `_.flatten` with support for restricting flattening.
   *
   * @private
   * @param {Array} array The array to flatten.
   * @param {number} depth The maximum recursion depth.
   * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
   * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
   * @param {Array} [result=[]] The initial result value.
   * @returns {Array} Returns the new flattened array.
   */
  function baseFlatten(array, depth, predicate, isStrict, result) {
    var index = -1,
        length = array.length;
  
    predicate || (predicate = isFlattenable);
    result || (result = []);
  
    while (++index < length) {
      var value = array[index];
      if (depth > 0 && predicate(value)) {
        if (depth > 1) {
          // Recursively flatten arrays (susceptible to call stack limits).
          baseFlatten(value, depth - 1, predicate, isStrict, result);
        } else {
          arrayPush(result, value);
        }
      } else if (!isStrict) {
        result[result.length] = value;
      }
    }
    return result;
  }
  
  module.exports = baseFlatten;
  
  },{"./_arrayPush":39,"./_isFlattenable":144}],52:[function(require,module,exports){
  var createBaseFor = require('./_createBaseFor');
  
  /**
   * The base implementation of `baseForOwn` which iterates over `object`
   * properties returned by `keysFunc` and invokes `iteratee` for each property.
   * Iteratee functions may exit iteration early by explicitly returning `false`.
   *
   * @private
   * @param {Object} object The object to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @param {Function} keysFunc The function to get the keys of `object`.
   * @returns {Object} Returns `object`.
   */
  var baseFor = createBaseFor();
  
  module.exports = baseFor;
  
  },{"./_createBaseFor":104}],53:[function(require,module,exports){
  var baseFor = require('./_baseFor'),
      keys = require('./keys');
  
  /**
   * The base implementation of `_.forOwn` without support for iteratee shorthands.
   *
   * @private
   * @param {Object} object The object to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Object} Returns `object`.
   */
  function baseForOwn(object, iteratee) {
    return object && baseFor(object, iteratee, keys);
  }
  
  module.exports = baseForOwn;
  
  },{"./_baseFor":52,"./keys":245}],54:[function(require,module,exports){
  var castPath = require('./_castPath'),
      toKey = require('./_toKey');
  
  /**
   * The base implementation of `_.get` without support for default values.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Array|string} path The path of the property to get.
   * @returns {*} Returns the resolved value.
   */
  function baseGet(object, path) {
    path = castPath(path, object);
  
    var index = 0,
        length = path.length;
  
    while (object != null && index < length) {
      object = object[toKey(path[index++])];
    }
    return (index && index == length) ? object : undefined;
  }
  
  module.exports = baseGet;
  
  },{"./_castPath":85,"./_toKey":193}],55:[function(require,module,exports){
  var arrayPush = require('./_arrayPush'),
      isArray = require('./isArray');
  
  /**
   * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
   * `keysFunc` and `symbolsFunc` to get the enumerable property names and
   * symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Function} keysFunc The function to get the keys of `object`.
   * @param {Function} symbolsFunc The function to get the symbols of `object`.
   * @returns {Array} Returns the array of property names and symbols.
   */
  function baseGetAllKeys(object, keysFunc, symbolsFunc) {
    var result = keysFunc(object);
    return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
  }
  
  module.exports = baseGetAllKeys;
  
  },{"./_arrayPush":39,"./isArray":232}],56:[function(require,module,exports){
  var Symbol = require('./_Symbol'),
      getRawTag = require('./_getRawTag'),
      objectToString = require('./_objectToString');
  
  /** `Object#toString` result references. */
  var nullTag = '[object Null]',
      undefinedTag = '[object Undefined]';
  
  /** Built-in value references. */
  var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
  
  /**
   * The base implementation of `getTag` without fallbacks for buggy environments.
   *
   * @private
   * @param {*} value The value to query.
   * @returns {string} Returns the `toStringTag`.
   */
  function baseGetTag(value) {
    if (value == null) {
      return value === undefined ? undefinedTag : nullTag;
    }
    return (symToStringTag && symToStringTag in Object(value))
      ? getRawTag(value)
      : objectToString(value);
  }
  
  module.exports = baseGetTag;
  
  },{"./_Symbol":28,"./_getRawTag":128,"./_objectToString":172}],57:[function(require,module,exports){
  /**
   * The base implementation of `_.hasIn` without support for deep paths.
   *
   * @private
   * @param {Object} [object] The object to query.
   * @param {Array|string} key The key to check.
   * @returns {boolean} Returns `true` if `key` exists, else `false`.
   */
  function baseHasIn(object, key) {
    return object != null && key in Object(object);
  }
  
  module.exports = baseHasIn;
  
  },{}],58:[function(require,module,exports){
  var baseFindIndex = require('./_baseFindIndex'),
      baseIsNaN = require('./_baseIsNaN'),
      strictIndexOf = require('./_strictIndexOf');
  
  /**
   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @param {number} fromIndex The index to search from.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function baseIndexOf(array, value, fromIndex) {
    return value === value
      ? strictIndexOf(array, value, fromIndex)
      : baseFindIndex(array, baseIsNaN, fromIndex);
  }
  
  module.exports = baseIndexOf;
  
  },{"./_baseFindIndex":50,"./_baseIsNaN":63,"./_strictIndexOf":191}],59:[function(require,module,exports){
  var baseGetTag = require('./_baseGetTag'),
      isObjectLike = require('./isObjectLike');
  
  /** `Object#toString` result references. */
  var argsTag = '[object Arguments]';
  
  /**
   * The base implementation of `_.isArguments`.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an `arguments` object,
   */
  function baseIsArguments(value) {
    return isObjectLike(value) && baseGetTag(value) == argsTag;
  }
  
  module.exports = baseIsArguments;
  
  },{"./_baseGetTag":56,"./isObjectLike":239}],60:[function(require,module,exports){
  var baseIsEqualDeep = require('./_baseIsEqualDeep'),
      isObjectLike = require('./isObjectLike');
  
  /**
   * The base implementation of `_.isEqual` which supports partial comparisons
   * and tracks traversed objects.
   *
   * @private
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @param {boolean} bitmask The bitmask flags.
   *  1 - Unordered comparison
   *  2 - Partial comparison
   * @param {Function} [customizer] The function to customize comparisons.
   * @param {Object} [stack] Tracks traversed `value` and `other` objects.
   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
   */
  function baseIsEqual(value, other, bitmask, customizer, stack) {
    if (value === other) {
      return true;
    }
    if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
      return value !== value && other !== other;
    }
    return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
  }
  
  module.exports = baseIsEqual;
  
  },{"./_baseIsEqualDeep":61,"./isObjectLike":239}],61:[function(require,module,exports){
  var Stack = require('./_Stack'),
      equalArrays = require('./_equalArrays'),
      equalByTag = require('./_equalByTag'),
      equalObjects = require('./_equalObjects'),
      getTag = require('./_getTag'),
      isArray = require('./isArray'),
      isBuffer = require('./isBuffer'),
      isTypedArray = require('./isTypedArray');
  
  /** Used to compose bitmasks for value comparisons. */
  var COMPARE_PARTIAL_FLAG = 1;
  
  /** `Object#toString` result references. */
  var argsTag = '[object Arguments]',
      arrayTag = '[object Array]',
      objectTag = '[object Object]';
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * A specialized version of `baseIsEqual` for arrays and objects which performs
   * deep comparisons and tracks traversed objects enabling objects with circular
   * references to be compared.
   *
   * @private
   * @param {Object} object The object to compare.
   * @param {Object} other The other object to compare.
   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
   * @param {Function} customizer The function to customize comparisons.
   * @param {Function} equalFunc The function to determine equivalents of values.
   * @param {Object} [stack] Tracks traversed `object` and `other` objects.
   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
   */
  function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
    var objIsArr = isArray(object),
        othIsArr = isArray(other),
        objTag = objIsArr ? arrayTag : getTag(object),
        othTag = othIsArr ? arrayTag : getTag(other);
  
    objTag = objTag == argsTag ? objectTag : objTag;
    othTag = othTag == argsTag ? objectTag : othTag;
  
    var objIsObj = objTag == objectTag,
        othIsObj = othTag == objectTag,
        isSameTag = objTag == othTag;
  
    if (isSameTag && isBuffer(object)) {
      if (!isBuffer(other)) {
        return false;
      }
      objIsArr = true;
      objIsObj = false;
    }
    if (isSameTag && !objIsObj) {
      stack || (stack = new Stack);
      return (objIsArr || isTypedArray(object))
        ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
        : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
    }
    if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
      var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
          othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
  
      if (objIsWrapped || othIsWrapped) {
        var objUnwrapped = objIsWrapped ? object.value() : object,
            othUnwrapped = othIsWrapped ? other.value() : other;
  
        stack || (stack = new Stack);
        return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
      }
    }
    if (!isSameTag) {
      return false;
    }
    stack || (stack = new Stack);
    return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
  }
  
  module.exports = baseIsEqualDeep;
  
  },{"./_Stack":27,"./_equalArrays":114,"./_equalByTag":115,"./_equalObjects":116,"./_getTag":131,"./isArray":232,"./isBuffer":234,"./isTypedArray":242}],62:[function(require,module,exports){
  var Stack = require('./_Stack'),
      baseIsEqual = require('./_baseIsEqual');
  
  /** Used to compose bitmasks for value comparisons. */
  var COMPARE_PARTIAL_FLAG = 1,
      COMPARE_UNORDERED_FLAG = 2;
  
  /**
   * The base implementation of `_.isMatch` without support for iteratee shorthands.
   *
   * @private
   * @param {Object} object The object to inspect.
   * @param {Object} source The object of property values to match.
   * @param {Array} matchData The property names, values, and compare flags to match.
   * @param {Function} [customizer] The function to customize comparisons.
   * @returns {boolean} Returns `true` if `object` is a match, else `false`.
   */
  function baseIsMatch(object, source, matchData, customizer) {
    var index = matchData.length,
        length = index,
        noCustomizer = !customizer;
  
    if (object == null) {
      return !length;
    }
    object = Object(object);
    while (index--) {
      var data = matchData[index];
      if ((noCustomizer && data[2])
            ? data[1] !== object[data[0]]
            : !(data[0] in object)
          ) {
        return false;
      }
    }
    while (++index < length) {
      data = matchData[index];
      var key = data[0],
          objValue = object[key],
          srcValue = data[1];
  
      if (noCustomizer && data[2]) {
        if (objValue === undefined && !(key in object)) {
          return false;
        }
      } else {
        var stack = new Stack;
        if (customizer) {
          var result = customizer(objValue, srcValue, key, object, source, stack);
        }
        if (!(result === undefined
              ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
              : result
            )) {
          return false;
        }
      }
    }
    return true;
  }
  
  module.exports = baseIsMatch;
  
  },{"./_Stack":27,"./_baseIsEqual":60}],63:[function(require,module,exports){
  /**
   * The base implementation of `_.isNaN` without support for number objects.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
   */
  function baseIsNaN(value) {
    return value !== value;
  }
  
  module.exports = baseIsNaN;
  
  },{}],64:[function(require,module,exports){
  var isFunction = require('./isFunction'),
      isMasked = require('./_isMasked'),
      isObject = require('./isObject'),
      toSource = require('./_toSource');
  
  /**
   * Used to match `RegExp`
   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
   */
  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
  
  /** Used to detect host constructors (Safari). */
  var reIsHostCtor = /^\[object .+?Constructor\]$/;
  
  /** Used for built-in method references. */
  var funcProto = Function.prototype,
      objectProto = Object.prototype;
  
  /** Used to resolve the decompiled source of functions. */
  var funcToString = funcProto.toString;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /** Used to detect if a method is native. */
  var reIsNative = RegExp('^' +
    funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
    .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
  );
  
  /**
   * The base implementation of `_.isNative` without bad shim checks.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a native function,
   *  else `false`.
   */
  function baseIsNative(value) {
    if (!isObject(value) || isMasked(value)) {
      return false;
    }
    var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
    return pattern.test(toSource(value));
  }
  
  module.exports = baseIsNative;
  
  },{"./_isMasked":150,"./_toSource":194,"./isFunction":235,"./isObject":238}],65:[function(require,module,exports){
  var baseGetTag = require('./_baseGetTag'),
      isLength = require('./isLength'),
      isObjectLike = require('./isObjectLike');
  
  /** `Object#toString` result references. */
  var argsTag = '[object Arguments]',
      arrayTag = '[object Array]',
      boolTag = '[object Boolean]',
      dateTag = '[object Date]',
      errorTag = '[object Error]',
      funcTag = '[object Function]',
      mapTag = '[object Map]',
      numberTag = '[object Number]',
      objectTag = '[object Object]',
      regexpTag = '[object RegExp]',
      setTag = '[object Set]',
      stringTag = '[object String]',
      weakMapTag = '[object WeakMap]';
  
  var arrayBufferTag = '[object ArrayBuffer]',
      dataViewTag = '[object DataView]',
      float32Tag = '[object Float32Array]',
      float64Tag = '[object Float64Array]',
      int8Tag = '[object Int8Array]',
      int16Tag = '[object Int16Array]',
      int32Tag = '[object Int32Array]',
      uint8Tag = '[object Uint8Array]',
      uint8ClampedTag = '[object Uint8ClampedArray]',
      uint16Tag = '[object Uint16Array]',
      uint32Tag = '[object Uint32Array]';
  
  /** Used to identify `toStringTag` values of typed arrays. */
  var typedArrayTags = {};
  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
  typedArrayTags[uint32Tag] = true;
  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
  typedArrayTags[errorTag] = typedArrayTags[funcTag] =
  typedArrayTags[mapTag] = typedArrayTags[numberTag] =
  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
  typedArrayTags[setTag] = typedArrayTags[stringTag] =
  typedArrayTags[weakMapTag] = false;
  
  /**
   * The base implementation of `_.isTypedArray` without Node.js optimizations.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
   */
  function baseIsTypedArray(value) {
    return isObjectLike(value) &&
      isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
  }
  
  module.exports = baseIsTypedArray;
  
  },{"./_baseGetTag":56,"./isLength":236,"./isObjectLike":239}],66:[function(require,module,exports){
  var baseMatches = require('./_baseMatches'),
      baseMatchesProperty = require('./_baseMatchesProperty'),
      identity = require('./identity'),
      isArray = require('./isArray'),
      property = require('./property');
  
  /**
   * The base implementation of `_.iteratee`.
   *
   * @private
   * @param {*} [value=_.identity] The value to convert to an iteratee.
   * @returns {Function} Returns the iteratee.
   */
  function baseIteratee(value) {
    // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
    // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
    if (typeof value == 'function') {
      return value;
    }
    if (value == null) {
      return identity;
    }
    if (typeof value == 'object') {
      return isArray(value)
        ? baseMatchesProperty(value[0], value[1])
        : baseMatches(value);
    }
    return property(value);
  }
  
  module.exports = baseIteratee;
  
  },{"./_baseMatches":70,"./_baseMatchesProperty":71,"./identity":230,"./isArray":232,"./property":252}],67:[function(require,module,exports){
  var isPrototype = require('./_isPrototype'),
      nativeKeys = require('./_nativeKeys');
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   */
  function baseKeys(object) {
    if (!isPrototype(object)) {
      return nativeKeys(object);
    }
    var result = [];
    for (var key in Object(object)) {
      if (hasOwnProperty.call(object, key) && key != 'constructor') {
        result.push(key);
      }
    }
    return result;
  }
  
  module.exports = baseKeys;
  
  },{"./_isPrototype":151,"./_nativeKeys":169}],68:[function(require,module,exports){
  var isObject = require('./isObject'),
      isPrototype = require('./_isPrototype'),
      nativeKeysIn = require('./_nativeKeysIn');
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   */
  function baseKeysIn(object) {
    if (!isObject(object)) {
      return nativeKeysIn(object);
    }
    var isProto = isPrototype(object),
        result = [];
  
    for (var key in object) {
      if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
        result.push(key);
      }
    }
    return result;
  }
  
  module.exports = baseKeysIn;
  
  },{"./_isPrototype":151,"./_nativeKeysIn":170,"./isObject":238}],69:[function(require,module,exports){
  /**
   * The function whose prototype chain sequence wrappers inherit from.
   *
   * @private
   */
  function baseLodash() {
    // No operation performed.
  }
  
  module.exports = baseLodash;
  
  },{}],70:[function(require,module,exports){
  var baseIsMatch = require('./_baseIsMatch'),
      getMatchData = require('./_getMatchData'),
      matchesStrictComparable = require('./_matchesStrictComparable');
  
  /**
   * The base implementation of `_.matches` which doesn't clone `source`.
   *
   * @private
   * @param {Object} source The object of property values to match.
   * @returns {Function} Returns the new spec function.
   */
  function baseMatches(source) {
    var matchData = getMatchData(source);
    if (matchData.length == 1 && matchData[0][2]) {
      return matchesStrictComparable(matchData[0][0], matchData[0][1]);
    }
    return function(object) {
      return object === source || baseIsMatch(object, source, matchData);
    };
  }
  
  module.exports = baseMatches;
  
  },{"./_baseIsMatch":62,"./_getMatchData":125,"./_matchesStrictComparable":164}],71:[function(require,module,exports){
  var baseIsEqual = require('./_baseIsEqual'),
      get = require('./get'),
      hasIn = require('./hasIn'),
      isKey = require('./_isKey'),
      isStrictComparable = require('./_isStrictComparable'),
      matchesStrictComparable = require('./_matchesStrictComparable'),
      toKey = require('./_toKey');
  
  /** Used to compose bitmasks for value comparisons. */
  var COMPARE_PARTIAL_FLAG = 1,
      COMPARE_UNORDERED_FLAG = 2;
  
  /**
   * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
   *
   * @private
   * @param {string} path The path of the property to get.
   * @param {*} srcValue The value to match.
   * @returns {Function} Returns the new spec function.
   */
  function baseMatchesProperty(path, srcValue) {
    if (isKey(path) && isStrictComparable(srcValue)) {
      return matchesStrictComparable(toKey(path), srcValue);
    }
    return function(object) {
      var objValue = get(object, path);
      return (objValue === undefined && objValue === srcValue)
        ? hasIn(object, path)
        : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
    };
  }
  
  module.exports = baseMatchesProperty;
  
  },{"./_baseIsEqual":60,"./_isKey":147,"./_isStrictComparable":152,"./_matchesStrictComparable":164,"./_toKey":193,"./get":228,"./hasIn":229}],72:[function(require,module,exports){
  var basePickBy = require('./_basePickBy'),
      hasIn = require('./hasIn');
  
  /**
   * The base implementation of `_.pick` without support for individual
   * property identifiers.
   *
   * @private
   * @param {Object} object The source object.
   * @param {string[]} paths The property paths to pick.
   * @returns {Object} Returns the new object.
   */
  function basePick(object, paths) {
    return basePickBy(object, paths, function(value, path) {
      return hasIn(object, path);
    });
  }
  
  module.exports = basePick;
  
  },{"./_basePickBy":73,"./hasIn":229}],73:[function(require,module,exports){
  var baseGet = require('./_baseGet'),
      baseSet = require('./_baseSet'),
      castPath = require('./_castPath');
  
  /**
   * The base implementation of  `_.pickBy` without support for iteratee shorthands.
   *
   * @private
   * @param {Object} object The source object.
   * @param {string[]} paths The property paths to pick.
   * @param {Function} predicate The function invoked per property.
   * @returns {Object} Returns the new object.
   */
  function basePickBy(object, paths, predicate) {
    var index = -1,
        length = paths.length,
        result = {};
  
    while (++index < length) {
      var path = paths[index],
          value = baseGet(object, path);
  
      if (predicate(value, path)) {
        baseSet(result, castPath(path, object), value);
      }
    }
    return result;
  }
  
  module.exports = basePickBy;
  
  },{"./_baseGet":54,"./_baseSet":77,"./_castPath":85}],74:[function(require,module,exports){
  /**
   * The base implementation of `_.property` without support for deep paths.
   *
   * @private
   * @param {string} key The key of the property to get.
   * @returns {Function} Returns the new accessor function.
   */
  function baseProperty(key) {
    return function(object) {
      return object == null ? undefined : object[key];
    };
  }
  
  module.exports = baseProperty;
  
  },{}],75:[function(require,module,exports){
  var baseGet = require('./_baseGet');
  
  /**
   * A specialized version of `baseProperty` which supports deep paths.
   *
   * @private
   * @param {Array|string} path The path of the property to get.
   * @returns {Function} Returns the new accessor function.
   */
  function basePropertyDeep(path) {
    return function(object) {
      return baseGet(object, path);
    };
  }
  
  module.exports = basePropertyDeep;
  
  },{"./_baseGet":54}],76:[function(require,module,exports){
  var identity = require('./identity'),
      overRest = require('./_overRest'),
      setToString = require('./_setToString');
  
  /**
   * The base implementation of `_.rest` which doesn't validate or coerce arguments.
   *
   * @private
   * @param {Function} func The function to apply a rest parameter to.
   * @param {number} [start=func.length-1] The start position of the rest parameter.
   * @returns {Function} Returns the new function.
   */
  function baseRest(func, start) {
    return setToString(overRest(func, start, identity), func + '');
  }
  
  module.exports = baseRest;
  
  },{"./_overRest":174,"./_setToString":183,"./identity":230}],77:[function(require,module,exports){
  var assignValue = require('./_assignValue'),
      castPath = require('./_castPath'),
      isIndex = require('./_isIndex'),
      isObject = require('./isObject'),
      toKey = require('./_toKey');
  
  /**
   * The base implementation of `_.set`.
   *
   * @private
   * @param {Object} object The object to modify.
   * @param {Array|string} path The path of the property to set.
   * @param {*} value The value to set.
   * @param {Function} [customizer] The function to customize path creation.
   * @returns {Object} Returns `object`.
   */
  function baseSet(object, path, value, customizer) {
    if (!isObject(object)) {
      return object;
    }
    path = castPath(path, object);
  
    var index = -1,
        length = path.length,
        lastIndex = length - 1,
        nested = object;
  
    while (nested != null && ++index < length) {
      var key = toKey(path[index]),
          newValue = value;
  
      if (index != lastIndex) {
        var objValue = nested[key];
        newValue = customizer ? customizer(objValue, key, nested) : undefined;
        if (newValue === undefined) {
          newValue = isObject(objValue)
            ? objValue
            : (isIndex(path[index + 1]) ? [] : {});
        }
      }
      assignValue(nested, key, newValue);
      nested = nested[key];
    }
    return object;
  }
  
  module.exports = baseSet;
  
  },{"./_assignValue":42,"./_castPath":85,"./_isIndex":145,"./_toKey":193,"./isObject":238}],78:[function(require,module,exports){
  var identity = require('./identity'),
      metaMap = require('./_metaMap');
  
  /**
   * The base implementation of `setData` without support for hot loop shorting.
   *
   * @private
   * @param {Function} func The function to associate metadata with.
   * @param {*} data The metadata.
   * @returns {Function} Returns `func`.
   */
  var baseSetData = !metaMap ? identity : function(func, data) {
    metaMap.set(func, data);
    return func;
  };
  
  module.exports = baseSetData;
  
  },{"./_metaMap":167,"./identity":230}],79:[function(require,module,exports){
  var constant = require('./constant'),
      defineProperty = require('./_defineProperty'),
      identity = require('./identity');
  
  /**
   * The base implementation of `setToString` without support for hot loop shorting.
   *
   * @private
   * @param {Function} func The function to modify.
   * @param {Function} string The `toString` result.
   * @returns {Function} Returns `func`.
   */
  var baseSetToString = !defineProperty ? identity : function(func, string) {
    return defineProperty(func, 'toString', {
      'configurable': true,
      'enumerable': false,
      'value': constant(string),
      'writable': true
    });
  };
  
  module.exports = baseSetToString;
  
  },{"./_defineProperty":113,"./constant":200,"./identity":230}],80:[function(require,module,exports){
  /**
   * The base implementation of `_.times` without support for iteratee shorthands
   * or max array length checks.
   *
   * @private
   * @param {number} n The number of times to invoke `iteratee`.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array} Returns the array of results.
   */
  function baseTimes(n, iteratee) {
    var index = -1,
        result = Array(n);
  
    while (++index < n) {
      result[index] = iteratee(index);
    }
    return result;
  }
  
  module.exports = baseTimes;
  
  },{}],81:[function(require,module,exports){
  var Symbol = require('./_Symbol'),
      arrayMap = require('./_arrayMap'),
      isArray = require('./isArray'),
      isSymbol = require('./isSymbol');
  
  /** Used as references for various `Number` constants. */
  var INFINITY = 1 / 0;
  
  /** Used to convert symbols to primitives and strings. */
  var symbolProto = Symbol ? Symbol.prototype : undefined,
      symbolToString = symbolProto ? symbolProto.toString : undefined;
  
  /**
   * The base implementation of `_.toString` which doesn't convert nullish
   * values to empty strings.
   *
   * @private
   * @param {*} value The value to process.
   * @returns {string} Returns the string.
   */
  function baseToString(value) {
    // Exit early for strings to avoid a performance hit in some environments.
    if (typeof value == 'string') {
      return value;
    }
    if (isArray(value)) {
      // Recursively convert values (susceptible to call stack limits).
      return arrayMap(value, baseToString) + '';
    }
    if (isSymbol(value)) {
      return symbolToString ? symbolToString.call(value) : '';
    }
    var result = (value + '');
    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
  }
  
  module.exports = baseToString;
  
  },{"./_Symbol":28,"./_arrayMap":38,"./isArray":232,"./isSymbol":241}],82:[function(require,module,exports){
  /**
   * The base implementation of `_.unary` without support for storing metadata.
   *
   * @private
   * @param {Function} func The function to cap arguments for.
   * @returns {Function} Returns the new capped function.
   */
  function baseUnary(func) {
    return function(value) {
      return func(value);
    };
  }
  
  module.exports = baseUnary;
  
  },{}],83:[function(require,module,exports){
  /**
   * Checks if a `cache` value for `key` exists.
   *
   * @private
   * @param {Object} cache The cache to query.
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function cacheHas(cache, key) {
    return cache.has(key);
  }
  
  module.exports = cacheHas;
  
  },{}],84:[function(require,module,exports){
  var identity = require('./identity');
  
  /**
   * Casts `value` to `identity` if it's not a function.
   *
   * @private
   * @param {*} value The value to inspect.
   * @returns {Function} Returns cast function.
   */
  function castFunction(value) {
    return typeof value == 'function' ? value : identity;
  }
  
  module.exports = castFunction;
  
  },{"./identity":230}],85:[function(require,module,exports){
  var isArray = require('./isArray'),
      isKey = require('./_isKey'),
      stringToPath = require('./_stringToPath'),
      toString = require('./toString');
  
  /**
   * Casts `value` to a path array if it's not one.
   *
   * @private
   * @param {*} value The value to inspect.
   * @param {Object} [object] The object to query keys on.
   * @returns {Array} Returns the cast property path array.
   */
  function castPath(value, object) {
    if (isArray(value)) {
      return value;
    }
    return isKey(value, object) ? [value] : stringToPath(toString(value));
  }
  
  module.exports = castPath;
  
  },{"./_isKey":147,"./_stringToPath":192,"./isArray":232,"./toString":260}],86:[function(require,module,exports){
  var Uint8Array = require('./_Uint8Array');
  
  /**
   * Creates a clone of `arrayBuffer`.
   *
   * @private
   * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
   * @returns {ArrayBuffer} Returns the cloned array buffer.
   */
  function cloneArrayBuffer(arrayBuffer) {
    var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
    new Uint8Array(result).set(new Uint8Array(arrayBuffer));
    return result;
  }
  
  module.exports = cloneArrayBuffer;
  
  },{"./_Uint8Array":29}],87:[function(require,module,exports){
  var root = require('./_root');
  
  /** Detect free variable `exports`. */
  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
  
  /** Detect free variable `module`. */
  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
  
  /** Detect the popular CommonJS extension `module.exports`. */
  var moduleExports = freeModule && freeModule.exports === freeExports;
  
  /** Built-in value references. */
  var Buffer = moduleExports ? root.Buffer : undefined,
      allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;
  
  /**
   * Creates a clone of  `buffer`.
   *
   * @private
   * @param {Buffer} buffer The buffer to clone.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Buffer} Returns the cloned buffer.
   */
  function cloneBuffer(buffer, isDeep) {
    if (isDeep) {
      return buffer.slice();
    }
    var length = buffer.length,
        result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
  
    buffer.copy(result);
    return result;
  }
  
  module.exports = cloneBuffer;
  
  },{"./_root":178}],88:[function(require,module,exports){
  var cloneArrayBuffer = require('./_cloneArrayBuffer');
  
  /**
   * Creates a clone of `dataView`.
   *
   * @private
   * @param {Object} dataView The data view to clone.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Object} Returns the cloned data view.
   */
  function cloneDataView(dataView, isDeep) {
    var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
    return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
  }
  
  module.exports = cloneDataView;
  
  },{"./_cloneArrayBuffer":86}],89:[function(require,module,exports){
  var addMapEntry = require('./_addMapEntry'),
      arrayReduce = require('./_arrayReduce'),
      mapToArray = require('./_mapToArray');
  
  /** Used to compose bitmasks for cloning. */
  var CLONE_DEEP_FLAG = 1;
  
  /**
   * Creates a clone of `map`.
   *
   * @private
   * @param {Object} map The map to clone.
   * @param {Function} cloneFunc The function to clone values.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Object} Returns the cloned map.
   */
  function cloneMap(map, isDeep, cloneFunc) {
    var array = isDeep ? cloneFunc(mapToArray(map), CLONE_DEEP_FLAG) : mapToArray(map);
    return arrayReduce(array, addMapEntry, new map.constructor);
  }
  
  module.exports = cloneMap;
  
  },{"./_addMapEntry":31,"./_arrayReduce":40,"./_mapToArray":163}],90:[function(require,module,exports){
  /** Used to match `RegExp` flags from their coerced string values. */
  var reFlags = /\w*$/;
  
  /**
   * Creates a clone of `regexp`.
   *
   * @private
   * @param {Object} regexp The regexp to clone.
   * @returns {Object} Returns the cloned regexp.
   */
  function cloneRegExp(regexp) {
    var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
    result.lastIndex = regexp.lastIndex;
    return result;
  }
  
  module.exports = cloneRegExp;
  
  },{}],91:[function(require,module,exports){
  var addSetEntry = require('./_addSetEntry'),
      arrayReduce = require('./_arrayReduce'),
      setToArray = require('./_setToArray');
  
  /** Used to compose bitmasks for cloning. */
  var CLONE_DEEP_FLAG = 1;
  
  /**
   * Creates a clone of `set`.
   *
   * @private
   * @param {Object} set The set to clone.
   * @param {Function} cloneFunc The function to clone values.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Object} Returns the cloned set.
   */
  function cloneSet(set, isDeep, cloneFunc) {
    var array = isDeep ? cloneFunc(setToArray(set), CLONE_DEEP_FLAG) : setToArray(set);
    return arrayReduce(array, addSetEntry, new set.constructor);
  }
  
  module.exports = cloneSet;
  
  },{"./_addSetEntry":32,"./_arrayReduce":40,"./_setToArray":182}],92:[function(require,module,exports){
  var Symbol = require('./_Symbol');
  
  /** Used to convert symbols to primitives and strings. */
  var symbolProto = Symbol ? Symbol.prototype : undefined,
      symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
  
  /**
   * Creates a clone of the `symbol` object.
   *
   * @private
   * @param {Object} symbol The symbol object to clone.
   * @returns {Object} Returns the cloned symbol object.
   */
  function cloneSymbol(symbol) {
    return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
  }
  
  module.exports = cloneSymbol;
  
  },{"./_Symbol":28}],93:[function(require,module,exports){
  var cloneArrayBuffer = require('./_cloneArrayBuffer');
  
  /**
   * Creates a clone of `typedArray`.
   *
   * @private
   * @param {Object} typedArray The typed array to clone.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Object} Returns the cloned typed array.
   */
  function cloneTypedArray(typedArray, isDeep) {
    var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
    return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
  }
  
  module.exports = cloneTypedArray;
  
  },{"./_cloneArrayBuffer":86}],94:[function(require,module,exports){
  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeMax = Math.max;
  
  /**
   * Creates an array that is the composition of partially applied arguments,
   * placeholders, and provided arguments into a single array of arguments.
   *
   * @private
   * @param {Array} args The provided arguments.
   * @param {Array} partials The arguments to prepend to those provided.
   * @param {Array} holders The `partials` placeholder indexes.
   * @params {boolean} [isCurried] Specify composing for a curried function.
   * @returns {Array} Returns the new array of composed arguments.
   */
  function composeArgs(args, partials, holders, isCurried) {
    var argsIndex = -1,
        argsLength = args.length,
        holdersLength = holders.length,
        leftIndex = -1,
        leftLength = partials.length,
        rangeLength = nativeMax(argsLength - holdersLength, 0),
        result = Array(leftLength + rangeLength),
        isUncurried = !isCurried;
  
    while (++leftIndex < leftLength) {
      result[leftIndex] = partials[leftIndex];
    }
    while (++argsIndex < holdersLength) {
      if (isUncurried || argsIndex < argsLength) {
        result[holders[argsIndex]] = args[argsIndex];
      }
    }
    while (rangeLength--) {
      result[leftIndex++] = args[argsIndex++];
    }
    return result;
  }
  
  module.exports = composeArgs;
  
  },{}],95:[function(require,module,exports){
  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeMax = Math.max;
  
  /**
   * This function is like `composeArgs` except that the arguments composition
   * is tailored for `_.partialRight`.
   *
   * @private
   * @param {Array} args The provided arguments.
   * @param {Array} partials The arguments to append to those provided.
   * @param {Array} holders The `partials` placeholder indexes.
   * @params {boolean} [isCurried] Specify composing for a curried function.
   * @returns {Array} Returns the new array of composed arguments.
   */
  function composeArgsRight(args, partials, holders, isCurried) {
    var argsIndex = -1,
        argsLength = args.length,
        holdersIndex = -1,
        holdersLength = holders.length,
        rightIndex = -1,
        rightLength = partials.length,
        rangeLength = nativeMax(argsLength - holdersLength, 0),
        result = Array(rangeLength + rightLength),
        isUncurried = !isCurried;
  
    while (++argsIndex < rangeLength) {
      result[argsIndex] = args[argsIndex];
    }
    var offset = argsIndex;
    while (++rightIndex < rightLength) {
      result[offset + rightIndex] = partials[rightIndex];
    }
    while (++holdersIndex < holdersLength) {
      if (isUncurried || argsIndex < argsLength) {
        result[offset + holders[holdersIndex]] = args[argsIndex++];
      }
    }
    return result;
  }
  
  module.exports = composeArgsRight;
  
  },{}],96:[function(require,module,exports){
  /**
   * Copies the values of `source` to `array`.
   *
   * @private
   * @param {Array} source The array to copy values from.
   * @param {Array} [array=[]] The array to copy values to.
   * @returns {Array} Returns `array`.
   */
  function copyArray(source, array) {
    var index = -1,
        length = source.length;
  
    array || (array = Array(length));
    while (++index < length) {
      array[index] = source[index];
    }
    return array;
  }
  
  module.exports = copyArray;
  
  },{}],97:[function(require,module,exports){
  var assignValue = require('./_assignValue'),
      baseAssignValue = require('./_baseAssignValue');
  
  /**
   * Copies properties of `source` to `object`.
   *
   * @private
   * @param {Object} source The object to copy properties from.
   * @param {Array} props The property identifiers to copy.
   * @param {Object} [object={}] The object to copy properties to.
   * @param {Function} [customizer] The function to customize copied values.
   * @returns {Object} Returns `object`.
   */
  function copyObject(source, props, object, customizer) {
    var isNew = !object;
    object || (object = {});
  
    var index = -1,
        length = props.length;
  
    while (++index < length) {
      var key = props[index];
  
      var newValue = customizer
        ? customizer(object[key], source[key], key, object, source)
        : undefined;
  
      if (newValue === undefined) {
        newValue = source[key];
      }
      if (isNew) {
        baseAssignValue(object, key, newValue);
      } else {
        assignValue(object, key, newValue);
      }
    }
    return object;
  }
  
  module.exports = copyObject;
  
  },{"./_assignValue":42,"./_baseAssignValue":46}],98:[function(require,module,exports){
  var copyObject = require('./_copyObject'),
      getSymbols = require('./_getSymbols');
  
  /**
   * Copies own symbols of `source` to `object`.
   *
   * @private
   * @param {Object} source The object to copy symbols from.
   * @param {Object} [object={}] The object to copy symbols to.
   * @returns {Object} Returns `object`.
   */
  function copySymbols(source, object) {
    return copyObject(source, getSymbols(source), object);
  }
  
  module.exports = copySymbols;
  
  },{"./_copyObject":97,"./_getSymbols":129}],99:[function(require,module,exports){
  var copyObject = require('./_copyObject'),
      getSymbolsIn = require('./_getSymbolsIn');
  
  /**
   * Copies own and inherited symbols of `source` to `object`.
   *
   * @private
   * @param {Object} source The object to copy symbols from.
   * @param {Object} [object={}] The object to copy symbols to.
   * @returns {Object} Returns `object`.
   */
  function copySymbolsIn(source, object) {
    return copyObject(source, getSymbolsIn(source), object);
  }
  
  module.exports = copySymbolsIn;
  
  },{"./_copyObject":97,"./_getSymbolsIn":130}],100:[function(require,module,exports){
  var root = require('./_root');
  
  /** Used to detect overreaching core-js shims. */
  var coreJsData = root['__core-js_shared__'];
  
  module.exports = coreJsData;
  
  },{"./_root":178}],101:[function(require,module,exports){
  /**
   * Gets the number of `placeholder` occurrences in `array`.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} placeholder The placeholder to search for.
   * @returns {number} Returns the placeholder count.
   */
  function countHolders(array, placeholder) {
    var length = array.length,
        result = 0;
  
    while (length--) {
      if (array[length] === placeholder) {
        ++result;
      }
    }
    return result;
  }
  
  module.exports = countHolders;
  
  },{}],102:[function(require,module,exports){
  var baseRest = require('./_baseRest'),
      isIterateeCall = require('./_isIterateeCall');
  
  /**
   * Creates a function like `_.assign`.
   *
   * @private
   * @param {Function} assigner The function to assign values.
   * @returns {Function} Returns the new assigner function.
   */
  function createAssigner(assigner) {
    return baseRest(function(object, sources) {
      var index = -1,
          length = sources.length,
          customizer = length > 1 ? sources[length - 1] : undefined,
          guard = length > 2 ? sources[2] : undefined;
  
      customizer = (assigner.length > 3 && typeof customizer == 'function')
        ? (length--, customizer)
        : undefined;
  
      if (guard && isIterateeCall(sources[0], sources[1], guard)) {
        customizer = length < 3 ? undefined : customizer;
        length = 1;
      }
      object = Object(object);
      while (++index < length) {
        var source = sources[index];
        if (source) {
          assigner(object, source, index, customizer);
        }
      }
      return object;
    });
  }
  
  module.exports = createAssigner;
  
  },{"./_baseRest":76,"./_isIterateeCall":146}],103:[function(require,module,exports){
  var isArrayLike = require('./isArrayLike');
  
  /**
   * Creates a `baseEach` or `baseEachRight` function.
   *
   * @private
   * @param {Function} eachFunc The function to iterate over a collection.
   * @param {boolean} [fromRight] Specify iterating from right to left.
   * @returns {Function} Returns the new base function.
   */
  function createBaseEach(eachFunc, fromRight) {
    return function(collection, iteratee) {
      if (collection == null) {
        return collection;
      }
      if (!isArrayLike(collection)) {
        return eachFunc(collection, iteratee);
      }
      var length = collection.length,
          index = fromRight ? length : -1,
          iterable = Object(collection);
  
      while ((fromRight ? index-- : ++index < length)) {
        if (iteratee(iterable[index], index, iterable) === false) {
          break;
        }
      }
      return collection;
    };
  }
  
  module.exports = createBaseEach;
  
  },{"./isArrayLike":233}],104:[function(require,module,exports){
  /**
   * Creates a base function for methods like `_.forIn` and `_.forOwn`.
   *
   * @private
   * @param {boolean} [fromRight] Specify iterating from right to left.
   * @returns {Function} Returns the new base function.
   */
  function createBaseFor(fromRight) {
    return function(object, iteratee, keysFunc) {
      var index = -1,
          iterable = Object(object),
          props = keysFunc(object),
          length = props.length;
  
      while (length--) {
        var key = props[fromRight ? length : ++index];
        if (iteratee(iterable[key], key, iterable) === false) {
          break;
        }
      }
      return object;
    };
  }
  
  module.exports = createBaseFor;
  
  },{}],105:[function(require,module,exports){
  var createCtor = require('./_createCtor'),
      root = require('./_root');
  
  /** Used to compose bitmasks for function metadata. */
  var WRAP_BIND_FLAG = 1;
  
  /**
   * Creates a function that wraps `func` to invoke it with the optional `this`
   * binding of `thisArg`.
   *
   * @private
   * @param {Function} func The function to wrap.
   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
   * @param {*} [thisArg] The `this` binding of `func`.
   * @returns {Function} Returns the new wrapped function.
   */
  function createBind(func, bitmask, thisArg) {
    var isBind = bitmask & WRAP_BIND_FLAG,
        Ctor = createCtor(func);
  
    function wrapper() {
      var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
      return fn.apply(isBind ? thisArg : this, arguments);
    }
    return wrapper;
  }
  
  module.exports = createBind;
  
  },{"./_createCtor":106,"./_root":178}],106:[function(require,module,exports){
  var baseCreate = require('./_baseCreate'),
      isObject = require('./isObject');
  
  /**
   * Creates a function that produces an instance of `Ctor` regardless of
   * whether it was invoked as part of a `new` expression or by `call` or `apply`.
   *
   * @private
   * @param {Function} Ctor The constructor to wrap.
   * @returns {Function} Returns the new wrapped function.
   */
  function createCtor(Ctor) {
    return function() {
      // Use a `switch` statement to work with class constructors. See
      // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
      // for more details.
      var args = arguments;
      switch (args.length) {
        case 0: return new Ctor;
        case 1: return new Ctor(args[0]);
        case 2: return new Ctor(args[0], args[1]);
        case 3: return new Ctor(args[0], args[1], args[2]);
        case 4: return new Ctor(args[0], args[1], args[2], args[3]);
        case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);
        case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
        case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
      }
      var thisBinding = baseCreate(Ctor.prototype),
          result = Ctor.apply(thisBinding, args);
  
      // Mimic the constructor's `return` behavior.
      // See https://es5.github.io/#x13.2.2 for more details.
      return isObject(result) ? result : thisBinding;
    };
  }
  
  module.exports = createCtor;
  
  },{"./_baseCreate":48,"./isObject":238}],107:[function(require,module,exports){
  var apply = require('./_apply'),
      createCtor = require('./_createCtor'),
      createHybrid = require('./_createHybrid'),
      createRecurry = require('./_createRecurry'),
      getHolder = require('./_getHolder'),
      replaceHolders = require('./_replaceHolders'),
      root = require('./_root');
  
  /**
   * Creates a function that wraps `func` to enable currying.
   *
   * @private
   * @param {Function} func The function to wrap.
   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
   * @param {number} arity The arity of `func`.
   * @returns {Function} Returns the new wrapped function.
   */
  function createCurry(func, bitmask, arity) {
    var Ctor = createCtor(func);
  
    function wrapper() {
      var length = arguments.length,
          args = Array(length),
          index = length,
          placeholder = getHolder(wrapper);
  
      while (index--) {
        args[index] = arguments[index];
      }
      var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)
        ? []
        : replaceHolders(args, placeholder);
  
      length -= holders.length;
      if (length < arity) {
        return createRecurry(
          func, bitmask, createHybrid, wrapper.placeholder, undefined,
          args, holders, undefined, undefined, arity - length);
      }
      var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
      return apply(fn, this, args);
    }
    return wrapper;
  }
  
  module.exports = createCurry;
  
  },{"./_apply":33,"./_createCtor":106,"./_createHybrid":109,"./_createRecurry":111,"./_getHolder":123,"./_replaceHolders":177,"./_root":178}],108:[function(require,module,exports){
  var baseIteratee = require('./_baseIteratee'),
      isArrayLike = require('./isArrayLike'),
      keys = require('./keys');
  
  /**
   * Creates a `_.find` or `_.findLast` function.
   *
   * @private
   * @param {Function} findIndexFunc The function to find the collection index.
   * @returns {Function} Returns the new find function.
   */
  function createFind(findIndexFunc) {
    return function(collection, predicate, fromIndex) {
      var iterable = Object(collection);
      if (!isArrayLike(collection)) {
        var iteratee = baseIteratee(predicate, 3);
        collection = keys(collection);
        predicate = function(key) { return iteratee(iterable[key], key, iterable); };
      }
      var index = findIndexFunc(collection, predicate, fromIndex);
      return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
    };
  }
  
  module.exports = createFind;
  
  },{"./_baseIteratee":66,"./isArrayLike":233,"./keys":245}],109:[function(require,module,exports){
  var composeArgs = require('./_composeArgs'),
      composeArgsRight = require('./_composeArgsRight'),
      countHolders = require('./_countHolders'),
      createCtor = require('./_createCtor'),
      createRecurry = require('./_createRecurry'),
      getHolder = require('./_getHolder'),
      reorder = require('./_reorder'),
      replaceHolders = require('./_replaceHolders'),
      root = require('./_root');
  
  /** Used to compose bitmasks for function metadata. */
  var WRAP_BIND_FLAG = 1,
      WRAP_BIND_KEY_FLAG = 2,
      WRAP_CURRY_FLAG = 8,
      WRAP_CURRY_RIGHT_FLAG = 16,
      WRAP_ARY_FLAG = 128,
      WRAP_FLIP_FLAG = 512;
  
  /**
   * Creates a function that wraps `func` to invoke it with optional `this`
   * binding of `thisArg`, partial application, and currying.
   *
   * @private
   * @param {Function|string} func The function or method name to wrap.
   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
   * @param {*} [thisArg] The `this` binding of `func`.
   * @param {Array} [partials] The arguments to prepend to those provided to
   *  the new function.
   * @param {Array} [holders] The `partials` placeholder indexes.
   * @param {Array} [partialsRight] The arguments to append to those provided
   *  to the new function.
   * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
   * @param {Array} [argPos] The argument positions of the new function.
   * @param {number} [ary] The arity cap of `func`.
   * @param {number} [arity] The arity of `func`.
   * @returns {Function} Returns the new wrapped function.
   */
  function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
    var isAry = bitmask & WRAP_ARY_FLAG,
        isBind = bitmask & WRAP_BIND_FLAG,
        isBindKey = bitmask & WRAP_BIND_KEY_FLAG,
        isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),
        isFlip = bitmask & WRAP_FLIP_FLAG,
        Ctor = isBindKey ? undefined : createCtor(func);
  
    function wrapper() {
      var length = arguments.length,
          args = Array(length),
          index = length;
  
      while (index--) {
        args[index] = arguments[index];
      }
      if (isCurried) {
        var placeholder = getHolder(wrapper),
            holdersCount = countHolders(args, placeholder);
      }
      if (partials) {
        args = composeArgs(args, partials, holders, isCurried);
      }
      if (partialsRight) {
        args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
      }
      length -= holdersCount;
      if (isCurried && length < arity) {
        var newHolders = replaceHolders(args, placeholder);
        return createRecurry(
          func, bitmask, createHybrid, wrapper.placeholder, thisArg,
          args, newHolders, argPos, ary, arity - length
        );
      }
      var thisBinding = isBind ? thisArg : this,
          fn = isBindKey ? thisBinding[func] : func;
  
      length = args.length;
      if (argPos) {
        args = reorder(args, argPos);
      } else if (isFlip && length > 1) {
        args.reverse();
      }
      if (isAry && ary < length) {
        args.length = ary;
      }
      if (this && this !== root && this instanceof wrapper) {
        fn = Ctor || createCtor(fn);
      }
      return fn.apply(thisBinding, args);
    }
    return wrapper;
  }
  
  module.exports = createHybrid;
  
  },{"./_composeArgs":94,"./_composeArgsRight":95,"./_countHolders":101,"./_createCtor":106,"./_createRecurry":111,"./_getHolder":123,"./_reorder":176,"./_replaceHolders":177,"./_root":178}],110:[function(require,module,exports){
  var apply = require('./_apply'),
      createCtor = require('./_createCtor'),
      root = require('./_root');
  
  /** Used to compose bitmasks for function metadata. */
  var WRAP_BIND_FLAG = 1;
  
  /**
   * Creates a function that wraps `func` to invoke it with the `this` binding
   * of `thisArg` and `partials` prepended to the arguments it receives.
   *
   * @private
   * @param {Function} func The function to wrap.
   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
   * @param {*} thisArg The `this` binding of `func`.
   * @param {Array} partials The arguments to prepend to those provided to
   *  the new function.
   * @returns {Function} Returns the new wrapped function.
   */
  function createPartial(func, bitmask, thisArg, partials) {
    var isBind = bitmask & WRAP_BIND_FLAG,
        Ctor = createCtor(func);
  
    function wrapper() {
      var argsIndex = -1,
          argsLength = arguments.length,
          leftIndex = -1,
          leftLength = partials.length,
          args = Array(leftLength + argsLength),
          fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
  
      while (++leftIndex < leftLength) {
        args[leftIndex] = partials[leftIndex];
      }
      while (argsLength--) {
        args[leftIndex++] = arguments[++argsIndex];
      }
      return apply(fn, isBind ? thisArg : this, args);
    }
    return wrapper;
  }
  
  module.exports = createPartial;
  
  },{"./_apply":33,"./_createCtor":106,"./_root":178}],111:[function(require,module,exports){
  var isLaziable = require('./_isLaziable'),
      setData = require('./_setData'),
      setWrapToString = require('./_setWrapToString');
  
  /** Used to compose bitmasks for function metadata. */
  var WRAP_BIND_FLAG = 1,
      WRAP_BIND_KEY_FLAG = 2,
      WRAP_CURRY_BOUND_FLAG = 4,
      WRAP_CURRY_FLAG = 8,
      WRAP_PARTIAL_FLAG = 32,
      WRAP_PARTIAL_RIGHT_FLAG = 64;
  
  /**
   * Creates a function that wraps `func` to continue currying.
   *
   * @private
   * @param {Function} func The function to wrap.
   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
   * @param {Function} wrapFunc The function to create the `func` wrapper.
   * @param {*} placeholder The placeholder value.
   * @param {*} [thisArg] The `this` binding of `func`.
   * @param {Array} [partials] The arguments to prepend to those provided to
   *  the new function.
   * @param {Array} [holders] The `partials` placeholder indexes.
   * @param {Array} [argPos] The argument positions of the new function.
   * @param {number} [ary] The arity cap of `func`.
   * @param {number} [arity] The arity of `func`.
   * @returns {Function} Returns the new wrapped function.
   */
  function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
    var isCurry = bitmask & WRAP_CURRY_FLAG,
        newHolders = isCurry ? holders : undefined,
        newHoldersRight = isCurry ? undefined : holders,
        newPartials = isCurry ? partials : undefined,
        newPartialsRight = isCurry ? undefined : partials;
  
    bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);
    bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
  
    if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
      bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
    }
    var newData = [
      func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
      newHoldersRight, argPos, ary, arity
    ];
  
    var result = wrapFunc.apply(undefined, newData);
    if (isLaziable(func)) {
      setData(result, newData);
    }
    result.placeholder = placeholder;
    return setWrapToString(result, func, bitmask);
  }
  
  module.exports = createRecurry;
  
  },{"./_isLaziable":149,"./_setData":181,"./_setWrapToString":184}],112:[function(require,module,exports){
  var baseSetData = require('./_baseSetData'),
      createBind = require('./_createBind'),
      createCurry = require('./_createCurry'),
      createHybrid = require('./_createHybrid'),
      createPartial = require('./_createPartial'),
      getData = require('./_getData'),
      mergeData = require('./_mergeData'),
      setData = require('./_setData'),
      setWrapToString = require('./_setWrapToString'),
      toInteger = require('./toInteger');
  
  /** Error message constants. */
  var FUNC_ERROR_TEXT = 'Expected a function';
  
  /** Used to compose bitmasks for function metadata. */
  var WRAP_BIND_FLAG = 1,
      WRAP_BIND_KEY_FLAG = 2,
      WRAP_CURRY_FLAG = 8,
      WRAP_CURRY_RIGHT_FLAG = 16,
      WRAP_PARTIAL_FLAG = 32,
      WRAP_PARTIAL_RIGHT_FLAG = 64;
  
  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeMax = Math.max;
  
  /**
   * Creates a function that either curries or invokes `func` with optional
   * `this` binding and partially applied arguments.
   *
   * @private
   * @param {Function|string} func The function or method name to wrap.
   * @param {number} bitmask The bitmask flags.
   *    1 - `_.bind`
   *    2 - `_.bindKey`
   *    4 - `_.curry` or `_.curryRight` of a bound function
   *    8 - `_.curry`
   *   16 - `_.curryRight`
   *   32 - `_.partial`
   *   64 - `_.partialRight`
   *  128 - `_.rearg`
   *  256 - `_.ary`
   *  512 - `_.flip`
   * @param {*} [thisArg] The `this` binding of `func`.
   * @param {Array} [partials] The arguments to be partially applied.
   * @param {Array} [holders] The `partials` placeholder indexes.
   * @param {Array} [argPos] The argument positions of the new function.
   * @param {number} [ary] The arity cap of `func`.
   * @param {number} [arity] The arity of `func`.
   * @returns {Function} Returns the new wrapped function.
   */
  function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
    var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
    if (!isBindKey && typeof func != 'function') {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    var length = partials ? partials.length : 0;
    if (!length) {
      bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
      partials = holders = undefined;
    }
    ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);
    arity = arity === undefined ? arity : toInteger(arity);
    length -= holders ? holders.length : 0;
  
    if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
      var partialsRight = partials,
          holdersRight = holders;
  
      partials = holders = undefined;
    }
    var data = isBindKey ? undefined : getData(func);
  
    var newData = [
      func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,
      argPos, ary, arity
    ];
  
    if (data) {
      mergeData(newData, data);
    }
    func = newData[0];
    bitmask = newData[1];
    thisArg = newData[2];
    partials = newData[3];
    holders = newData[4];
    arity = newData[9] = newData[9] === undefined
      ? (isBindKey ? 0 : func.length)
      : nativeMax(newData[9] - length, 0);
  
    if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
      bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
    }
    if (!bitmask || bitmask == WRAP_BIND_FLAG) {
      var result = createBind(func, bitmask, thisArg);
    } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
      result = createCurry(func, bitmask, arity);
    } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
      result = createPartial(func, bitmask, thisArg, partials);
    } else {
      result = createHybrid.apply(undefined, newData);
    }
    var setter = data ? baseSetData : setData;
    return setWrapToString(setter(result, newData), func, bitmask);
  }
  
  module.exports = createWrap;
  
  },{"./_baseSetData":78,"./_createBind":105,"./_createCurry":107,"./_createHybrid":109,"./_createPartial":110,"./_getData":121,"./_mergeData":166,"./_setData":181,"./_setWrapToString":184,"./toInteger":257}],113:[function(require,module,exports){
  var getNative = require('./_getNative');
  
  var defineProperty = (function() {
    try {
      var func = getNative(Object, 'defineProperty');
      func({}, '', {});
      return func;
    } catch (e) {}
  }());
  
  module.exports = defineProperty;
  
  },{"./_getNative":126}],114:[function(require,module,exports){
  var SetCache = require('./_SetCache'),
      arraySome = require('./_arraySome'),
      cacheHas = require('./_cacheHas');
  
  /** Used to compose bitmasks for value comparisons. */
  var COMPARE_PARTIAL_FLAG = 1,
      COMPARE_UNORDERED_FLAG = 2;
  
  /**
   * A specialized version of `baseIsEqualDeep` for arrays with support for
   * partial deep comparisons.
   *
   * @private
   * @param {Array} array The array to compare.
   * @param {Array} other The other array to compare.
   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
   * @param {Function} customizer The function to customize comparisons.
   * @param {Function} equalFunc The function to determine equivalents of values.
   * @param {Object} stack Tracks traversed `array` and `other` objects.
   * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
   */
  function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
    var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
        arrLength = array.length,
        othLength = other.length;
  
    if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
      return false;
    }
    // Assume cyclic values are equal.
    var stacked = stack.get(array);
    if (stacked && stack.get(other)) {
      return stacked == other;
    }
    var index = -1,
        result = true,
        seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;
  
    stack.set(array, other);
    stack.set(other, array);
  
    // Ignore non-index properties.
    while (++index < arrLength) {
      var arrValue = array[index],
          othValue = other[index];
  
      if (customizer) {
        var compared = isPartial
          ? customizer(othValue, arrValue, index, other, array, stack)
          : customizer(arrValue, othValue, index, array, other, stack);
      }
      if (compared !== undefined) {
        if (compared) {
          continue;
        }
        result = false;
        break;
      }
      // Recursively compare arrays (susceptible to call stack limits).
      if (seen) {
        if (!arraySome(other, function(othValue, othIndex) {
              if (!cacheHas(seen, othIndex) &&
                  (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
                return seen.push(othIndex);
              }
            })) {
          result = false;
          break;
        }
      } else if (!(
            arrValue === othValue ||
              equalFunc(arrValue, othValue, bitmask, customizer, stack)
          )) {
        result = false;
        break;
      }
    }
    stack['delete'](array);
    stack['delete'](other);
    return result;
  }
  
  module.exports = equalArrays;
  
  },{"./_SetCache":26,"./_arraySome":41,"./_cacheHas":83}],115:[function(require,module,exports){
  var Symbol = require('./_Symbol'),
      Uint8Array = require('./_Uint8Array'),
      eq = require('./eq'),
      equalArrays = require('./_equalArrays'),
      mapToArray = require('./_mapToArray'),
      setToArray = require('./_setToArray');
  
  /** Used to compose bitmasks for value comparisons. */
  var COMPARE_PARTIAL_FLAG = 1,
      COMPARE_UNORDERED_FLAG = 2;
  
  /** `Object#toString` result references. */
  var boolTag = '[object Boolean]',
      dateTag = '[object Date]',
      errorTag = '[object Error]',
      mapTag = '[object Map]',
      numberTag = '[object Number]',
      regexpTag = '[object RegExp]',
      setTag = '[object Set]',
      stringTag = '[object String]',
      symbolTag = '[object Symbol]';
  
  var arrayBufferTag = '[object ArrayBuffer]',
      dataViewTag = '[object DataView]';
  
  /** Used to convert symbols to primitives and strings. */
  var symbolProto = Symbol ? Symbol.prototype : undefined,
      symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
  
  /**
   * A specialized version of `baseIsEqualDeep` for comparing objects of
   * the same `toStringTag`.
   *
   * **Note:** This function only supports comparing values with tags of
   * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
   *
   * @private
   * @param {Object} object The object to compare.
   * @param {Object} other The other object to compare.
   * @param {string} tag The `toStringTag` of the objects to compare.
   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
   * @param {Function} customizer The function to customize comparisons.
   * @param {Function} equalFunc The function to determine equivalents of values.
   * @param {Object} stack Tracks traversed `object` and `other` objects.
   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
   */
  function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
    switch (tag) {
      case dataViewTag:
        if ((object.byteLength != other.byteLength) ||
            (object.byteOffset != other.byteOffset)) {
          return false;
        }
        object = object.buffer;
        other = other.buffer;
  
      case arrayBufferTag:
        if ((object.byteLength != other.byteLength) ||
            !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
          return false;
        }
        return true;
  
      case boolTag:
      case dateTag:
      case numberTag:
        // Coerce booleans to `1` or `0` and dates to milliseconds.
        // Invalid dates are coerced to `NaN`.
        return eq(+object, +other);
  
      case errorTag:
        return object.name == other.name && object.message == other.message;
  
      case regexpTag:
      case stringTag:
        // Coerce regexes to strings and treat strings, primitives and objects,
        // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
        // for more details.
        return object == (other + '');
  
      case mapTag:
        var convert = mapToArray;
  
      case setTag:
        var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
        convert || (convert = setToArray);
  
        if (object.size != other.size && !isPartial) {
          return false;
        }
        // Assume cyclic values are equal.
        var stacked = stack.get(object);
        if (stacked) {
          return stacked == other;
        }
        bitmask |= COMPARE_UNORDERED_FLAG;
  
        // Recursively compare objects (susceptible to call stack limits).
        stack.set(object, other);
        var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
        stack['delete'](object);
        return result;
  
      case symbolTag:
        if (symbolValueOf) {
          return symbolValueOf.call(object) == symbolValueOf.call(other);
        }
    }
    return false;
  }
  
  module.exports = equalByTag;
  
  },{"./_Symbol":28,"./_Uint8Array":29,"./_equalArrays":114,"./_mapToArray":163,"./_setToArray":182,"./eq":202}],116:[function(require,module,exports){
  var getAllKeys = require('./_getAllKeys');
  
  /** Used to compose bitmasks for value comparisons. */
  var COMPARE_PARTIAL_FLAG = 1;
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * A specialized version of `baseIsEqualDeep` for objects with support for
   * partial deep comparisons.
   *
   * @private
   * @param {Object} object The object to compare.
   * @param {Object} other The other object to compare.
   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
   * @param {Function} customizer The function to customize comparisons.
   * @param {Function} equalFunc The function to determine equivalents of values.
   * @param {Object} stack Tracks traversed `object` and `other` objects.
   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
   */
  function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
    var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
        objProps = getAllKeys(object),
        objLength = objProps.length,
        othProps = getAllKeys(other),
        othLength = othProps.length;
  
    if (objLength != othLength && !isPartial) {
      return false;
    }
    var index = objLength;
    while (index--) {
      var key = objProps[index];
      if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
        return false;
      }
    }
    // Assume cyclic values are equal.
    var stacked = stack.get(object);
    if (stacked && stack.get(other)) {
      return stacked == other;
    }
    var result = true;
    stack.set(object, other);
    stack.set(other, object);
  
    var skipCtor = isPartial;
    while (++index < objLength) {
      key = objProps[index];
      var objValue = object[key],
          othValue = other[key];
  
      if (customizer) {
        var compared = isPartial
          ? customizer(othValue, objValue, key, other, object, stack)
          : customizer(objValue, othValue, key, object, other, stack);
      }
      // Recursively compare objects (susceptible to call stack limits).
      if (!(compared === undefined
            ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
            : compared
          )) {
        result = false;
        break;
      }
      skipCtor || (skipCtor = key == 'constructor');
    }
    if (result && !skipCtor) {
      var objCtor = object.constructor,
          othCtor = other.constructor;
  
      // Non `Object` object instances with different constructors are not equal.
      if (objCtor != othCtor &&
          ('constructor' in object && 'constructor' in other) &&
          !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
            typeof othCtor == 'function' && othCtor instanceof othCtor)) {
        result = false;
      }
    }
    stack['delete'](object);
    stack['delete'](other);
    return result;
  }
  
  module.exports = equalObjects;
  
  },{"./_getAllKeys":119}],117:[function(require,module,exports){
  var flatten = require('./flatten'),
      overRest = require('./_overRest'),
      setToString = require('./_setToString');
  
  /**
   * A specialized version of `baseRest` which flattens the rest array.
   *
   * @private
   * @param {Function} func The function to apply a rest parameter to.
   * @returns {Function} Returns the new function.
   */
  function flatRest(func) {
    return setToString(overRest(func, undefined, flatten), func + '');
  }
  
  module.exports = flatRest;
  
  },{"./_overRest":174,"./_setToString":183,"./flatten":205}],118:[function(require,module,exports){
  (function (global){
  /** Detect free variable `global` from Node.js. */
  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
  
  module.exports = freeGlobal;
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{}],119:[function(require,module,exports){
  var baseGetAllKeys = require('./_baseGetAllKeys'),
      getSymbols = require('./_getSymbols'),
      keys = require('./keys');
  
  /**
   * Creates an array of own enumerable property names and symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names and symbols.
   */
  function getAllKeys(object) {
    return baseGetAllKeys(object, keys, getSymbols);
  }
  
  module.exports = getAllKeys;
  
  },{"./_baseGetAllKeys":55,"./_getSymbols":129,"./keys":245}],120:[function(require,module,exports){
  var baseGetAllKeys = require('./_baseGetAllKeys'),
      getSymbolsIn = require('./_getSymbolsIn'),
      keysIn = require('./keysIn');
  
  /**
   * Creates an array of own and inherited enumerable property names and
   * symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names and symbols.
   */
  function getAllKeysIn(object) {
    return baseGetAllKeys(object, keysIn, getSymbolsIn);
  }
  
  module.exports = getAllKeysIn;
  
  },{"./_baseGetAllKeys":55,"./_getSymbolsIn":130,"./keysIn":246}],121:[function(require,module,exports){
  var metaMap = require('./_metaMap'),
      noop = require('./noop');
  
  /**
   * Gets metadata for `func`.
   *
   * @private
   * @param {Function} func The function to query.
   * @returns {*} Returns the metadata for `func`.
   */
  var getData = !metaMap ? noop : function(func) {
    return metaMap.get(func);
  };
  
  module.exports = getData;
  
  },{"./_metaMap":167,"./noop":250}],122:[function(require,module,exports){
  var realNames = require('./_realNames');
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * Gets the name of `func`.
   *
   * @private
   * @param {Function} func The function to query.
   * @returns {string} Returns the function name.
   */
  function getFuncName(func) {
    var result = (func.name + ''),
        array = realNames[result],
        length = hasOwnProperty.call(realNames, result) ? array.length : 0;
  
    while (length--) {
      var data = array[length],
          otherFunc = data.func;
      if (otherFunc == null || otherFunc == func) {
        return data.name;
      }
    }
    return result;
  }
  
  module.exports = getFuncName;
  
  },{"./_realNames":175}],123:[function(require,module,exports){
  /**
   * Gets the argument placeholder value for `func`.
   *
   * @private
   * @param {Function} func The function to inspect.
   * @returns {*} Returns the placeholder value.
   */
  function getHolder(func) {
    var object = func;
    return object.placeholder;
  }
  
  module.exports = getHolder;
  
  },{}],124:[function(require,module,exports){
  var isKeyable = require('./_isKeyable');
  
  /**
   * Gets the data for `map`.
   *
   * @private
   * @param {Object} map The map to query.
   * @param {string} key The reference key.
   * @returns {*} Returns the map data.
   */
  function getMapData(map, key) {
    var data = map.__data__;
    return isKeyable(key)
      ? data[typeof key == 'string' ? 'string' : 'hash']
      : data.map;
  }
  
  module.exports = getMapData;
  
  },{"./_isKeyable":148}],125:[function(require,module,exports){
  var isStrictComparable = require('./_isStrictComparable'),
      keys = require('./keys');
  
  /**
   * Gets the property names, values, and compare flags of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the match data of `object`.
   */
  function getMatchData(object) {
    var result = keys(object),
        length = result.length;
  
    while (length--) {
      var key = result[length],
          value = object[key];
  
      result[length] = [key, value, isStrictComparable(value)];
    }
    return result;
  }
  
  module.exports = getMatchData;
  
  },{"./_isStrictComparable":152,"./keys":245}],126:[function(require,module,exports){
  var baseIsNative = require('./_baseIsNative'),
      getValue = require('./_getValue');
  
  /**
   * Gets the native function at `key` of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {string} key The key of the method to get.
   * @returns {*} Returns the function if it's native, else `undefined`.
   */
  function getNative(object, key) {
    var value = getValue(object, key);
    return baseIsNative(value) ? value : undefined;
  }
  
  module.exports = getNative;
  
  },{"./_baseIsNative":64,"./_getValue":132}],127:[function(require,module,exports){
  var overArg = require('./_overArg');
  
  /** Built-in value references. */
  var getPrototype = overArg(Object.getPrototypeOf, Object);
  
  module.exports = getPrototype;
  
  },{"./_overArg":173}],128:[function(require,module,exports){
  var Symbol = require('./_Symbol');
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * Used to resolve the
   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
   * of values.
   */
  var nativeObjectToString = objectProto.toString;
  
  /** Built-in value references. */
  var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
  
  /**
   * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
   *
   * @private
   * @param {*} value The value to query.
   * @returns {string} Returns the raw `toStringTag`.
   */
  function getRawTag(value) {
    var isOwn = hasOwnProperty.call(value, symToStringTag),
        tag = value[symToStringTag];
  
    try {
      value[symToStringTag] = undefined;
      var unmasked = true;
    } catch (e) {}
  
    var result = nativeObjectToString.call(value);
    if (unmasked) {
      if (isOwn) {
        value[symToStringTag] = tag;
      } else {
        delete value[symToStringTag];
      }
    }
    return result;
  }
  
  module.exports = getRawTag;
  
  },{"./_Symbol":28}],129:[function(require,module,exports){
  var arrayFilter = require('./_arrayFilter'),
      stubArray = require('./stubArray');
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Built-in value references. */
  var propertyIsEnumerable = objectProto.propertyIsEnumerable;
  
  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeGetSymbols = Object.getOwnPropertySymbols;
  
  /**
   * Creates an array of the own enumerable symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of symbols.
   */
  var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
    if (object == null) {
      return [];
    }
    object = Object(object);
    return arrayFilter(nativeGetSymbols(object), function(symbol) {
      return propertyIsEnumerable.call(object, symbol);
    });
  };
  
  module.exports = getSymbols;
  
  },{"./_arrayFilter":35,"./stubArray":254}],130:[function(require,module,exports){
  var arrayPush = require('./_arrayPush'),
      getPrototype = require('./_getPrototype'),
      getSymbols = require('./_getSymbols'),
      stubArray = require('./stubArray');
  
  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeGetSymbols = Object.getOwnPropertySymbols;
  
  /**
   * Creates an array of the own and inherited enumerable symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of symbols.
   */
  var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
    var result = [];
    while (object) {
      arrayPush(result, getSymbols(object));
      object = getPrototype(object);
    }
    return result;
  };
  
  module.exports = getSymbolsIn;
  
  },{"./_arrayPush":39,"./_getPrototype":127,"./_getSymbols":129,"./stubArray":254}],131:[function(require,module,exports){
  var DataView = require('./_DataView'),
      Map = require('./_Map'),
      Promise = require('./_Promise'),
      Set = require('./_Set'),
      WeakMap = require('./_WeakMap'),
      baseGetTag = require('./_baseGetTag'),
      toSource = require('./_toSource');
  
  /** `Object#toString` result references. */
  var mapTag = '[object Map]',
      objectTag = '[object Object]',
      promiseTag = '[object Promise]',
      setTag = '[object Set]',
      weakMapTag = '[object WeakMap]';
  
  var dataViewTag = '[object DataView]';
  
  /** Used to detect maps, sets, and weakmaps. */
  var dataViewCtorString = toSource(DataView),
      mapCtorString = toSource(Map),
      promiseCtorString = toSource(Promise),
      setCtorString = toSource(Set),
      weakMapCtorString = toSource(WeakMap);
  
  /**
   * Gets the `toStringTag` of `value`.
   *
   * @private
   * @param {*} value The value to query.
   * @returns {string} Returns the `toStringTag`.
   */
  var getTag = baseGetTag;
  
  // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
  if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
      (Map && getTag(new Map) != mapTag) ||
      (Promise && getTag(Promise.resolve()) != promiseTag) ||
      (Set && getTag(new Set) != setTag) ||
      (WeakMap && getTag(new WeakMap) != weakMapTag)) {
    getTag = function(value) {
      var result = baseGetTag(value),
          Ctor = result == objectTag ? value.constructor : undefined,
          ctorString = Ctor ? toSource(Ctor) : '';
  
      if (ctorString) {
        switch (ctorString) {
          case dataViewCtorString: return dataViewTag;
          case mapCtorString: return mapTag;
          case promiseCtorString: return promiseTag;
          case setCtorString: return setTag;
          case weakMapCtorString: return weakMapTag;
        }
      }
      return result;
    };
  }
  
  module.exports = getTag;
  
  },{"./_DataView":17,"./_Map":22,"./_Promise":24,"./_Set":25,"./_WeakMap":30,"./_baseGetTag":56,"./_toSource":194}],132:[function(require,module,exports){
  /**
   * Gets the value at `key` of `object`.
   *
   * @private
   * @param {Object} [object] The object to query.
   * @param {string} key The key of the property to get.
   * @returns {*} Returns the property value.
   */
  function getValue(object, key) {
    return object == null ? undefined : object[key];
  }
  
  module.exports = getValue;
  
  },{}],133:[function(require,module,exports){
  /** Used to match wrap detail comments. */
  var reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,
      reSplitDetails = /,? & /;
  
  /**
   * Extracts wrapper details from the `source` body comment.
   *
   * @private
   * @param {string} source The source to inspect.
   * @returns {Array} Returns the wrapper details.
   */
  function getWrapDetails(source) {
    var match = source.match(reWrapDetails);
    return match ? match[1].split(reSplitDetails) : [];
  }
  
  module.exports = getWrapDetails;
  
  },{}],134:[function(require,module,exports){
  var castPath = require('./_castPath'),
      isArguments = require('./isArguments'),
      isArray = require('./isArray'),
      isIndex = require('./_isIndex'),
      isLength = require('./isLength'),
      toKey = require('./_toKey');
  
  /**
   * Checks if `path` exists on `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Array|string} path The path to check.
   * @param {Function} hasFunc The function to check properties.
   * @returns {boolean} Returns `true` if `path` exists, else `false`.
   */
  function hasPath(object, path, hasFunc) {
    path = castPath(path, object);
  
    var index = -1,
        length = path.length,
        result = false;
  
    while (++index < length) {
      var key = toKey(path[index]);
      if (!(result = object != null && hasFunc(object, key))) {
        break;
      }
      object = object[key];
    }
    if (result || ++index != length) {
      return result;
    }
    length = object == null ? 0 : object.length;
    return !!length && isLength(length) && isIndex(key, length) &&
      (isArray(object) || isArguments(object));
  }
  
  module.exports = hasPath;
  
  },{"./_castPath":85,"./_isIndex":145,"./_toKey":193,"./isArguments":231,"./isArray":232,"./isLength":236}],135:[function(require,module,exports){
  var nativeCreate = require('./_nativeCreate');
  
  /**
   * Removes all key-value entries from the hash.
   *
   * @private
   * @name clear
   * @memberOf Hash
   */
  function hashClear() {
    this.__data__ = nativeCreate ? nativeCreate(null) : {};
    this.size = 0;
  }
  
  module.exports = hashClear;
  
  },{"./_nativeCreate":168}],136:[function(require,module,exports){
  /**
   * Removes `key` and its value from the hash.
   *
   * @private
   * @name delete
   * @memberOf Hash
   * @param {Object} hash The hash to modify.
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function hashDelete(key) {
    var result = this.has(key) && delete this.__data__[key];
    this.size -= result ? 1 : 0;
    return result;
  }
  
  module.exports = hashDelete;
  
  },{}],137:[function(require,module,exports){
  var nativeCreate = require('./_nativeCreate');
  
  /** Used to stand-in for `undefined` hash values. */
  var HASH_UNDEFINED = '__lodash_hash_undefined__';
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * Gets the hash value for `key`.
   *
   * @private
   * @name get
   * @memberOf Hash
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function hashGet(key) {
    var data = this.__data__;
    if (nativeCreate) {
      var result = data[key];
      return result === HASH_UNDEFINED ? undefined : result;
    }
    return hasOwnProperty.call(data, key) ? data[key] : undefined;
  }
  
  module.exports = hashGet;
  
  },{"./_nativeCreate":168}],138:[function(require,module,exports){
  var nativeCreate = require('./_nativeCreate');
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * Checks if a hash value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf Hash
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function hashHas(key) {
    var data = this.__data__;
    return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
  }
  
  module.exports = hashHas;
  
  },{"./_nativeCreate":168}],139:[function(require,module,exports){
  var nativeCreate = require('./_nativeCreate');
  
  /** Used to stand-in for `undefined` hash values. */
  var HASH_UNDEFINED = '__lodash_hash_undefined__';
  
  /**
   * Sets the hash `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf Hash
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the hash instance.
   */
  function hashSet(key, value) {
    var data = this.__data__;
    this.size += this.has(key) ? 0 : 1;
    data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
    return this;
  }
  
  module.exports = hashSet;
  
  },{"./_nativeCreate":168}],140:[function(require,module,exports){
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * Initializes an array clone.
   *
   * @private
   * @param {Array} array The array to clone.
   * @returns {Array} Returns the initialized clone.
   */
  function initCloneArray(array) {
    var length = array.length,
        result = array.constructor(length);
  
    // Add properties assigned by `RegExp#exec`.
    if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
      result.index = array.index;
      result.input = array.input;
    }
    return result;
  }
  
  module.exports = initCloneArray;
  
  },{}],141:[function(require,module,exports){
  var cloneArrayBuffer = require('./_cloneArrayBuffer'),
      cloneDataView = require('./_cloneDataView'),
      cloneMap = require('./_cloneMap'),
      cloneRegExp = require('./_cloneRegExp'),
      cloneSet = require('./_cloneSet'),
      cloneSymbol = require('./_cloneSymbol'),
      cloneTypedArray = require('./_cloneTypedArray');
  
  /** `Object#toString` result references. */
  var boolTag = '[object Boolean]',
      dateTag = '[object Date]',
      mapTag = '[object Map]',
      numberTag = '[object Number]',
      regexpTag = '[object RegExp]',
      setTag = '[object Set]',
      stringTag = '[object String]',
      symbolTag = '[object Symbol]';
  
  var arrayBufferTag = '[object ArrayBuffer]',
      dataViewTag = '[object DataView]',
      float32Tag = '[object Float32Array]',
      float64Tag = '[object Float64Array]',
      int8Tag = '[object Int8Array]',
      int16Tag = '[object Int16Array]',
      int32Tag = '[object Int32Array]',
      uint8Tag = '[object Uint8Array]',
      uint8ClampedTag = '[object Uint8ClampedArray]',
      uint16Tag = '[object Uint16Array]',
      uint32Tag = '[object Uint32Array]';
  
  /**
   * Initializes an object clone based on its `toStringTag`.
   *
   * **Note:** This function only supports cloning values with tags of
   * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
   *
   * @private
   * @param {Object} object The object to clone.
   * @param {string} tag The `toStringTag` of the object to clone.
   * @param {Function} cloneFunc The function to clone values.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Object} Returns the initialized clone.
   */
  function initCloneByTag(object, tag, cloneFunc, isDeep) {
    var Ctor = object.constructor;
    switch (tag) {
      case arrayBufferTag:
        return cloneArrayBuffer(object);
  
      case boolTag:
      case dateTag:
        return new Ctor(+object);
  
      case dataViewTag:
        return cloneDataView(object, isDeep);
  
      case float32Tag: case float64Tag:
      case int8Tag: case int16Tag: case int32Tag:
      case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
        return cloneTypedArray(object, isDeep);
  
      case mapTag:
        return cloneMap(object, isDeep, cloneFunc);
  
      case numberTag:
      case stringTag:
        return new Ctor(object);
  
      case regexpTag:
        return cloneRegExp(object);
  
      case setTag:
        return cloneSet(object, isDeep, cloneFunc);
  
      case symbolTag:
        return cloneSymbol(object);
    }
  }
  
  module.exports = initCloneByTag;
  
  },{"./_cloneArrayBuffer":86,"./_cloneDataView":88,"./_cloneMap":89,"./_cloneRegExp":90,"./_cloneSet":91,"./_cloneSymbol":92,"./_cloneTypedArray":93}],142:[function(require,module,exports){
  var baseCreate = require('./_baseCreate'),
      getPrototype = require('./_getPrototype'),
      isPrototype = require('./_isPrototype');
  
  /**
   * Initializes an object clone.
   *
   * @private
   * @param {Object} object The object to clone.
   * @returns {Object} Returns the initialized clone.
   */
  function initCloneObject(object) {
    return (typeof object.constructor == 'function' && !isPrototype(object))
      ? baseCreate(getPrototype(object))
      : {};
  }
  
  module.exports = initCloneObject;
  
  },{"./_baseCreate":48,"./_getPrototype":127,"./_isPrototype":151}],143:[function(require,module,exports){
  /** Used to match wrap detail comments. */
  var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/;
  
  /**
   * Inserts wrapper `details` in a comment at the top of the `source` body.
   *
   * @private
   * @param {string} source The source to modify.
   * @returns {Array} details The details to insert.
   * @returns {string} Returns the modified source.
   */
  function insertWrapDetails(source, details) {
    var length = details.length;
    if (!length) {
      return source;
    }
    var lastIndex = length - 1;
    details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];
    details = details.join(length > 2 ? ', ' : ' ');
    return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n');
  }
  
  module.exports = insertWrapDetails;
  
  },{}],144:[function(require,module,exports){
  var Symbol = require('./_Symbol'),
      isArguments = require('./isArguments'),
      isArray = require('./isArray');
  
  /** Built-in value references. */
  var spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;
  
  /**
   * Checks if `value` is a flattenable `arguments` object or array.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
   */
  function isFlattenable(value) {
    return isArray(value) || isArguments(value) ||
      !!(spreadableSymbol && value && value[spreadableSymbol]);
  }
  
  module.exports = isFlattenable;
  
  },{"./_Symbol":28,"./isArguments":231,"./isArray":232}],145:[function(require,module,exports){
  /** Used as references for various `Number` constants. */
  var MAX_SAFE_INTEGER = 9007199254740991;
  
  /** Used to detect unsigned integer values. */
  var reIsUint = /^(?:0|[1-9]\d*)$/;
  
  /**
   * Checks if `value` is a valid array-like index.
   *
   * @private
   * @param {*} value The value to check.
   * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
   * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
   */
  function isIndex(value, length) {
    length = length == null ? MAX_SAFE_INTEGER : length;
    return !!length &&
      (typeof value == 'number' || reIsUint.test(value)) &&
      (value > -1 && value % 1 == 0 && value < length);
  }
  
  module.exports = isIndex;
  
  },{}],146:[function(require,module,exports){
  var eq = require('./eq'),
      isArrayLike = require('./isArrayLike'),
      isIndex = require('./_isIndex'),
      isObject = require('./isObject');
  
  /**
   * Checks if the given arguments are from an iteratee call.
   *
   * @private
   * @param {*} value The potential iteratee value argument.
   * @param {*} index The potential iteratee index or key argument.
   * @param {*} object The potential iteratee object argument.
   * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
   *  else `false`.
   */
  function isIterateeCall(value, index, object) {
    if (!isObject(object)) {
      return false;
    }
    var type = typeof index;
    if (type == 'number'
          ? (isArrayLike(object) && isIndex(index, object.length))
          : (type == 'string' && index in object)
        ) {
      return eq(object[index], value);
    }
    return false;
  }
  
  module.exports = isIterateeCall;
  
  },{"./_isIndex":145,"./eq":202,"./isArrayLike":233,"./isObject":238}],147:[function(require,module,exports){
  var isArray = require('./isArray'),
      isSymbol = require('./isSymbol');
  
  /** Used to match property names within property paths. */
  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
      reIsPlainProp = /^\w*$/;
  
  /**
   * Checks if `value` is a property name and not a property path.
   *
   * @private
   * @param {*} value The value to check.
   * @param {Object} [object] The object to query keys on.
   * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
   */
  function isKey(value, object) {
    if (isArray(value)) {
      return false;
    }
    var type = typeof value;
    if (type == 'number' || type == 'symbol' || type == 'boolean' ||
        value == null || isSymbol(value)) {
      return true;
    }
    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
      (object != null && value in Object(object));
  }
  
  module.exports = isKey;
  
  },{"./isArray":232,"./isSymbol":241}],148:[function(require,module,exports){
  /**
   * Checks if `value` is suitable for use as unique object key.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
   */
  function isKeyable(value) {
    var type = typeof value;
    return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
      ? (value !== '__proto__')
      : (value === null);
  }
  
  module.exports = isKeyable;
  
  },{}],149:[function(require,module,exports){
  var LazyWrapper = require('./_LazyWrapper'),
      getData = require('./_getData'),
      getFuncName = require('./_getFuncName'),
      lodash = require('./wrapperLodash');
  
  /**
   * Checks if `func` has a lazy counterpart.
   *
   * @private
   * @param {Function} func The function to check.
   * @returns {boolean} Returns `true` if `func` has a lazy counterpart,
   *  else `false`.
   */
  function isLaziable(func) {
    var funcName = getFuncName(func),
        other = lodash[funcName];
  
    if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {
      return false;
    }
    if (func === other) {
      return true;
    }
    var data = getData(other);
    return !!data && func === data[0];
  }
  
  module.exports = isLaziable;
  
  },{"./_LazyWrapper":19,"./_getData":121,"./_getFuncName":122,"./wrapperLodash":262}],150:[function(require,module,exports){
  var coreJsData = require('./_coreJsData');
  
  /** Used to detect methods masquerading as native. */
  var maskSrcKey = (function() {
    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
    return uid ? ('Symbol(src)_1.' + uid) : '';
  }());
  
  /**
   * Checks if `func` has its source masked.
   *
   * @private
   * @param {Function} func The function to check.
   * @returns {boolean} Returns `true` if `func` is masked, else `false`.
   */
  function isMasked(func) {
    return !!maskSrcKey && (maskSrcKey in func);
  }
  
  module.exports = isMasked;
  
  },{"./_coreJsData":100}],151:[function(require,module,exports){
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /**
   * Checks if `value` is likely a prototype object.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
   */
  function isPrototype(value) {
    var Ctor = value && value.constructor,
        proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
  
    return value === proto;
  }
  
  module.exports = isPrototype;
  
  },{}],152:[function(require,module,exports){
  var isObject = require('./isObject');
  
  /**
   * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` if suitable for strict
   *  equality comparisons, else `false`.
   */
  function isStrictComparable(value) {
    return value === value && !isObject(value);
  }
  
  module.exports = isStrictComparable;
  
  },{"./isObject":238}],153:[function(require,module,exports){
  /**
   * Removes all key-value entries from the list cache.
   *
   * @private
   * @name clear
   * @memberOf ListCache
   */
  function listCacheClear() {
    this.__data__ = [];
    this.size = 0;
  }
  
  module.exports = listCacheClear;
  
  },{}],154:[function(require,module,exports){
  var assocIndexOf = require('./_assocIndexOf');
  
  /** Used for built-in method references. */
  var arrayProto = Array.prototype;
  
  /** Built-in value references. */
  var splice = arrayProto.splice;
  
  /**
   * Removes `key` and its value from the list cache.
   *
   * @private
   * @name delete
   * @memberOf ListCache
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function listCacheDelete(key) {
    var data = this.__data__,
        index = assocIndexOf(data, key);
  
    if (index < 0) {
      return false;
    }
    var lastIndex = data.length - 1;
    if (index == lastIndex) {
      data.pop();
    } else {
      splice.call(data, index, 1);
    }
    --this.size;
    return true;
  }
  
  module.exports = listCacheDelete;
  
  },{"./_assocIndexOf":43}],155:[function(require,module,exports){
  var assocIndexOf = require('./_assocIndexOf');
  
  /**
   * Gets the list cache value for `key`.
   *
   * @private
   * @name get
   * @memberOf ListCache
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function listCacheGet(key) {
    var data = this.__data__,
        index = assocIndexOf(data, key);
  
    return index < 0 ? undefined : data[index][1];
  }
  
  module.exports = listCacheGet;
  
  },{"./_assocIndexOf":43}],156:[function(require,module,exports){
  var assocIndexOf = require('./_assocIndexOf');
  
  /**
   * Checks if a list cache value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf ListCache
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function listCacheHas(key) {
    return assocIndexOf(this.__data__, key) > -1;
  }
  
  module.exports = listCacheHas;
  
  },{"./_assocIndexOf":43}],157:[function(require,module,exports){
  var assocIndexOf = require('./_assocIndexOf');
  
  /**
   * Sets the list cache `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf ListCache
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the list cache instance.
   */
  function listCacheSet(key, value) {
    var data = this.__data__,
        index = assocIndexOf(data, key);
  
    if (index < 0) {
      ++this.size;
      data.push([key, value]);
    } else {
      data[index][1] = value;
    }
    return this;
  }
  
  module.exports = listCacheSet;
  
  },{"./_assocIndexOf":43}],158:[function(require,module,exports){
  var Hash = require('./_Hash'),
      ListCache = require('./_ListCache'),
      Map = require('./_Map');
  
  /**
   * Removes all key-value entries from the map.
   *
   * @private
   * @name clear
   * @memberOf MapCache
   */
  function mapCacheClear() {
    this.size = 0;
    this.__data__ = {
      'hash': new Hash,
      'map': new (Map || ListCache),
      'string': new Hash
    };
  }
  
  module.exports = mapCacheClear;
  
  },{"./_Hash":18,"./_ListCache":20,"./_Map":22}],159:[function(require,module,exports){
  var getMapData = require('./_getMapData');
  
  /**
   * Removes `key` and its value from the map.
   *
   * @private
   * @name delete
   * @memberOf MapCache
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function mapCacheDelete(key) {
    var result = getMapData(this, key)['delete'](key);
    this.size -= result ? 1 : 0;
    return result;
  }
  
  module.exports = mapCacheDelete;
  
  },{"./_getMapData":124}],160:[function(require,module,exports){
  var getMapData = require('./_getMapData');
  
  /**
   * Gets the map value for `key`.
   *
   * @private
   * @name get
   * @memberOf MapCache
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function mapCacheGet(key) {
    return getMapData(this, key).get(key);
  }
  
  module.exports = mapCacheGet;
  
  },{"./_getMapData":124}],161:[function(require,module,exports){
  var getMapData = require('./_getMapData');
  
  /**
   * Checks if a map value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf MapCache
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function mapCacheHas(key) {
    return getMapData(this, key).has(key);
  }
  
  module.exports = mapCacheHas;
  
  },{"./_getMapData":124}],162:[function(require,module,exports){
  var getMapData = require('./_getMapData');
  
  /**
   * Sets the map `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf MapCache
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the map cache instance.
   */
  function mapCacheSet(key, value) {
    var data = getMapData(this, key),
        size = data.size;
  
    data.set(key, value);
    this.size += data.size == size ? 0 : 1;
    return this;
  }
  
  module.exports = mapCacheSet;
  
  },{"./_getMapData":124}],163:[function(require,module,exports){
  /**
   * Converts `map` to its key-value pairs.
   *
   * @private
   * @param {Object} map The map to convert.
   * @returns {Array} Returns the key-value pairs.
   */
  function mapToArray(map) {
    var index = -1,
        result = Array(map.size);
  
    map.forEach(function(value, key) {
      result[++index] = [key, value];
    });
    return result;
  }
  
  module.exports = mapToArray;
  
  },{}],164:[function(require,module,exports){
  /**
   * A specialized version of `matchesProperty` for source values suitable
   * for strict equality comparisons, i.e. `===`.
   *
   * @private
   * @param {string} key The key of the property to get.
   * @param {*} srcValue The value to match.
   * @returns {Function} Returns the new spec function.
   */
  function matchesStrictComparable(key, srcValue) {
    return function(object) {
      if (object == null) {
        return false;
      }
      return object[key] === srcValue &&
        (srcValue !== undefined || (key in Object(object)));
    };
  }
  
  module.exports = matchesStrictComparable;
  
  },{}],165:[function(require,module,exports){
  var memoize = require('./memoize');
  
  /** Used as the maximum memoize cache size. */
  var MAX_MEMOIZE_SIZE = 500;
  
  /**
   * A specialized version of `_.memoize` which clears the memoized function's
   * cache when it exceeds `MAX_MEMOIZE_SIZE`.
   *
   * @private
   * @param {Function} func The function to have its output memoized.
   * @returns {Function} Returns the new memoized function.
   */
  function memoizeCapped(func) {
    var result = memoize(func, function(key) {
      if (cache.size === MAX_MEMOIZE_SIZE) {
        cache.clear();
      }
      return key;
    });
  
    var cache = result.cache;
    return result;
  }
  
  module.exports = memoizeCapped;
  
  },{"./memoize":249}],166:[function(require,module,exports){
  var composeArgs = require('./_composeArgs'),
      composeArgsRight = require('./_composeArgsRight'),
      replaceHolders = require('./_replaceHolders');
  
  /** Used as the internal argument placeholder. */
  var PLACEHOLDER = '__lodash_placeholder__';
  
  /** Used to compose bitmasks for function metadata. */
  var WRAP_BIND_FLAG = 1,
      WRAP_BIND_KEY_FLAG = 2,
      WRAP_CURRY_BOUND_FLAG = 4,
      WRAP_CURRY_FLAG = 8,
      WRAP_ARY_FLAG = 128,
      WRAP_REARG_FLAG = 256;
  
  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeMin = Math.min;
  
  /**
   * Merges the function metadata of `source` into `data`.
   *
   * Merging metadata reduces the number of wrappers used to invoke a function.
   * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`
   * may be applied regardless of execution order. Methods like `_.ary` and
   * `_.rearg` modify function arguments, making the order in which they are
   * executed important, preventing the merging of metadata. However, we make
   * an exception for a safe combined case where curried functions have `_.ary`
   * and or `_.rearg` applied.
   *
   * @private
   * @param {Array} data The destination metadata.
   * @param {Array} source The source metadata.
   * @returns {Array} Returns `data`.
   */
  function mergeData(data, source) {
    var bitmask = data[1],
        srcBitmask = source[1],
        newBitmask = bitmask | srcBitmask,
        isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);
  
    var isCombo =
      ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||
      ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||
      ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));
  
    // Exit early if metadata can't be merged.
    if (!(isCommon || isCombo)) {
      return data;
    }
    // Use source `thisArg` if available.
    if (srcBitmask & WRAP_BIND_FLAG) {
      data[2] = source[2];
      // Set when currying a bound function.
      newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
    }
    // Compose partial arguments.
    var value = source[3];
    if (value) {
      var partials = data[3];
      data[3] = partials ? composeArgs(partials, value, source[4]) : value;
      data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
    }
    // Compose partial right arguments.
    value = source[5];
    if (value) {
      partials = data[5];
      data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
      data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
    }
    // Use source `argPos` if available.
    value = source[7];
    if (value) {
      data[7] = value;
    }
    // Use source `ary` if it's smaller.
    if (srcBitmask & WRAP_ARY_FLAG) {
      data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
    }
    // Use source `arity` if one is not provided.
    if (data[9] == null) {
      data[9] = source[9];
    }
    // Use source `func` and merge bitmasks.
    data[0] = source[0];
    data[1] = newBitmask;
  
    return data;
  }
  
  module.exports = mergeData;
  
  },{"./_composeArgs":94,"./_composeArgsRight":95,"./_replaceHolders":177}],167:[function(require,module,exports){
  var WeakMap = require('./_WeakMap');
  
  /** Used to store function metadata. */
  var metaMap = WeakMap && new WeakMap;
  
  module.exports = metaMap;
  
  },{"./_WeakMap":30}],168:[function(require,module,exports){
  var getNative = require('./_getNative');
  
  /* Built-in method references that are verified to be native. */
  var nativeCreate = getNative(Object, 'create');
  
  module.exports = nativeCreate;
  
  },{"./_getNative":126}],169:[function(require,module,exports){
  var overArg = require('./_overArg');
  
  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeKeys = overArg(Object.keys, Object);
  
  module.exports = nativeKeys;
  
  },{"./_overArg":173}],170:[function(require,module,exports){
  /**
   * This function is like
   * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
   * except that it includes inherited enumerable properties.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   */
  function nativeKeysIn(object) {
    var result = [];
    if (object != null) {
      for (var key in Object(object)) {
        result.push(key);
      }
    }
    return result;
  }
  
  module.exports = nativeKeysIn;
  
  },{}],171:[function(require,module,exports){
  var freeGlobal = require('./_freeGlobal');
  
  /** Detect free variable `exports`. */
  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
  
  /** Detect free variable `module`. */
  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
  
  /** Detect the popular CommonJS extension `module.exports`. */
  var moduleExports = freeModule && freeModule.exports === freeExports;
  
  /** Detect free variable `process` from Node.js. */
  var freeProcess = moduleExports && freeGlobal.process;
  
  /** Used to access faster Node.js helpers. */
  var nodeUtil = (function() {
    try {
      return freeProcess && freeProcess.binding && freeProcess.binding('util');
    } catch (e) {}
  }());
  
  module.exports = nodeUtil;
  
  },{"./_freeGlobal":118}],172:[function(require,module,exports){
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /**
   * Used to resolve the
   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
   * of values.
   */
  var nativeObjectToString = objectProto.toString;
  
  /**
   * Converts `value` to a string using `Object.prototype.toString`.
   *
   * @private
   * @param {*} value The value to convert.
   * @returns {string} Returns the converted string.
   */
  function objectToString(value) {
    return nativeObjectToString.call(value);
  }
  
  module.exports = objectToString;
  
  },{}],173:[function(require,module,exports){
  /**
   * Creates a unary function that invokes `func` with its argument transformed.
   *
   * @private
   * @param {Function} func The function to wrap.
   * @param {Function} transform The argument transform.
   * @returns {Function} Returns the new function.
   */
  function overArg(func, transform) {
    return function(arg) {
      return func(transform(arg));
    };
  }
  
  module.exports = overArg;
  
  },{}],174:[function(require,module,exports){
  var apply = require('./_apply');
  
  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeMax = Math.max;
  
  /**
   * A specialized version of `baseRest` which transforms the rest array.
   *
   * @private
   * @param {Function} func The function to apply a rest parameter to.
   * @param {number} [start=func.length-1] The start position of the rest parameter.
   * @param {Function} transform The rest array transform.
   * @returns {Function} Returns the new function.
   */
  function overRest(func, start, transform) {
    start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
    return function() {
      var args = arguments,
          index = -1,
          length = nativeMax(args.length - start, 0),
          array = Array(length);
  
      while (++index < length) {
        array[index] = args[start + index];
      }
      index = -1;
      var otherArgs = Array(start + 1);
      while (++index < start) {
        otherArgs[index] = args[index];
      }
      otherArgs[start] = transform(array);
      return apply(func, this, otherArgs);
    };
  }
  
  module.exports = overRest;
  
  },{"./_apply":33}],175:[function(require,module,exports){
  /** Used to lookup unminified function names. */
  var realNames = {};
  
  module.exports = realNames;
  
  },{}],176:[function(require,module,exports){
  var copyArray = require('./_copyArray'),
      isIndex = require('./_isIndex');
  
  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeMin = Math.min;
  
  /**
   * Reorder `array` according to the specified indexes where the element at
   * the first index is assigned as the first element, the element at
   * the second index is assigned as the second element, and so on.
   *
   * @private
   * @param {Array} array The array to reorder.
   * @param {Array} indexes The arranged array indexes.
   * @returns {Array} Returns `array`.
   */
  function reorder(array, indexes) {
    var arrLength = array.length,
        length = nativeMin(indexes.length, arrLength),
        oldArray = copyArray(array);
  
    while (length--) {
      var index = indexes[length];
      array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;
    }
    return array;
  }
  
  module.exports = reorder;
  
  },{"./_copyArray":96,"./_isIndex":145}],177:[function(require,module,exports){
  /** Used as the internal argument placeholder. */
  var PLACEHOLDER = '__lodash_placeholder__';
  
  /**
   * Replaces all `placeholder` elements in `array` with an internal placeholder
   * and returns an array of their indexes.
   *
   * @private
   * @param {Array} array The array to modify.
   * @param {*} placeholder The placeholder to replace.
   * @returns {Array} Returns the new array of placeholder indexes.
   */
  function replaceHolders(array, placeholder) {
    var index = -1,
        length = array.length,
        resIndex = 0,
        result = [];
  
    while (++index < length) {
      var value = array[index];
      if (value === placeholder || value === PLACEHOLDER) {
        array[index] = PLACEHOLDER;
        result[resIndex++] = index;
      }
    }
    return result;
  }
  
  module.exports = replaceHolders;
  
  },{}],178:[function(require,module,exports){
  var freeGlobal = require('./_freeGlobal');
  
  /** Detect free variable `self`. */
  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
  
  /** Used as a reference to the global object. */
  var root = freeGlobal || freeSelf || Function('return this')();
  
  module.exports = root;
  
  },{"./_freeGlobal":118}],179:[function(require,module,exports){
  /** Used to stand-in for `undefined` hash values. */
  var HASH_UNDEFINED = '__lodash_hash_undefined__';
  
  /**
   * Adds `value` to the array cache.
   *
   * @private
   * @name add
   * @memberOf SetCache
   * @alias push
   * @param {*} value The value to cache.
   * @returns {Object} Returns the cache instance.
   */
  function setCacheAdd(value) {
    this.__data__.set(value, HASH_UNDEFINED);
    return this;
  }
  
  module.exports = setCacheAdd;
  
  },{}],180:[function(require,module,exports){
  /**
   * Checks if `value` is in the array cache.
   *
   * @private
   * @name has
   * @memberOf SetCache
   * @param {*} value The value to search for.
   * @returns {number} Returns `true` if `value` is found, else `false`.
   */
  function setCacheHas(value) {
    return this.__data__.has(value);
  }
  
  module.exports = setCacheHas;
  
  },{}],181:[function(require,module,exports){
  var baseSetData = require('./_baseSetData'),
      shortOut = require('./_shortOut');
  
  /**
   * Sets metadata for `func`.
   *
   * **Note:** If this function becomes hot, i.e. is invoked a lot in a short
   * period of time, it will trip its breaker and transition to an identity
   * function to avoid garbage collection pauses in V8. See
   * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)
   * for more details.
   *
   * @private
   * @param {Function} func The function to associate metadata with.
   * @param {*} data The metadata.
   * @returns {Function} Returns `func`.
   */
  var setData = shortOut(baseSetData);
  
  module.exports = setData;
  
  },{"./_baseSetData":78,"./_shortOut":185}],182:[function(require,module,exports){
  /**
   * Converts `set` to an array of its values.
   *
   * @private
   * @param {Object} set The set to convert.
   * @returns {Array} Returns the values.
   */
  function setToArray(set) {
    var index = -1,
        result = Array(set.size);
  
    set.forEach(function(value) {
      result[++index] = value;
    });
    return result;
  }
  
  module.exports = setToArray;
  
  },{}],183:[function(require,module,exports){
  var baseSetToString = require('./_baseSetToString'),
      shortOut = require('./_shortOut');
  
  /**
   * Sets the `toString` method of `func` to return `string`.
   *
   * @private
   * @param {Function} func The function to modify.
   * @param {Function} string The `toString` result.
   * @returns {Function} Returns `func`.
   */
  var setToString = shortOut(baseSetToString);
  
  module.exports = setToString;
  
  },{"./_baseSetToString":79,"./_shortOut":185}],184:[function(require,module,exports){
  var getWrapDetails = require('./_getWrapDetails'),
      insertWrapDetails = require('./_insertWrapDetails'),
      setToString = require('./_setToString'),
      updateWrapDetails = require('./_updateWrapDetails');
  
  /**
   * Sets the `toString` method of `wrapper` to mimic the source of `reference`
   * with wrapper details in a comment at the top of the source body.
   *
   * @private
   * @param {Function} wrapper The function to modify.
   * @param {Function} reference The reference function.
   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
   * @returns {Function} Returns `wrapper`.
   */
  function setWrapToString(wrapper, reference, bitmask) {
    var source = (reference + '');
    return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
  }
  
  module.exports = setWrapToString;
  
  },{"./_getWrapDetails":133,"./_insertWrapDetails":143,"./_setToString":183,"./_updateWrapDetails":195}],185:[function(require,module,exports){
  /** Used to detect hot functions by number of calls within a span of milliseconds. */
  var HOT_COUNT = 800,
      HOT_SPAN = 16;
  
  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeNow = Date.now;
  
  /**
   * Creates a function that'll short out and invoke `identity` instead
   * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
   * milliseconds.
   *
   * @private
   * @param {Function} func The function to restrict.
   * @returns {Function} Returns the new shortable function.
   */
  function shortOut(func) {
    var count = 0,
        lastCalled = 0;
  
    return function() {
      var stamp = nativeNow(),
          remaining = HOT_SPAN - (stamp - lastCalled);
  
      lastCalled = stamp;
      if (remaining > 0) {
        if (++count >= HOT_COUNT) {
          return arguments[0];
        }
      } else {
        count = 0;
      }
      return func.apply(undefined, arguments);
    };
  }
  
  module.exports = shortOut;
  
  },{}],186:[function(require,module,exports){
  var ListCache = require('./_ListCache');
  
  /**
   * Removes all key-value entries from the stack.
   *
   * @private
   * @name clear
   * @memberOf Stack
   */
  function stackClear() {
    this.__data__ = new ListCache;
    this.size = 0;
  }
  
  module.exports = stackClear;
  
  },{"./_ListCache":20}],187:[function(require,module,exports){
  /**
   * Removes `key` and its value from the stack.
   *
   * @private
   * @name delete
   * @memberOf Stack
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function stackDelete(key) {
    var data = this.__data__,
        result = data['delete'](key);
  
    this.size = data.size;
    return result;
  }
  
  module.exports = stackDelete;
  
  },{}],188:[function(require,module,exports){
  /**
   * Gets the stack value for `key`.
   *
   * @private
   * @name get
   * @memberOf Stack
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function stackGet(key) {
    return this.__data__.get(key);
  }
  
  module.exports = stackGet;
  
  },{}],189:[function(require,module,exports){
  /**
   * Checks if a stack value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf Stack
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function stackHas(key) {
    return this.__data__.has(key);
  }
  
  module.exports = stackHas;
  
  },{}],190:[function(require,module,exports){
  var ListCache = require('./_ListCache'),
      Map = require('./_Map'),
      MapCache = require('./_MapCache');
  
  /** Used as the size to enable large array optimizations. */
  var LARGE_ARRAY_SIZE = 200;
  
  /**
   * Sets the stack `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf Stack
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the stack cache instance.
   */
  function stackSet(key, value) {
    var data = this.__data__;
    if (data instanceof ListCache) {
      var pairs = data.__data__;
      if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
        pairs.push([key, value]);
        this.size = ++data.size;
        return this;
      }
      data = this.__data__ = new MapCache(pairs);
    }
    data.set(key, value);
    this.size = data.size;
    return this;
  }
  
  module.exports = stackSet;
  
  },{"./_ListCache":20,"./_Map":22,"./_MapCache":23}],191:[function(require,module,exports){
  /**
   * A specialized version of `_.indexOf` which performs strict equality
   * comparisons of values, i.e. `===`.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @param {number} fromIndex The index to search from.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function strictIndexOf(array, value, fromIndex) {
    var index = fromIndex - 1,
        length = array.length;
  
    while (++index < length) {
      if (array[index] === value) {
        return index;
      }
    }
    return -1;
  }
  
  module.exports = strictIndexOf;
  
  },{}],192:[function(require,module,exports){
  var memoizeCapped = require('./_memoizeCapped');
  
  /** Used to match property names within property paths. */
  var reLeadingDot = /^\./,
      rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
  
  /** Used to match backslashes in property paths. */
  var reEscapeChar = /\\(\\)?/g;
  
  /**
   * Converts `string` to a property path array.
   *
   * @private
   * @param {string} string The string to convert.
   * @returns {Array} Returns the property path array.
   */
  var stringToPath = memoizeCapped(function(string) {
    var result = [];
    if (reLeadingDot.test(string)) {
      result.push('');
    }
    string.replace(rePropName, function(match, number, quote, string) {
      result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
    });
    return result;
  });
  
  module.exports = stringToPath;
  
  },{"./_memoizeCapped":165}],193:[function(require,module,exports){
  var isSymbol = require('./isSymbol');
  
  /** Used as references for various `Number` constants. */
  var INFINITY = 1 / 0;
  
  /**
   * Converts `value` to a string key if it's not a string or symbol.
   *
   * @private
   * @param {*} value The value to inspect.
   * @returns {string|symbol} Returns the key.
   */
  function toKey(value) {
    if (typeof value == 'string' || isSymbol(value)) {
      return value;
    }
    var result = (value + '');
    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
  }
  
  module.exports = toKey;
  
  },{"./isSymbol":241}],194:[function(require,module,exports){
  /** Used for built-in method references. */
  var funcProto = Function.prototype;
  
  /** Used to resolve the decompiled source of functions. */
  var funcToString = funcProto.toString;
  
  /**
   * Converts `func` to its source code.
   *
   * @private
   * @param {Function} func The function to convert.
   * @returns {string} Returns the source code.
   */
  function toSource(func) {
    if (func != null) {
      try {
        return funcToString.call(func);
      } catch (e) {}
      try {
        return (func + '');
      } catch (e) {}
    }
    return '';
  }
  
  module.exports = toSource;
  
  },{}],195:[function(require,module,exports){
  var arrayEach = require('./_arrayEach'),
      arrayIncludes = require('./_arrayIncludes');
  
  /** Used to compose bitmasks for function metadata. */
  var WRAP_BIND_FLAG = 1,
      WRAP_BIND_KEY_FLAG = 2,
      WRAP_CURRY_FLAG = 8,
      WRAP_CURRY_RIGHT_FLAG = 16,
      WRAP_PARTIAL_FLAG = 32,
      WRAP_PARTIAL_RIGHT_FLAG = 64,
      WRAP_ARY_FLAG = 128,
      WRAP_REARG_FLAG = 256,
      WRAP_FLIP_FLAG = 512;
  
  /** Used to associate wrap methods with their bit flags. */
  var wrapFlags = [
    ['ary', WRAP_ARY_FLAG],
    ['bind', WRAP_BIND_FLAG],
    ['bindKey', WRAP_BIND_KEY_FLAG],
    ['curry', WRAP_CURRY_FLAG],
    ['curryRight', WRAP_CURRY_RIGHT_FLAG],
    ['flip', WRAP_FLIP_FLAG],
    ['partial', WRAP_PARTIAL_FLAG],
    ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
    ['rearg', WRAP_REARG_FLAG]
  ];
  
  /**
   * Updates wrapper `details` based on `bitmask` flags.
   *
   * @private
   * @returns {Array} details The details to modify.
   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
   * @returns {Array} Returns `details`.
   */
  function updateWrapDetails(details, bitmask) {
    arrayEach(wrapFlags, function(pair) {
      var value = '_.' + pair[0];
      if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {
        details.push(value);
      }
    });
    return details.sort();
  }
  
  module.exports = updateWrapDetails;
  
  },{"./_arrayEach":34,"./_arrayIncludes":36}],196:[function(require,module,exports){
  var LazyWrapper = require('./_LazyWrapper'),
      LodashWrapper = require('./_LodashWrapper'),
      copyArray = require('./_copyArray');
  
  /**
   * Creates a clone of `wrapper`.
   *
   * @private
   * @param {Object} wrapper The wrapper to clone.
   * @returns {Object} Returns the cloned wrapper.
   */
  function wrapperClone(wrapper) {
    if (wrapper instanceof LazyWrapper) {
      return wrapper.clone();
    }
    var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
    result.__actions__ = copyArray(wrapper.__actions__);
    result.__index__  = wrapper.__index__;
    result.__values__ = wrapper.__values__;
    return result;
  }
  
  module.exports = wrapperClone;
  
  },{"./_LazyWrapper":19,"./_LodashWrapper":21,"./_copyArray":96}],197:[function(require,module,exports){
  var createWrap = require('./_createWrap');
  
  /** Used to compose bitmasks for function metadata. */
  var WRAP_ARY_FLAG = 128;
  
  /**
   * Creates a function that invokes `func`, with up to `n` arguments,
   * ignoring any additional arguments.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Function
   * @param {Function} func The function to cap arguments for.
   * @param {number} [n=func.length] The arity cap.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {Function} Returns the new capped function.
   * @example
   *
   * _.map(['6', '8', '10'], _.ary(parseInt, 1));
   * // => [6, 8, 10]
   */
  function ary(func, n, guard) {
    n = guard ? undefined : n;
    n = (func && n == null) ? func.length : n;
    return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);
  }
  
  module.exports = ary;
  
  },{"./_createWrap":112}],198:[function(require,module,exports){
  var copyObject = require('./_copyObject'),
      createAssigner = require('./_createAssigner'),
      keysIn = require('./keysIn');
  
  /**
   * This method is like `_.assign` except that it iterates over own and
   * inherited source properties.
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @alias extend
   * @category Object
   * @param {Object} object The destination object.
   * @param {...Object} [sources] The source objects.
   * @returns {Object} Returns `object`.
   * @see _.assign
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   * }
   *
   * function Bar() {
   *   this.c = 3;
   * }
   *
   * Foo.prototype.b = 2;
   * Bar.prototype.d = 4;
   *
   * _.assignIn({ 'a': 0 }, new Foo, new Bar);
   * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }
   */
  var assignIn = createAssigner(function(object, source) {
    copyObject(source, keysIn(source), object);
  });
  
  module.exports = assignIn;
  
  },{"./_copyObject":97,"./_createAssigner":102,"./keysIn":246}],199:[function(require,module,exports){
  var baseClone = require('./_baseClone');
  
  /** Used to compose bitmasks for cloning. */
  var CLONE_SYMBOLS_FLAG = 4;
  
  /**
   * Creates a shallow clone of `value`.
   *
   * **Note:** This method is loosely based on the
   * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
   * and supports cloning arrays, array buffers, booleans, date objects, maps,
   * numbers, `Object` objects, regexes, sets, strings, symbols, and typed
   * arrays. The own enumerable properties of `arguments` objects are cloned
   * as plain objects. An empty object is returned for uncloneable values such
   * as error objects, functions, DOM nodes, and WeakMaps.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to clone.
   * @returns {*} Returns the cloned value.
   * @see _.cloneDeep
   * @example
   *
   * var objects = [{ 'a': 1 }, { 'b': 2 }];
   *
   * var shallow = _.clone(objects);
   * console.log(shallow[0] === objects[0]);
   * // => true
   */
  function clone(value) {
    return baseClone(value, CLONE_SYMBOLS_FLAG);
  }
  
  module.exports = clone;
  
  },{"./_baseClone":47}],200:[function(require,module,exports){
  /**
   * Creates a function that returns `value`.
   *
   * @static
   * @memberOf _
   * @since 2.4.0
   * @category Util
   * @param {*} value The value to return from the new function.
   * @returns {Function} Returns the new constant function.
   * @example
   *
   * var objects = _.times(2, _.constant({ 'a': 1 }));
   *
   * console.log(objects);
   * // => [{ 'a': 1 }, { 'a': 1 }]
   *
   * console.log(objects[0] === objects[1]);
   * // => true
   */
  function constant(value) {
    return function() {
      return value;
    };
  }
  
  module.exports = constant;
  
  },{}],201:[function(require,module,exports){
  var createWrap = require('./_createWrap');
  
  /** Used to compose bitmasks for function metadata. */
  var WRAP_CURRY_FLAG = 8;
  
  /**
   * Creates a function that accepts arguments of `func` and either invokes
   * `func` returning its result, if at least `arity` number of arguments have
   * been provided, or returns a function that accepts the remaining `func`
   * arguments, and so on. The arity of `func` may be specified if `func.length`
   * is not sufficient.
   *
   * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,
   * may be used as a placeholder for provided arguments.
   *
   * **Note:** This method doesn't set the "length" property of curried functions.
   *
   * @static
   * @memberOf _
   * @since 2.0.0
   * @category Function
   * @param {Function} func The function to curry.
   * @param {number} [arity=func.length] The arity of `func`.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {Function} Returns the new curried function.
   * @example
   *
   * var abc = function(a, b, c) {
   *   return [a, b, c];
   * };
   *
   * var curried = _.curry(abc);
   *
   * curried(1)(2)(3);
   * // => [1, 2, 3]
   *
   * curried(1, 2)(3);
   * // => [1, 2, 3]
   *
   * curried(1, 2, 3);
   * // => [1, 2, 3]
   *
   * // Curried with placeholders.
   * curried(1)(_, 3)(2);
   * // => [1, 2, 3]
   */
  function curry(func, arity, guard) {
    arity = guard ? undefined : arity;
    var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
    result.placeholder = curry.placeholder;
    return result;
  }
  
  // Assign default placeholders.
  curry.placeholder = {};
  
  module.exports = curry;
  
  },{"./_createWrap":112}],202:[function(require,module,exports){
  /**
   * Performs a
   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * comparison between two values to determine if they are equivalent.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
   * @example
   *
   * var object = { 'a': 1 };
   * var other = { 'a': 1 };
   *
   * _.eq(object, object);
   * // => true
   *
   * _.eq(object, other);
   * // => false
   *
   * _.eq('a', 'a');
   * // => true
   *
   * _.eq('a', Object('a'));
   * // => false
   *
   * _.eq(NaN, NaN);
   * // => true
   */
  function eq(value, other) {
    return value === other || (value !== value && other !== other);
  }
  
  module.exports = eq;
  
  },{}],203:[function(require,module,exports){
  var createFind = require('./_createFind'),
      findIndex = require('./findIndex');
  
  /**
   * Iterates over elements of `collection`, returning the first element
   * `predicate` returns truthy for. The predicate is invoked with three
   * arguments: (value, index|key, collection).
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Collection
   * @param {Array|Object} collection The collection to inspect.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @param {number} [fromIndex=0] The index to search from.
   * @returns {*} Returns the matched element, else `undefined`.
   * @example
   *
   * var users = [
   *   { 'user': 'barney',  'age': 36, 'active': true },
   *   { 'user': 'fred',    'age': 40, 'active': false },
   *   { 'user': 'pebbles', 'age': 1,  'active': true }
   * ];
   *
   * _.find(users, function(o) { return o.age < 40; });
   * // => object for 'barney'
   *
   * // The `_.matches` iteratee shorthand.
   * _.find(users, { 'age': 1, 'active': true });
   * // => object for 'pebbles'
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.find(users, ['active', false]);
   * // => object for 'fred'
   *
   * // The `_.property` iteratee shorthand.
   * _.find(users, 'active');
   * // => object for 'barney'
   */
  var find = createFind(findIndex);
  
  module.exports = find;
  
  },{"./_createFind":108,"./findIndex":204}],204:[function(require,module,exports){
  var baseFindIndex = require('./_baseFindIndex'),
      baseIteratee = require('./_baseIteratee'),
      toInteger = require('./toInteger');
  
  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeMax = Math.max;
  
  /**
   * This method is like `_.find` except that it returns the index of the first
   * element `predicate` returns truthy for instead of the element itself.
   *
   * @static
   * @memberOf _
   * @since 1.1.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @param {number} [fromIndex=0] The index to search from.
   * @returns {number} Returns the index of the found element, else `-1`.
   * @example
   *
   * var users = [
   *   { 'user': 'barney',  'active': false },
   *   { 'user': 'fred',    'active': false },
   *   { 'user': 'pebbles', 'active': true }
   * ];
   *
   * _.findIndex(users, function(o) { return o.user == 'barney'; });
   * // => 0
   *
   * // The `_.matches` iteratee shorthand.
   * _.findIndex(users, { 'user': 'fred', 'active': false });
   * // => 1
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.findIndex(users, ['active', false]);
   * // => 0
   *
   * // The `_.property` iteratee shorthand.
   * _.findIndex(users, 'active');
   * // => 2
   */
  function findIndex(array, predicate, fromIndex) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return -1;
    }
    var index = fromIndex == null ? 0 : toInteger(fromIndex);
    if (index < 0) {
      index = nativeMax(length + index, 0);
    }
    return baseFindIndex(array, baseIteratee(predicate, 3), index);
  }
  
  module.exports = findIndex;
  
  },{"./_baseFindIndex":50,"./_baseIteratee":66,"./toInteger":257}],205:[function(require,module,exports){
  var baseFlatten = require('./_baseFlatten');
  
  /**
   * Flattens `array` a single level deep.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The array to flatten.
   * @returns {Array} Returns the new flattened array.
   * @example
   *
   * _.flatten([1, [2, [3, [4]], 5]]);
   * // => [1, 2, [3, [4]], 5]
   */
  function flatten(array) {
    var length = array == null ? 0 : array.length;
    return length ? baseFlatten(array, 1) : [];
  }
  
  module.exports = flatten;
  
  },{"./_baseFlatten":51}],206:[function(require,module,exports){
  var arrayEach = require('./_arrayEach'),
      baseEach = require('./_baseEach'),
      castFunction = require('./_castFunction'),
      isArray = require('./isArray');
  
  /**
   * Iterates over elements of `collection` and invokes `iteratee` for each element.
   * The iteratee is invoked with three arguments: (value, index|key, collection).
   * Iteratee functions may exit iteration early by explicitly returning `false`.
   *
   * **Note:** As with other "Collections" methods, objects with a "length"
   * property are iterated like arrays. To avoid this behavior use `_.forIn`
   * or `_.forOwn` for object iteration.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @alias each
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Array|Object} Returns `collection`.
   * @see _.forEachRight
   * @example
   *
   * _.forEach([1, 2], function(value) {
   *   console.log(value);
   * });
   * // => Logs `1` then `2`.
   *
   * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
   *   console.log(key);
   * });
   * // => Logs 'a' then 'b' (iteration order is not guaranteed).
   */
  function forEach(collection, iteratee) {
    var func = isArray(collection) ? arrayEach : baseEach;
    return func(collection, castFunction(iteratee));
  }
  
  module.exports = forEach;
  
  },{"./_arrayEach":34,"./_baseEach":49,"./_castFunction":84,"./isArray":232}],207:[function(require,module,exports){
  var mapping = require('./_mapping'),
      fallbackHolder = require('./placeholder');
  
  /** Built-in value reference. */
  var push = Array.prototype.push;
  
  /**
   * Creates a function, with an arity of `n`, that invokes `func` with the
   * arguments it receives.
   *
   * @private
   * @param {Function} func The function to wrap.
   * @param {number} n The arity of the new function.
   * @returns {Function} Returns the new function.
   */
  function baseArity(func, n) {
    return n == 2
      ? function(a, b) { return func.apply(undefined, arguments); }
      : function(a) { return func.apply(undefined, arguments); };
  }
  
  /**
   * Creates a function that invokes `func`, with up to `n` arguments, ignoring
   * any additional arguments.
   *
   * @private
   * @param {Function} func The function to cap arguments for.
   * @param {number} n The arity cap.
   * @returns {Function} Returns the new function.
   */
  function baseAry(func, n) {
    return n == 2
      ? function(a, b) { return func(a, b); }
      : function(a) { return func(a); };
  }
  
  /**
   * Creates a clone of `array`.
   *
   * @private
   * @param {Array} array The array to clone.
   * @returns {Array} Returns the cloned array.
   */
  function cloneArray(array) {
    var length = array ? array.length : 0,
        result = Array(length);
  
    while (length--) {
      result[length] = array[length];
    }
    return result;
  }
  
  /**
   * Creates a function that clones a given object using the assignment `func`.
   *
   * @private
   * @param {Function} func The assignment function.
   * @returns {Function} Returns the new cloner function.
   */
  function createCloner(func) {
    return function(object) {
      return func({}, object);
    };
  }
  
  /**
   * A specialized version of `_.spread` which flattens the spread array into
   * the arguments of the invoked `func`.
   *
   * @private
   * @param {Function} func The function to spread arguments over.
   * @param {number} start The start position of the spread.
   * @returns {Function} Returns the new function.
   */
  function flatSpread(func, start) {
    return function() {
      var length = arguments.length,
          lastIndex = length - 1,
          args = Array(length);
  
      while (length--) {
        args[length] = arguments[length];
      }
      var array = args[start],
          otherArgs = args.slice(0, start);
  
      if (array) {
        push.apply(otherArgs, array);
      }
      if (start != lastIndex) {
        push.apply(otherArgs, args.slice(start + 1));
      }
      return func.apply(this, otherArgs);
    };
  }
  
  /**
   * Creates a function that wraps `func` and uses `cloner` to clone the first
   * argument it receives.
   *
   * @private
   * @param {Function} func The function to wrap.
   * @param {Function} cloner The function to clone arguments.
   * @returns {Function} Returns the new immutable function.
   */
  function wrapImmutable(func, cloner) {
    return function() {
      var length = arguments.length;
      if (!length) {
        return;
      }
      var args = Array(length);
      while (length--) {
        args[length] = arguments[length];
      }
      var result = args[0] = cloner.apply(undefined, args);
      func.apply(undefined, args);
      return result;
    };
  }
  
  /**
   * The base implementation of `convert` which accepts a `util` object of methods
   * required to perform conversions.
   *
   * @param {Object} util The util object.
   * @param {string} name The name of the function to convert.
   * @param {Function} func The function to convert.
   * @param {Object} [options] The options object.
   * @param {boolean} [options.cap=true] Specify capping iteratee arguments.
   * @param {boolean} [options.curry=true] Specify currying.
   * @param {boolean} [options.fixed=true] Specify fixed arity.
   * @param {boolean} [options.immutable=true] Specify immutable operations.
   * @param {boolean} [options.rearg=true] Specify rearranging arguments.
   * @returns {Function|Object} Returns the converted function or object.
   */
  function baseConvert(util, name, func, options) {
    var setPlaceholder,
        isLib = typeof name == 'function',
        isObj = name === Object(name);
  
    if (isObj) {
      options = func;
      func = name;
      name = undefined;
    }
    if (func == null) {
      throw new TypeError;
    }
    options || (options = {});
  
    var config = {
      'cap': 'cap' in options ? options.cap : true,
      'curry': 'curry' in options ? options.curry : true,
      'fixed': 'fixed' in options ? options.fixed : true,
      'immutable': 'immutable' in options ? options.immutable : true,
      'rearg': 'rearg' in options ? options.rearg : true
    };
  
    var forceCurry = ('curry' in options) && options.curry,
        forceFixed = ('fixed' in options) && options.fixed,
        forceRearg = ('rearg' in options) && options.rearg,
        placeholder = isLib ? func : fallbackHolder,
        pristine = isLib ? func.runInContext() : undefined;
  
    var helpers = isLib ? func : {
      'ary': util.ary,
      'assign': util.assign,
      'clone': util.clone,
      'curry': util.curry,
      'forEach': util.forEach,
      'isArray': util.isArray,
      'isFunction': util.isFunction,
      'iteratee': util.iteratee,
      'keys': util.keys,
      'rearg': util.rearg,
      'toInteger': util.toInteger,
      'toPath': util.toPath
    };
  
    var ary = helpers.ary,
        assign = helpers.assign,
        clone = helpers.clone,
        curry = helpers.curry,
        each = helpers.forEach,
        isArray = helpers.isArray,
        isFunction = helpers.isFunction,
        keys = helpers.keys,
        rearg = helpers.rearg,
        toInteger = helpers.toInteger,
        toPath = helpers.toPath;
  
    var aryMethodKeys = keys(mapping.aryMethod);
  
    var wrappers = {
      'castArray': function(castArray) {
        return function() {
          var value = arguments[0];
          return isArray(value)
            ? castArray(cloneArray(value))
            : castArray.apply(undefined, arguments);
        };
      },
      'iteratee': function(iteratee) {
        return function() {
          var func = arguments[0],
              arity = arguments[1],
              result = iteratee(func, arity),
              length = result.length;
  
          if (config.cap && typeof arity == 'number') {
            arity = arity > 2 ? (arity - 2) : 1;
            return (length && length <= arity) ? result : baseAry(result, arity);
          }
          return result;
        };
      },
      'mixin': function(mixin) {
        return function(source) {
          var func = this;
          if (!isFunction(func)) {
            return mixin(func, Object(source));
          }
          var pairs = [];
          each(keys(source), function(key) {
            if (isFunction(source[key])) {
              pairs.push([key, func.prototype[key]]);
            }
          });
  
          mixin(func, Object(source));
  
          each(pairs, function(pair) {
            var value = pair[1];
            if (isFunction(value)) {
              func.prototype[pair[0]] = value;
            } else {
              delete func.prototype[pair[0]];
            }
          });
          return func;
        };
      },
      'nthArg': function(nthArg) {
        return function(n) {
          var arity = n < 0 ? 1 : (toInteger(n) + 1);
          return curry(nthArg(n), arity);
        };
      },
      'rearg': function(rearg) {
        return function(func, indexes) {
          var arity = indexes ? indexes.length : 0;
          return curry(rearg(func, indexes), arity);
        };
      },
      'runInContext': function(runInContext) {
        return function(context) {
          return baseConvert(util, runInContext(context), options);
        };
      }
    };
  
    /*--------------------------------------------------------------------------*/
  
    /**
     * Casts `func` to a function with an arity capped iteratee if needed.
     *
     * @private
     * @param {string} name The name of the function to inspect.
     * @param {Function} func The function to inspect.
     * @returns {Function} Returns the cast function.
     */
    function castCap(name, func) {
      if (config.cap) {
        var indexes = mapping.iterateeRearg[name];
        if (indexes) {
          return iterateeRearg(func, indexes);
        }
        var n = !isLib && mapping.iterateeAry[name];
        if (n) {
          return iterateeAry(func, n);
        }
      }
      return func;
    }
  
    /**
     * Casts `func` to a curried function if needed.
     *
     * @private
     * @param {string} name The name of the function to inspect.
     * @param {Function} func The function to inspect.
     * @param {number} n The arity of `func`.
     * @returns {Function} Returns the cast function.
     */
    function castCurry(name, func, n) {
      return (forceCurry || (config.curry && n > 1))
        ? curry(func, n)
        : func;
    }
  
    /**
     * Casts `func` to a fixed arity function if needed.
     *
     * @private
     * @param {string} name The name of the function to inspect.
     * @param {Function} func The function to inspect.
     * @param {number} n The arity cap.
     * @returns {Function} Returns the cast function.
     */
    function castFixed(name, func, n) {
      if (config.fixed && (forceFixed || !mapping.skipFixed[name])) {
        var data = mapping.methodSpread[name],
            start = data && data.start;
  
        return start  === undefined ? ary(func, n) : flatSpread(func, start);
      }
      return func;
    }
  
    /**
     * Casts `func` to an rearged function if needed.
     *
     * @private
     * @param {string} name The name of the function to inspect.
     * @param {Function} func The function to inspect.
     * @param {number} n The arity of `func`.
     * @returns {Function} Returns the cast function.
     */
    function castRearg(name, func, n) {
      return (config.rearg && n > 1 && (forceRearg || !mapping.skipRearg[name]))
        ? rearg(func, mapping.methodRearg[name] || mapping.aryRearg[n])
        : func;
    }
  
    /**
     * Creates a clone of `object` by `path`.
     *
     * @private
     * @param {Object} object The object to clone.
     * @param {Array|string} path The path to clone by.
     * @returns {Object} Returns the cloned object.
     */
    function cloneByPath(object, path) {
      path = toPath(path);
  
      var index = -1,
          length = path.length,
          lastIndex = length - 1,
          result = clone(Object(object)),
          nested = result;
  
      while (nested != null && ++index < length) {
        var key = path[index],
            value = nested[key];
  
        if (value != null) {
          nested[path[index]] = clone(index == lastIndex ? value : Object(value));
        }
        nested = nested[key];
      }
      return result;
    }
  
    /**
     * Converts `lodash` to an immutable auto-curried iteratee-first data-last
     * version with conversion `options` applied.
     *
     * @param {Object} [options] The options object. See `baseConvert` for more details.
     * @returns {Function} Returns the converted `lodash`.
     */
    function convertLib(options) {
      return _.runInContext.convert(options)(undefined);
    }
  
    /**
     * Create a converter function for `func` of `name`.
     *
     * @param {string} name The name of the function to convert.
     * @param {Function} func The function to convert.
     * @returns {Function} Returns the new converter function.
     */
    function createConverter(name, func) {
      var realName = mapping.aliasToReal[name] || name,
          methodName = mapping.remap[realName] || realName,
          oldOptions = options;
  
      return function(options) {
        var newUtil = isLib ? pristine : helpers,
            newFunc = isLib ? pristine[methodName] : func,
            newOptions = assign(assign({}, oldOptions), options);
  
        return baseConvert(newUtil, realName, newFunc, newOptions);
      };
    }
  
    /**
     * Creates a function that wraps `func` to invoke its iteratee, with up to `n`
     * arguments, ignoring any additional arguments.
     *
     * @private
     * @param {Function} func The function to cap iteratee arguments for.
     * @param {number} n The arity cap.
     * @returns {Function} Returns the new function.
     */
    function iterateeAry(func, n) {
      return overArg(func, function(func) {
        return typeof func == 'function' ? baseAry(func, n) : func;
      });
    }
  
    /**
     * Creates a function that wraps `func` to invoke its iteratee with arguments
     * arranged according to the specified `indexes` where the argument value at
     * the first index is provided as the first argument, the argument value at
     * the second index is provided as the second argument, and so on.
     *
     * @private
     * @param {Function} func The function to rearrange iteratee arguments for.
     * @param {number[]} indexes The arranged argument indexes.
     * @returns {Function} Returns the new function.
     */
    function iterateeRearg(func, indexes) {
      return overArg(func, function(func) {
        var n = indexes.length;
        return baseArity(rearg(baseAry(func, n), indexes), n);
      });
    }
  
    /**
     * Creates a function that invokes `func` with its first argument transformed.
     *
     * @private
     * @param {Function} func The function to wrap.
     * @param {Function} transform The argument transform.
     * @returns {Function} Returns the new function.
     */
    function overArg(func, transform) {
      return function() {
        var length = arguments.length;
        if (!length) {
          return func();
        }
        var args = Array(length);
        while (length--) {
          args[length] = arguments[length];
        }
        var index = config.rearg ? 0 : (length - 1);
        args[index] = transform(args[index]);
        return func.apply(undefined, args);
      };
    }
  
    /**
     * Creates a function that wraps `func` and applys the conversions
     * rules by `name`.
     *
     * @private
     * @param {string} name The name of the function to wrap.
     * @param {Function} func The function to wrap.
     * @returns {Function} Returns the converted function.
     */
    function wrap(name, func) {
      var result,
          realName = mapping.aliasToReal[name] || name,
          wrapped = func,
          wrapper = wrappers[realName];
  
      if (wrapper) {
        wrapped = wrapper(func);
      }
      else if (config.immutable) {
        if (mapping.mutate.array[realName]) {
          wrapped = wrapImmutable(func, cloneArray);
        }
        else if (mapping.mutate.object[realName]) {
          wrapped = wrapImmutable(func, createCloner(func));
        }
        else if (mapping.mutate.set[realName]) {
          wrapped = wrapImmutable(func, cloneByPath);
        }
      }
      each(aryMethodKeys, function(aryKey) {
        each(mapping.aryMethod[aryKey], function(otherName) {
          if (realName == otherName) {
            var data = mapping.methodSpread[realName],
                afterRearg = data && data.afterRearg;
  
            result = afterRearg
              ? castFixed(realName, castRearg(realName, wrapped, aryKey), aryKey)
              : castRearg(realName, castFixed(realName, wrapped, aryKey), aryKey);
  
            result = castCap(realName, result);
            result = castCurry(realName, result, aryKey);
            return false;
          }
        });
        return !result;
      });
  
      result || (result = wrapped);
      if (result == func) {
        result = forceCurry ? curry(result, 1) : function() {
          return func.apply(this, arguments);
        };
      }
      result.convert = createConverter(realName, func);
      if (mapping.placeholder[realName]) {
        setPlaceholder = true;
        result.placeholder = func.placeholder = placeholder;
      }
      return result;
    }
  
    /*--------------------------------------------------------------------------*/
  
    if (!isObj) {
      return wrap(name, func);
    }
    var _ = func;
  
    // Convert methods by ary cap.
    var pairs = [];
    each(aryMethodKeys, function(aryKey) {
      each(mapping.aryMethod[aryKey], function(key) {
        var func = _[mapping.remap[key] || key];
        if (func) {
          pairs.push([key, wrap(key, func)]);
        }
      });
    });
  
    // Convert remaining methods.
    each(keys(_), function(key) {
      var func = _[key];
      if (typeof func == 'function') {
        var length = pairs.length;
        while (length--) {
          if (pairs[length][0] == key) {
            return;
          }
        }
        func.convert = createConverter(key, func);
        pairs.push([key, func]);
      }
    });
  
    // Assign to `_` leaving `_.prototype` unchanged to allow chaining.
    each(pairs, function(pair) {
      _[pair[0]] = pair[1];
    });
  
    _.convert = convertLib;
    if (setPlaceholder) {
      _.placeholder = placeholder;
    }
    // Assign aliases.
    each(keys(_), function(key) {
      each(mapping.realToAlias[key] || [], function(alias) {
        _[alias] = _[key];
      });
    });
  
    return _;
  }
  
  module.exports = baseConvert;
  
  },{"./_mapping":209,"./placeholder":226}],208:[function(require,module,exports){
  module.exports = {
    'cap': false,
    'curry': false,
    'fixed': false,
    'immutable': false,
    'rearg': false
  };
  
  },{}],209:[function(require,module,exports){
  /** Used to map aliases to their real names. */
  exports.aliasToReal = {
  
    // Lodash aliases.
    'each': 'forEach',
    'eachRight': 'forEachRight',
    'entries': 'toPairs',
    'entriesIn': 'toPairsIn',
    'extend': 'assignIn',
    'extendAll': 'assignInAll',
    'extendAllWith': 'assignInAllWith',
    'extendWith': 'assignInWith',
    'first': 'head',
  
    // Methods that are curried variants of others.
    'conforms': 'conformsTo',
    'matches': 'isMatch',
    'property': 'get',
  
    // Ramda aliases.
    '__': 'placeholder',
    'F': 'stubFalse',
    'T': 'stubTrue',
    'all': 'every',
    'allPass': 'overEvery',
    'always': 'constant',
    'any': 'some',
    'anyPass': 'overSome',
    'apply': 'spread',
    'assoc': 'set',
    'assocPath': 'set',
    'complement': 'negate',
    'compose': 'flowRight',
    'contains': 'includes',
    'dissoc': 'unset',
    'dissocPath': 'unset',
    'dropLast': 'dropRight',
    'dropLastWhile': 'dropRightWhile',
    'equals': 'isEqual',
    'identical': 'eq',
    'indexBy': 'keyBy',
    'init': 'initial',
    'invertObj': 'invert',
    'juxt': 'over',
    'omitAll': 'omit',
    'nAry': 'ary',
    'path': 'get',
    'pathEq': 'matchesProperty',
    'pathOr': 'getOr',
    'paths': 'at',
    'pickAll': 'pick',
    'pipe': 'flow',
    'pluck': 'map',
    'prop': 'get',
    'propEq': 'matchesProperty',
    'propOr': 'getOr',
    'props': 'at',
    'symmetricDifference': 'xor',
    'symmetricDifferenceBy': 'xorBy',
    'symmetricDifferenceWith': 'xorWith',
    'takeLast': 'takeRight',
    'takeLastWhile': 'takeRightWhile',
    'unapply': 'rest',
    'unnest': 'flatten',
    'useWith': 'overArgs',
    'where': 'conformsTo',
    'whereEq': 'isMatch',
    'zipObj': 'zipObject'
  };
  
  /** Used to map ary to method names. */
  exports.aryMethod = {
    '1': [
      'assignAll', 'assignInAll', 'attempt', 'castArray', 'ceil', 'create',
      'curry', 'curryRight', 'defaultsAll', 'defaultsDeepAll', 'floor', 'flow',
      'flowRight', 'fromPairs', 'invert', 'iteratee', 'memoize', 'method', 'mergeAll',
      'methodOf', 'mixin', 'nthArg', 'over', 'overEvery', 'overSome','rest', 'reverse',
      'round', 'runInContext', 'spread', 'template', 'trim', 'trimEnd', 'trimStart',
      'uniqueId', 'words', 'zipAll'
    ],
    '2': [
      'add', 'after', 'ary', 'assign', 'assignAllWith', 'assignIn', 'assignInAllWith',
      'at', 'before', 'bind', 'bindAll', 'bindKey', 'chunk', 'cloneDeepWith',
      'cloneWith', 'concat', 'conformsTo', 'countBy', 'curryN', 'curryRightN',
      'debounce', 'defaults', 'defaultsDeep', 'defaultTo', 'delay', 'difference',
      'divide', 'drop', 'dropRight', 'dropRightWhile', 'dropWhile', 'endsWith', 'eq',
      'every', 'filter', 'find', 'findIndex', 'findKey', 'findLast', 'findLastIndex',
      'findLastKey', 'flatMap', 'flatMapDeep', 'flattenDepth', 'forEach',
      'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight', 'get',
      'groupBy', 'gt', 'gte', 'has', 'hasIn', 'includes', 'indexOf', 'intersection',
      'invertBy', 'invoke', 'invokeMap', 'isEqual', 'isMatch', 'join', 'keyBy',
      'lastIndexOf', 'lt', 'lte', 'map', 'mapKeys', 'mapValues', 'matchesProperty',
      'maxBy', 'meanBy', 'merge', 'mergeAllWith', 'minBy', 'multiply', 'nth', 'omit',
      'omitBy', 'overArgs', 'pad', 'padEnd', 'padStart', 'parseInt', 'partial',
      'partialRight', 'partition', 'pick', 'pickBy', 'propertyOf', 'pull', 'pullAll',
      'pullAt', 'random', 'range', 'rangeRight', 'rearg', 'reject', 'remove',
      'repeat', 'restFrom', 'result', 'sampleSize', 'some', 'sortBy', 'sortedIndex',
      'sortedIndexOf', 'sortedLastIndex', 'sortedLastIndexOf', 'sortedUniqBy',
      'split', 'spreadFrom', 'startsWith', 'subtract', 'sumBy', 'take', 'takeRight',
      'takeRightWhile', 'takeWhile', 'tap', 'throttle', 'thru', 'times', 'trimChars',
      'trimCharsEnd', 'trimCharsStart', 'truncate', 'union', 'uniqBy', 'uniqWith',
      'unset', 'unzipWith', 'without', 'wrap', 'xor', 'zip', 'zipObject',
      'zipObjectDeep'
    ],
    '3': [
      'assignInWith', 'assignWith', 'clamp', 'differenceBy', 'differenceWith',
      'findFrom', 'findIndexFrom', 'findLastFrom', 'findLastIndexFrom', 'getOr',
      'includesFrom', 'indexOfFrom', 'inRange', 'intersectionBy', 'intersectionWith',
      'invokeArgs', 'invokeArgsMap', 'isEqualWith', 'isMatchWith', 'flatMapDepth',
      'lastIndexOfFrom', 'mergeWith', 'orderBy', 'padChars', 'padCharsEnd',
      'padCharsStart', 'pullAllBy', 'pullAllWith', 'rangeStep', 'rangeStepRight',
      'reduce', 'reduceRight', 'replace', 'set', 'slice', 'sortedIndexBy',
      'sortedLastIndexBy', 'transform', 'unionBy', 'unionWith', 'update', 'xorBy',
      'xorWith', 'zipWith'
    ],
    '4': [
      'fill', 'setWith', 'updateWith'
    ]
  };
  
  /** Used to map ary to rearg configs. */
  exports.aryRearg = {
    '2': [1, 0],
    '3': [2, 0, 1],
    '4': [3, 2, 0, 1]
  };
  
  /** Used to map method names to their iteratee ary. */
  exports.iterateeAry = {
    'dropRightWhile': 1,
    'dropWhile': 1,
    'every': 1,
    'filter': 1,
    'find': 1,
    'findFrom': 1,
    'findIndex': 1,
    'findIndexFrom': 1,
    'findKey': 1,
    'findLast': 1,
    'findLastFrom': 1,
    'findLastIndex': 1,
    'findLastIndexFrom': 1,
    'findLastKey': 1,
    'flatMap': 1,
    'flatMapDeep': 1,
    'flatMapDepth': 1,
    'forEach': 1,
    'forEachRight': 1,
    'forIn': 1,
    'forInRight': 1,
    'forOwn': 1,
    'forOwnRight': 1,
    'map': 1,
    'mapKeys': 1,
    'mapValues': 1,
    'partition': 1,
    'reduce': 2,
    'reduceRight': 2,
    'reject': 1,
    'remove': 1,
    'some': 1,
    'takeRightWhile': 1,
    'takeWhile': 1,
    'times': 1,
    'transform': 2
  };
  
  /** Used to map method names to iteratee rearg configs. */
  exports.iterateeRearg = {
    'mapKeys': [1],
    'reduceRight': [1, 0]
  };
  
  /** Used to map method names to rearg configs. */
  exports.methodRearg = {
    'assignInAllWith': [1, 0],
    'assignInWith': [1, 2, 0],
    'assignAllWith': [1, 0],
    'assignWith': [1, 2, 0],
    'differenceBy': [1, 2, 0],
    'differenceWith': [1, 2, 0],
    'getOr': [2, 1, 0],
    'intersectionBy': [1, 2, 0],
    'intersectionWith': [1, 2, 0],
    'isEqualWith': [1, 2, 0],
    'isMatchWith': [2, 1, 0],
    'mergeAllWith': [1, 0],
    'mergeWith': [1, 2, 0],
    'padChars': [2, 1, 0],
    'padCharsEnd': [2, 1, 0],
    'padCharsStart': [2, 1, 0],
    'pullAllBy': [2, 1, 0],
    'pullAllWith': [2, 1, 0],
    'rangeStep': [1, 2, 0],
    'rangeStepRight': [1, 2, 0],
    'setWith': [3, 1, 2, 0],
    'sortedIndexBy': [2, 1, 0],
    'sortedLastIndexBy': [2, 1, 0],
    'unionBy': [1, 2, 0],
    'unionWith': [1, 2, 0],
    'updateWith': [3, 1, 2, 0],
    'xorBy': [1, 2, 0],
    'xorWith': [1, 2, 0],
    'zipWith': [1, 2, 0]
  };
  
  /** Used to map method names to spread configs. */
  exports.methodSpread = {
    'assignAll': { 'start': 0 },
    'assignAllWith': { 'start': 0 },
    'assignInAll': { 'start': 0 },
    'assignInAllWith': { 'start': 0 },
    'defaultsAll': { 'start': 0 },
    'defaultsDeepAll': { 'start': 0 },
    'invokeArgs': { 'start': 2 },
    'invokeArgsMap': { 'start': 2 },
    'mergeAll': { 'start': 0 },
    'mergeAllWith': { 'start': 0 },
    'partial': { 'start': 1 },
    'partialRight': { 'start': 1 },
    'without': { 'start': 1 },
    'zipAll': { 'start': 0 }
  };
  
  /** Used to identify methods which mutate arrays or objects. */
  exports.mutate = {
    'array': {
      'fill': true,
      'pull': true,
      'pullAll': true,
      'pullAllBy': true,
      'pullAllWith': true,
      'pullAt': true,
      'remove': true,
      'reverse': true
    },
    'object': {
      'assign': true,
      'assignAll': true,
      'assignAllWith': true,
      'assignIn': true,
      'assignInAll': true,
      'assignInAllWith': true,
      'assignInWith': true,
      'assignWith': true,
      'defaults': true,
      'defaultsAll': true,
      'defaultsDeep': true,
      'defaultsDeepAll': true,
      'merge': true,
      'mergeAll': true,
      'mergeAllWith': true,
      'mergeWith': true,
    },
    'set': {
      'set': true,
      'setWith': true,
      'unset': true,
      'update': true,
      'updateWith': true
    }
  };
  
  /** Used to track methods with placeholder support */
  exports.placeholder = {
    'bind': true,
    'bindKey': true,
    'curry': true,
    'curryRight': true,
    'partial': true,
    'partialRight': true
  };
  
  /** Used to map real names to their aliases. */
  exports.realToAlias = (function() {
    var hasOwnProperty = Object.prototype.hasOwnProperty,
        object = exports.aliasToReal,
        result = {};
  
    for (var key in object) {
      var value = object[key];
      if (hasOwnProperty.call(result, value)) {
        result[value].push(key);
      } else {
        result[value] = [key];
      }
    }
    return result;
  }());
  
  /** Used to map method names to other names. */
  exports.remap = {
    'assignAll': 'assign',
    'assignAllWith': 'assignWith',
    'assignInAll': 'assignIn',
    'assignInAllWith': 'assignInWith',
    'curryN': 'curry',
    'curryRightN': 'curryRight',
    'defaultsAll': 'defaults',
    'defaultsDeepAll': 'defaultsDeep',
    'findFrom': 'find',
    'findIndexFrom': 'findIndex',
    'findLastFrom': 'findLast',
    'findLastIndexFrom': 'findLastIndex',
    'getOr': 'get',
    'includesFrom': 'includes',
    'indexOfFrom': 'indexOf',
    'invokeArgs': 'invoke',
    'invokeArgsMap': 'invokeMap',
    'lastIndexOfFrom': 'lastIndexOf',
    'mergeAll': 'merge',
    'mergeAllWith': 'mergeWith',
    'padChars': 'pad',
    'padCharsEnd': 'padEnd',
    'padCharsStart': 'padStart',
    'propertyOf': 'get',
    'rangeStep': 'range',
    'rangeStepRight': 'rangeRight',
    'restFrom': 'rest',
    'spreadFrom': 'spread',
    'trimChars': 'trim',
    'trimCharsEnd': 'trimEnd',
    'trimCharsStart': 'trimStart',
    'zipAll': 'zip'
  };
  
  /** Used to track methods that skip fixing their arity. */
  exports.skipFixed = {
    'castArray': true,
    'flow': true,
    'flowRight': true,
    'iteratee': true,
    'mixin': true,
    'rearg': true,
    'runInContext': true
  };
  
  /** Used to track methods that skip rearranging arguments. */
  exports.skipRearg = {
    'add': true,
    'assign': true,
    'assignIn': true,
    'bind': true,
    'bindKey': true,
    'concat': true,
    'difference': true,
    'divide': true,
    'eq': true,
    'gt': true,
    'gte': true,
    'isEqual': true,
    'lt': true,
    'lte': true,
    'matchesProperty': true,
    'merge': true,
    'multiply': true,
    'overArgs': true,
    'partial': true,
    'partialRight': true,
    'propertyOf': true,
    'random': true,
    'range': true,
    'rangeRight': true,
    'subtract': true,
    'zip': true,
    'zipObject': true,
    'zipObjectDeep': true
  };
  
  },{}],210:[function(require,module,exports){
  module.exports = {
    'ary': require('../ary'),
    'assign': require('../_baseAssign'),
    'clone': require('../clone'),
    'curry': require('../curry'),
    'forEach': require('../_arrayEach'),
    'isArray': require('../isArray'),
    'isFunction': require('../isFunction'),
    'iteratee': require('../iteratee'),
    'keys': require('../_baseKeys'),
    'rearg': require('../rearg'),
    'toInteger': require('../toInteger'),
    'toPath': require('../toPath')
  };
  
  },{"../_arrayEach":34,"../_baseAssign":44,"../_baseKeys":67,"../ary":197,"../clone":199,"../curry":201,"../isArray":232,"../isFunction":235,"../iteratee":244,"../rearg":253,"../toInteger":257,"../toPath":259}],211:[function(require,module,exports){
  var convert = require('./convert'),
      func = convert('assignIn', require('../assignIn'));
  
  func.placeholder = require('./placeholder');
  module.exports = func;
  
  },{"../assignIn":198,"./convert":212,"./placeholder":226}],212:[function(require,module,exports){
  var baseConvert = require('./_baseConvert'),
      util = require('./_util');
  
  /**
   * Converts `func` of `name` to an immutable auto-curried iteratee-first data-last
   * version with conversion `options` applied. If `name` is an object its methods
   * will be converted.
   *
   * @param {string} name The name of the function to wrap.
   * @param {Function} [func] The function to wrap.
   * @param {Object} [options] The options object. See `baseConvert` for more details.
   * @returns {Function|Object} Returns the converted function or object.
   */
  function convert(name, func, options) {
    return baseConvert(util, name, func, options);
  }
  
  module.exports = convert;
  
  },{"./_baseConvert":207,"./_util":210}],213:[function(require,module,exports){
  module.exports = require('./forEach');
  
  },{"./forEach":216}],214:[function(require,module,exports){
  module.exports = require('./assignIn');
  
  },{"./assignIn":211}],215:[function(require,module,exports){
  var convert = require('./convert'),
      func = convert('find', require('../find'));
  
  func.placeholder = require('./placeholder');
  module.exports = func;
  
  },{"../find":203,"./convert":212,"./placeholder":226}],216:[function(require,module,exports){
  var convert = require('./convert'),
      func = convert('forEach', require('../forEach'));
  
  func.placeholder = require('./placeholder');
  module.exports = func;
  
  },{"../forEach":206,"./convert":212,"./placeholder":226}],217:[function(require,module,exports){
  var convert = require('./convert'),
      func = convert('isArray', require('../isArray'), require('./_falseOptions'));
  
  func.placeholder = require('./placeholder');
  module.exports = func;
  
  },{"../isArray":232,"./_falseOptions":208,"./convert":212,"./placeholder":226}],218:[function(require,module,exports){
  var convert = require('./convert'),
      func = convert('isFunction', require('../isFunction'), require('./_falseOptions'));
  
  func.placeholder = require('./placeholder');
  module.exports = func;
  
  },{"../isFunction":235,"./_falseOptions":208,"./convert":212,"./placeholder":226}],219:[function(require,module,exports){
  var convert = require('./convert'),
      func = convert('isNull', require('../isNull'), require('./_falseOptions'));
  
  func.placeholder = require('./placeholder');
  module.exports = func;
  
  },{"../isNull":237,"./_falseOptions":208,"./convert":212,"./placeholder":226}],220:[function(require,module,exports){
  var convert = require('./convert'),
      func = convert('isPlainObject', require('../isPlainObject'), require('./_falseOptions'));
  
  func.placeholder = require('./placeholder');
  module.exports = func;
  
  },{"../isPlainObject":240,"./_falseOptions":208,"./convert":212,"./placeholder":226}],221:[function(require,module,exports){
  var convert = require('./convert'),
      func = convert('isUndefined', require('../isUndefined'), require('./_falseOptions'));
  
  func.placeholder = require('./placeholder');
  module.exports = func;
  
  },{"../isUndefined":243,"./_falseOptions":208,"./convert":212,"./placeholder":226}],222:[function(require,module,exports){
  var convert = require('./convert'),
      func = convert('keys', require('../keys'), require('./_falseOptions'));
  
  func.placeholder = require('./placeholder');
  module.exports = func;
  
  },{"../keys":245,"./_falseOptions":208,"./convert":212,"./placeholder":226}],223:[function(require,module,exports){
  var convert = require('./convert'),
      func = convert('mapKeys', require('../mapKeys'));
  
  func.placeholder = require('./placeholder');
  module.exports = func;
  
  },{"../mapKeys":247,"./convert":212,"./placeholder":226}],224:[function(require,module,exports){
  var convert = require('./convert'),
      func = convert('mapValues', require('../mapValues'));
  
  func.placeholder = require('./placeholder');
  module.exports = func;
  
  },{"../mapValues":248,"./convert":212,"./placeholder":226}],225:[function(require,module,exports){
  var convert = require('./convert'),
      func = convert('pick', require('../pick'));
  
  func.placeholder = require('./placeholder');
  module.exports = func;
  
  },{"../pick":251,"./convert":212,"./placeholder":226}],226:[function(require,module,exports){
  /**
   * The default argument placeholder value for methods.
   *
   * @type {Object}
   */
  module.exports = {};
  
  },{}],227:[function(require,module,exports){
  var convert = require('./convert'),
      func = convert('transform', require('../transform'));
  
  func.placeholder = require('./placeholder');
  module.exports = func;
  
  },{"../transform":261,"./convert":212,"./placeholder":226}],228:[function(require,module,exports){
  var baseGet = require('./_baseGet');
  
  /**
   * Gets the value at `path` of `object`. If the resolved value is
   * `undefined`, the `defaultValue` is returned in its place.
   *
   * @static
   * @memberOf _
   * @since 3.7.0
   * @category Object
   * @param {Object} object The object to query.
   * @param {Array|string} path The path of the property to get.
   * @param {*} [defaultValue] The value returned for `undefined` resolved values.
   * @returns {*} Returns the resolved value.
   * @example
   *
   * var object = { 'a': [{ 'b': { 'c': 3 } }] };
   *
   * _.get(object, 'a[0].b.c');
   * // => 3
   *
   * _.get(object, ['a', '0', 'b', 'c']);
   * // => 3
   *
   * _.get(object, 'a.b.c', 'default');
   * // => 'default'
   */
  function get(object, path, defaultValue) {
    var result = object == null ? undefined : baseGet(object, path);
    return result === undefined ? defaultValue : result;
  }
  
  module.exports = get;
  
  },{"./_baseGet":54}],229:[function(require,module,exports){
  var baseHasIn = require('./_baseHasIn'),
      hasPath = require('./_hasPath');
  
  /**
   * Checks if `path` is a direct or inherited property of `object`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Object
   * @param {Object} object The object to query.
   * @param {Array|string} path The path to check.
   * @returns {boolean} Returns `true` if `path` exists, else `false`.
   * @example
   *
   * var object = _.create({ 'a': _.create({ 'b': 2 }) });
   *
   * _.hasIn(object, 'a');
   * // => true
   *
   * _.hasIn(object, 'a.b');
   * // => true
   *
   * _.hasIn(object, ['a', 'b']);
   * // => true
   *
   * _.hasIn(object, 'b');
   * // => false
   */
  function hasIn(object, path) {
    return object != null && hasPath(object, path, baseHasIn);
  }
  
  module.exports = hasIn;
  
  },{"./_baseHasIn":57,"./_hasPath":134}],230:[function(require,module,exports){
  /**
   * This method returns the first argument it receives.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Util
   * @param {*} value Any value.
   * @returns {*} Returns `value`.
   * @example
   *
   * var object = { 'a': 1 };
   *
   * console.log(_.identity(object) === object);
   * // => true
   */
  function identity(value) {
    return value;
  }
  
  module.exports = identity;
  
  },{}],231:[function(require,module,exports){
  var baseIsArguments = require('./_baseIsArguments'),
      isObjectLike = require('./isObjectLike');
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /** Built-in value references. */
  var propertyIsEnumerable = objectProto.propertyIsEnumerable;
  
  /**
   * Checks if `value` is likely an `arguments` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an `arguments` object,
   *  else `false`.
   * @example
   *
   * _.isArguments(function() { return arguments; }());
   * // => true
   *
   * _.isArguments([1, 2, 3]);
   * // => false
   */
  var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
    return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
      !propertyIsEnumerable.call(value, 'callee');
  };
  
  module.exports = isArguments;
  
  },{"./_baseIsArguments":59,"./isObjectLike":239}],232:[function(require,module,exports){
  /**
   * Checks if `value` is classified as an `Array` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an array, else `false`.
   * @example
   *
   * _.isArray([1, 2, 3]);
   * // => true
   *
   * _.isArray(document.body.children);
   * // => false
   *
   * _.isArray('abc');
   * // => false
   *
   * _.isArray(_.noop);
   * // => false
   */
  var isArray = Array.isArray;
  
  module.exports = isArray;
  
  },{}],233:[function(require,module,exports){
  var isFunction = require('./isFunction'),
      isLength = require('./isLength');
  
  /**
   * Checks if `value` is array-like. A value is considered array-like if it's
   * not a function and has a `value.length` that's an integer greater than or
   * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
   * @example
   *
   * _.isArrayLike([1, 2, 3]);
   * // => true
   *
   * _.isArrayLike(document.body.children);
   * // => true
   *
   * _.isArrayLike('abc');
   * // => true
   *
   * _.isArrayLike(_.noop);
   * // => false
   */
  function isArrayLike(value) {
    return value != null && isLength(value.length) && !isFunction(value);
  }
  
  module.exports = isArrayLike;
  
  },{"./isFunction":235,"./isLength":236}],234:[function(require,module,exports){
  var root = require('./_root'),
      stubFalse = require('./stubFalse');
  
  /** Detect free variable `exports`. */
  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
  
  /** Detect free variable `module`. */
  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
  
  /** Detect the popular CommonJS extension `module.exports`. */
  var moduleExports = freeModule && freeModule.exports === freeExports;
  
  /** Built-in value references. */
  var Buffer = moduleExports ? root.Buffer : undefined;
  
  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
  
  /**
   * Checks if `value` is a buffer.
   *
   * @static
   * @memberOf _
   * @since 4.3.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
   * @example
   *
   * _.isBuffer(new Buffer(2));
   * // => true
   *
   * _.isBuffer(new Uint8Array(2));
   * // => false
   */
  var isBuffer = nativeIsBuffer || stubFalse;
  
  module.exports = isBuffer;
  
  },{"./_root":178,"./stubFalse":255}],235:[function(require,module,exports){
  var baseGetTag = require('./_baseGetTag'),
      isObject = require('./isObject');
  
  /** `Object#toString` result references. */
  var asyncTag = '[object AsyncFunction]',
      funcTag = '[object Function]',
      genTag = '[object GeneratorFunction]',
      proxyTag = '[object Proxy]';
  
  /**
   * Checks if `value` is classified as a `Function` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a function, else `false`.
   * @example
   *
   * _.isFunction(_);
   * // => true
   *
   * _.isFunction(/abc/);
   * // => false
   */
  function isFunction(value) {
    if (!isObject(value)) {
      return false;
    }
    // The use of `Object#toString` avoids issues with the `typeof` operator
    // in Safari 9 which returns 'object' for typed arrays and other constructors.
    var tag = baseGetTag(value);
    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
  }
  
  module.exports = isFunction;
  
  },{"./_baseGetTag":56,"./isObject":238}],236:[function(require,module,exports){
  /** Used as references for various `Number` constants. */
  var MAX_SAFE_INTEGER = 9007199254740991;
  
  /**
   * Checks if `value` is a valid array-like length.
   *
   * **Note:** This method is loosely based on
   * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
   * @example
   *
   * _.isLength(3);
   * // => true
   *
   * _.isLength(Number.MIN_VALUE);
   * // => false
   *
   * _.isLength(Infinity);
   * // => false
   *
   * _.isLength('3');
   * // => false
   */
  function isLength(value) {
    return typeof value == 'number' &&
      value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
  }
  
  module.exports = isLength;
  
  },{}],237:[function(require,module,exports){
  /**
   * Checks if `value` is `null`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is `null`, else `false`.
   * @example
   *
   * _.isNull(null);
   * // => true
   *
   * _.isNull(void 0);
   * // => false
   */
  function isNull(value) {
    return value === null;
  }
  
  module.exports = isNull;
  
  },{}],238:[function(require,module,exports){
  /**
   * Checks if `value` is the
   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
   * @example
   *
   * _.isObject({});
   * // => true
   *
   * _.isObject([1, 2, 3]);
   * // => true
   *
   * _.isObject(_.noop);
   * // => true
   *
   * _.isObject(null);
   * // => false
   */
  function isObject(value) {
    var type = typeof value;
    return value != null && (type == 'object' || type == 'function');
  }
  
  module.exports = isObject;
  
  },{}],239:[function(require,module,exports){
  /**
   * Checks if `value` is object-like. A value is object-like if it's not `null`
   * and has a `typeof` result of "object".
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
   * @example
   *
   * _.isObjectLike({});
   * // => true
   *
   * _.isObjectLike([1, 2, 3]);
   * // => true
   *
   * _.isObjectLike(_.noop);
   * // => false
   *
   * _.isObjectLike(null);
   * // => false
   */
  function isObjectLike(value) {
    return value != null && typeof value == 'object';
  }
  
  module.exports = isObjectLike;
  
  },{}],240:[function(require,module,exports){
  var baseGetTag = require('./_baseGetTag'),
      getPrototype = require('./_getPrototype'),
      isObjectLike = require('./isObjectLike');
  
  /** `Object#toString` result references. */
  var objectTag = '[object Object]';
  
  /** Used for built-in method references. */
  var funcProto = Function.prototype,
      objectProto = Object.prototype;
  
  /** Used to resolve the decompiled source of functions. */
  var funcToString = funcProto.toString;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /** Used to infer the `Object` constructor. */
  var objectCtorString = funcToString.call(Object);
  
  /**
   * Checks if `value` is a plain object, that is, an object created by the
   * `Object` constructor or one with a `[[Prototype]]` of `null`.
   *
   * @static
   * @memberOf _
   * @since 0.8.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   * }
   *
   * _.isPlainObject(new Foo);
   * // => false
   *
   * _.isPlainObject([1, 2, 3]);
   * // => false
   *
   * _.isPlainObject({ 'x': 0, 'y': 0 });
   * // => true
   *
   * _.isPlainObject(Object.create(null));
   * // => true
   */
  function isPlainObject(value) {
    if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
      return false;
    }
    var proto = getPrototype(value);
    if (proto === null) {
      return true;
    }
    var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
    return typeof Ctor == 'function' && Ctor instanceof Ctor &&
      funcToString.call(Ctor) == objectCtorString;
  }
  
  module.exports = isPlainObject;
  
  },{"./_baseGetTag":56,"./_getPrototype":127,"./isObjectLike":239}],241:[function(require,module,exports){
  var baseGetTag = require('./_baseGetTag'),
      isObjectLike = require('./isObjectLike');
  
  /** `Object#toString` result references. */
  var symbolTag = '[object Symbol]';
  
  /**
   * Checks if `value` is classified as a `Symbol` primitive or object.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
   * @example
   *
   * _.isSymbol(Symbol.iterator);
   * // => true
   *
   * _.isSymbol('abc');
   * // => false
   */
  function isSymbol(value) {
    return typeof value == 'symbol' ||
      (isObjectLike(value) && baseGetTag(value) == symbolTag);
  }
  
  module.exports = isSymbol;
  
  },{"./_baseGetTag":56,"./isObjectLike":239}],242:[function(require,module,exports){
  var baseIsTypedArray = require('./_baseIsTypedArray'),
      baseUnary = require('./_baseUnary'),
      nodeUtil = require('./_nodeUtil');
  
  /* Node.js helper references. */
  var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
  
  /**
   * Checks if `value` is classified as a typed array.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
   * @example
   *
   * _.isTypedArray(new Uint8Array);
   * // => true
   *
   * _.isTypedArray([]);
   * // => false
   */
  var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
  
  module.exports = isTypedArray;
  
  },{"./_baseIsTypedArray":65,"./_baseUnary":82,"./_nodeUtil":171}],243:[function(require,module,exports){
  /**
   * Checks if `value` is `undefined`.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
   * @example
   *
   * _.isUndefined(void 0);
   * // => true
   *
   * _.isUndefined(null);
   * // => false
   */
  function isUndefined(value) {
    return value === undefined;
  }
  
  module.exports = isUndefined;
  
  },{}],244:[function(require,module,exports){
  var baseClone = require('./_baseClone'),
      baseIteratee = require('./_baseIteratee');
  
  /** Used to compose bitmasks for cloning. */
  var CLONE_DEEP_FLAG = 1;
  
  /**
   * Creates a function that invokes `func` with the arguments of the created
   * function. If `func` is a property name, the created function returns the
   * property value for a given element. If `func` is an array or object, the
   * created function returns `true` for elements that contain the equivalent
   * source properties, otherwise it returns `false`.
   *
   * @static
   * @since 4.0.0
   * @memberOf _
   * @category Util
   * @param {*} [func=_.identity] The value to convert to a callback.
   * @returns {Function} Returns the callback.
   * @example
   *
   * var users = [
   *   { 'user': 'barney', 'age': 36, 'active': true },
   *   { 'user': 'fred',   'age': 40, 'active': false }
   * ];
   *
   * // The `_.matches` iteratee shorthand.
   * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
   * // => [{ 'user': 'barney', 'age': 36, 'active': true }]
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.filter(users, _.iteratee(['user', 'fred']));
   * // => [{ 'user': 'fred', 'age': 40 }]
   *
   * // The `_.property` iteratee shorthand.
   * _.map(users, _.iteratee('user'));
   * // => ['barney', 'fred']
   *
   * // Create custom iteratee shorthands.
   * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
   *   return !_.isRegExp(func) ? iteratee(func) : function(string) {
   *     return func.test(string);
   *   };
   * });
   *
   * _.filter(['abc', 'def'], /ef/);
   * // => ['def']
   */
  function iteratee(func) {
    return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));
  }
  
  module.exports = iteratee;
  
  },{"./_baseClone":47,"./_baseIteratee":66}],245:[function(require,module,exports){
  var arrayLikeKeys = require('./_arrayLikeKeys'),
      baseKeys = require('./_baseKeys'),
      isArrayLike = require('./isArrayLike');
  
  /**
   * Creates an array of the own enumerable property names of `object`.
   *
   * **Note:** Non-object values are coerced to objects. See the
   * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
   * for more details.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Object
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.keys(new Foo);
   * // => ['a', 'b'] (iteration order is not guaranteed)
   *
   * _.keys('hi');
   * // => ['0', '1']
   */
  function keys(object) {
    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
  }
  
  module.exports = keys;
  
  },{"./_arrayLikeKeys":37,"./_baseKeys":67,"./isArrayLike":233}],246:[function(require,module,exports){
  var arrayLikeKeys = require('./_arrayLikeKeys'),
      baseKeysIn = require('./_baseKeysIn'),
      isArrayLike = require('./isArrayLike');
  
  /**
   * Creates an array of the own and inherited enumerable property names of `object`.
   *
   * **Note:** Non-object values are coerced to objects.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Object
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.keysIn(new Foo);
   * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
   */
  function keysIn(object) {
    return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
  }
  
  module.exports = keysIn;
  
  },{"./_arrayLikeKeys":37,"./_baseKeysIn":68,"./isArrayLike":233}],247:[function(require,module,exports){
  var baseAssignValue = require('./_baseAssignValue'),
      baseForOwn = require('./_baseForOwn'),
      baseIteratee = require('./_baseIteratee');
  
  /**
   * The opposite of `_.mapValues`; this method creates an object with the
   * same values as `object` and keys generated by running each own enumerable
   * string keyed property of `object` thru `iteratee`. The iteratee is invoked
   * with three arguments: (value, key, object).
   *
   * @static
   * @memberOf _
   * @since 3.8.0
   * @category Object
   * @param {Object} object The object to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Object} Returns the new mapped object.
   * @see _.mapValues
   * @example
   *
   * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
   *   return key + value;
   * });
   * // => { 'a1': 1, 'b2': 2 }
   */
  function mapKeys(object, iteratee) {
    var result = {};
    iteratee = baseIteratee(iteratee, 3);
  
    baseForOwn(object, function(value, key, object) {
      baseAssignValue(result, iteratee(value, key, object), value);
    });
    return result;
  }
  
  module.exports = mapKeys;
  
  },{"./_baseAssignValue":46,"./_baseForOwn":53,"./_baseIteratee":66}],248:[function(require,module,exports){
  var baseAssignValue = require('./_baseAssignValue'),
      baseForOwn = require('./_baseForOwn'),
      baseIteratee = require('./_baseIteratee');
  
  /**
   * Creates an object with the same keys as `object` and values generated
   * by running each own enumerable string keyed property of `object` thru
   * `iteratee`. The iteratee is invoked with three arguments:
   * (value, key, object).
   *
   * @static
   * @memberOf _
   * @since 2.4.0
   * @category Object
   * @param {Object} object The object to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Object} Returns the new mapped object.
   * @see _.mapKeys
   * @example
   *
   * var users = {
   *   'fred':    { 'user': 'fred',    'age': 40 },
   *   'pebbles': { 'user': 'pebbles', 'age': 1 }
   * };
   *
   * _.mapValues(users, function(o) { return o.age; });
   * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
   *
   * // The `_.property` iteratee shorthand.
   * _.mapValues(users, 'age');
   * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
   */
  function mapValues(object, iteratee) {
    var result = {};
    iteratee = baseIteratee(iteratee, 3);
  
    baseForOwn(object, function(value, key, object) {
      baseAssignValue(result, key, iteratee(value, key, object));
    });
    return result;
  }
  
  module.exports = mapValues;
  
  },{"./_baseAssignValue":46,"./_baseForOwn":53,"./_baseIteratee":66}],249:[function(require,module,exports){
  var MapCache = require('./_MapCache');
  
  /** Error message constants. */
  var FUNC_ERROR_TEXT = 'Expected a function';
  
  /**
   * Creates a function that memoizes the result of `func`. If `resolver` is
   * provided, it determines the cache key for storing the result based on the
   * arguments provided to the memoized function. By default, the first argument
   * provided to the memoized function is used as the map cache key. The `func`
   * is invoked with the `this` binding of the memoized function.
   *
   * **Note:** The cache is exposed as the `cache` property on the memoized
   * function. Its creation may be customized by replacing the `_.memoize.Cache`
   * constructor with one whose instances implement the
   * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
   * method interface of `clear`, `delete`, `get`, `has`, and `set`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Function
   * @param {Function} func The function to have its output memoized.
   * @param {Function} [resolver] The function to resolve the cache key.
   * @returns {Function} Returns the new memoized function.
   * @example
   *
   * var object = { 'a': 1, 'b': 2 };
   * var other = { 'c': 3, 'd': 4 };
   *
   * var values = _.memoize(_.values);
   * values(object);
   * // => [1, 2]
   *
   * values(other);
   * // => [3, 4]
   *
   * object.a = 2;
   * values(object);
   * // => [1, 2]
   *
   * // Modify the result cache.
   * values.cache.set(object, ['a', 'b']);
   * values(object);
   * // => ['a', 'b']
   *
   * // Replace `_.memoize.Cache`.
   * _.memoize.Cache = WeakMap;
   */
  function memoize(func, resolver) {
    if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    var memoized = function() {
      var args = arguments,
          key = resolver ? resolver.apply(this, args) : args[0],
          cache = memoized.cache;
  
      if (cache.has(key)) {
        return cache.get(key);
      }
      var result = func.apply(this, args);
      memoized.cache = cache.set(key, result) || cache;
      return result;
    };
    memoized.cache = new (memoize.Cache || MapCache);
    return memoized;
  }
  
  // Expose `MapCache`.
  memoize.Cache = MapCache;
  
  module.exports = memoize;
  
  },{"./_MapCache":23}],250:[function(require,module,exports){
  /**
   * This method returns `undefined`.
   *
   * @static
   * @memberOf _
   * @since 2.3.0
   * @category Util
   * @example
   *
   * _.times(2, _.noop);
   * // => [undefined, undefined]
   */
  function noop() {
    // No operation performed.
  }
  
  module.exports = noop;
  
  },{}],251:[function(require,module,exports){
  var basePick = require('./_basePick'),
      flatRest = require('./_flatRest');
  
  /**
   * Creates an object composed of the picked `object` properties.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Object
   * @param {Object} object The source object.
   * @param {...(string|string[])} [paths] The property paths to pick.
   * @returns {Object} Returns the new object.
   * @example
   *
   * var object = { 'a': 1, 'b': '2', 'c': 3 };
   *
   * _.pick(object, ['a', 'c']);
   * // => { 'a': 1, 'c': 3 }
   */
  var pick = flatRest(function(object, paths) {
    return object == null ? {} : basePick(object, paths);
  });
  
  module.exports = pick;
  
  },{"./_basePick":72,"./_flatRest":117}],252:[function(require,module,exports){
  var baseProperty = require('./_baseProperty'),
      basePropertyDeep = require('./_basePropertyDeep'),
      isKey = require('./_isKey'),
      toKey = require('./_toKey');
  
  /**
   * Creates a function that returns the value at `path` of a given object.
   *
   * @static
   * @memberOf _
   * @since 2.4.0
   * @category Util
   * @param {Array|string} path The path of the property to get.
   * @returns {Function} Returns the new accessor function.
   * @example
   *
   * var objects = [
   *   { 'a': { 'b': 2 } },
   *   { 'a': { 'b': 1 } }
   * ];
   *
   * _.map(objects, _.property('a.b'));
   * // => [2, 1]
   *
   * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
   * // => [1, 2]
   */
  function property(path) {
    return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
  }
  
  module.exports = property;
  
  },{"./_baseProperty":74,"./_basePropertyDeep":75,"./_isKey":147,"./_toKey":193}],253:[function(require,module,exports){
  var createWrap = require('./_createWrap'),
      flatRest = require('./_flatRest');
  
  /** Used to compose bitmasks for function metadata. */
  var WRAP_REARG_FLAG = 256;
  
  /**
   * Creates a function that invokes `func` with arguments arranged according
   * to the specified `indexes` where the argument value at the first index is
   * provided as the first argument, the argument value at the second index is
   * provided as the second argument, and so on.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Function
   * @param {Function} func The function to rearrange arguments for.
   * @param {...(number|number[])} indexes The arranged argument indexes.
   * @returns {Function} Returns the new function.
   * @example
   *
   * var rearged = _.rearg(function(a, b, c) {
   *   return [a, b, c];
   * }, [2, 0, 1]);
   *
   * rearged('b', 'c', 'a')
   * // => ['a', 'b', 'c']
   */
  var rearg = flatRest(function(func, indexes) {
    return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);
  });
  
  module.exports = rearg;
  
  },{"./_createWrap":112,"./_flatRest":117}],254:[function(require,module,exports){
  /**
   * This method returns a new empty array.
   *
   * @static
   * @memberOf _
   * @since 4.13.0
   * @category Util
   * @returns {Array} Returns the new empty array.
   * @example
   *
   * var arrays = _.times(2, _.stubArray);
   *
   * console.log(arrays);
   * // => [[], []]
   *
   * console.log(arrays[0] === arrays[1]);
   * // => false
   */
  function stubArray() {
    return [];
  }
  
  module.exports = stubArray;
  
  },{}],255:[function(require,module,exports){
  /**
   * This method returns `false`.
   *
   * @static
   * @memberOf _
   * @since 4.13.0
   * @category Util
   * @returns {boolean} Returns `false`.
   * @example
   *
   * _.times(2, _.stubFalse);
   * // => [false, false]
   */
  function stubFalse() {
    return false;
  }
  
  module.exports = stubFalse;
  
  },{}],256:[function(require,module,exports){
  var toNumber = require('./toNumber');
  
  /** Used as references for various `Number` constants. */
  var INFINITY = 1 / 0,
      MAX_INTEGER = 1.7976931348623157e+308;
  
  /**
   * Converts `value` to a finite number.
   *
   * @static
   * @memberOf _
   * @since 4.12.0
   * @category Lang
   * @param {*} value The value to convert.
   * @returns {number} Returns the converted number.
   * @example
   *
   * _.toFinite(3.2);
   * // => 3.2
   *
   * _.toFinite(Number.MIN_VALUE);
   * // => 5e-324
   *
   * _.toFinite(Infinity);
   * // => 1.7976931348623157e+308
   *
   * _.toFinite('3.2');
   * // => 3.2
   */
  function toFinite(value) {
    if (!value) {
      return value === 0 ? value : 0;
    }
    value = toNumber(value);
    if (value === INFINITY || value === -INFINITY) {
      var sign = (value < 0 ? -1 : 1);
      return sign * MAX_INTEGER;
    }
    return value === value ? value : 0;
  }
  
  module.exports = toFinite;
  
  },{"./toNumber":258}],257:[function(require,module,exports){
  var toFinite = require('./toFinite');
  
  /**
   * Converts `value` to an integer.
   *
   * **Note:** This method is loosely based on
   * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to convert.
   * @returns {number} Returns the converted integer.
   * @example
   *
   * _.toInteger(3.2);
   * // => 3
   *
   * _.toInteger(Number.MIN_VALUE);
   * // => 0
   *
   * _.toInteger(Infinity);
   * // => 1.7976931348623157e+308
   *
   * _.toInteger('3.2');
   * // => 3
   */
  function toInteger(value) {
    var result = toFinite(value),
        remainder = result % 1;
  
    return result === result ? (remainder ? result - remainder : result) : 0;
  }
  
  module.exports = toInteger;
  
  },{"./toFinite":256}],258:[function(require,module,exports){
  var isObject = require('./isObject'),
      isSymbol = require('./isSymbol');
  
  /** Used as references for various `Number` constants. */
  var NAN = 0 / 0;
  
  /** Used to match leading and trailing whitespace. */
  var reTrim = /^\s+|\s+$/g;
  
  /** Used to detect bad signed hexadecimal string values. */
  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
  
  /** Used to detect binary string values. */
  var reIsBinary = /^0b[01]+$/i;
  
  /** Used to detect octal string values. */
  var reIsOctal = /^0o[0-7]+$/i;
  
  /** Built-in method references without a dependency on `root`. */
  var freeParseInt = parseInt;
  
  /**
   * Converts `value` to a number.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to process.
   * @returns {number} Returns the number.
   * @example
   *
   * _.toNumber(3.2);
   * // => 3.2
   *
   * _.toNumber(Number.MIN_VALUE);
   * // => 5e-324
   *
   * _.toNumber(Infinity);
   * // => Infinity
   *
   * _.toNumber('3.2');
   * // => 3.2
   */
  function toNumber(value) {
    if (typeof value == 'number') {
      return value;
    }
    if (isSymbol(value)) {
      return NAN;
    }
    if (isObject(value)) {
      var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
      value = isObject(other) ? (other + '') : other;
    }
    if (typeof value != 'string') {
      return value === 0 ? value : +value;
    }
    value = value.replace(reTrim, '');
    var isBinary = reIsBinary.test(value);
    return (isBinary || reIsOctal.test(value))
      ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
      : (reIsBadHex.test(value) ? NAN : +value);
  }
  
  module.exports = toNumber;
  
  },{"./isObject":238,"./isSymbol":241}],259:[function(require,module,exports){
  var arrayMap = require('./_arrayMap'),
      copyArray = require('./_copyArray'),
      isArray = require('./isArray'),
      isSymbol = require('./isSymbol'),
      stringToPath = require('./_stringToPath'),
      toKey = require('./_toKey'),
      toString = require('./toString');
  
  /**
   * Converts `value` to a property path array.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Util
   * @param {*} value The value to convert.
   * @returns {Array} Returns the new property path array.
   * @example
   *
   * _.toPath('a.b.c');
   * // => ['a', 'b', 'c']
   *
   * _.toPath('a[0].b.c');
   * // => ['a', '0', 'b', 'c']
   */
  function toPath(value) {
    if (isArray(value)) {
      return arrayMap(value, toKey);
    }
    return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));
  }
  
  module.exports = toPath;
  
  },{"./_arrayMap":38,"./_copyArray":96,"./_stringToPath":192,"./_toKey":193,"./isArray":232,"./isSymbol":241,"./toString":260}],260:[function(require,module,exports){
  var baseToString = require('./_baseToString');
  
  /**
   * Converts `value` to a string. An empty string is returned for `null`
   * and `undefined` values. The sign of `-0` is preserved.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to convert.
   * @returns {string} Returns the converted string.
   * @example
   *
   * _.toString(null);
   * // => ''
   *
   * _.toString(-0);
   * // => '-0'
   *
   * _.toString([1, 2, 3]);
   * // => '1,2,3'
   */
  function toString(value) {
    return value == null ? '' : baseToString(value);
  }
  
  module.exports = toString;
  
  },{"./_baseToString":81}],261:[function(require,module,exports){
  var arrayEach = require('./_arrayEach'),
      baseCreate = require('./_baseCreate'),
      baseForOwn = require('./_baseForOwn'),
      baseIteratee = require('./_baseIteratee'),
      getPrototype = require('./_getPrototype'),
      isArray = require('./isArray'),
      isBuffer = require('./isBuffer'),
      isFunction = require('./isFunction'),
      isObject = require('./isObject'),
      isTypedArray = require('./isTypedArray');
  
  /**
   * An alternative to `_.reduce`; this method transforms `object` to a new
   * `accumulator` object which is the result of running each of its own
   * enumerable string keyed properties thru `iteratee`, with each invocation
   * potentially mutating the `accumulator` object. If `accumulator` is not
   * provided, a new object with the same `[[Prototype]]` will be used. The
   * iteratee is invoked with four arguments: (accumulator, value, key, object).
   * Iteratee functions may exit iteration early by explicitly returning `false`.
   *
   * @static
   * @memberOf _
   * @since 1.3.0
   * @category Object
   * @param {Object} object The object to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @param {*} [accumulator] The custom accumulator value.
   * @returns {*} Returns the accumulated value.
   * @example
   *
   * _.transform([2, 3, 4], function(result, n) {
   *   result.push(n *= n);
   *   return n % 2 == 0;
   * }, []);
   * // => [4, 9]
   *
   * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
   *   (result[value] || (result[value] = [])).push(key);
   * }, {});
   * // => { '1': ['a', 'c'], '2': ['b'] }
   */
  function transform(object, iteratee, accumulator) {
    var isArr = isArray(object),
        isArrLike = isArr || isBuffer(object) || isTypedArray(object);
  
    iteratee = baseIteratee(iteratee, 4);
    if (accumulator == null) {
      var Ctor = object && object.constructor;
      if (isArrLike) {
        accumulator = isArr ? new Ctor : [];
      }
      else if (isObject(object)) {
        accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};
      }
      else {
        accumulator = {};
      }
    }
    (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {
      return iteratee(accumulator, value, index, object);
    });
    return accumulator;
  }
  
  module.exports = transform;
  
  },{"./_arrayEach":34,"./_baseCreate":48,"./_baseForOwn":53,"./_baseIteratee":66,"./_getPrototype":127,"./isArray":232,"./isBuffer":234,"./isFunction":235,"./isObject":238,"./isTypedArray":242}],262:[function(require,module,exports){
  var LazyWrapper = require('./_LazyWrapper'),
      LodashWrapper = require('./_LodashWrapper'),
      baseLodash = require('./_baseLodash'),
      isArray = require('./isArray'),
      isObjectLike = require('./isObjectLike'),
      wrapperClone = require('./_wrapperClone');
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * Creates a `lodash` object which wraps `value` to enable implicit method
   * chain sequences. Methods that operate on and return arrays, collections,
   * and functions can be chained together. Methods that retrieve a single value
   * or may return a primitive value will automatically end the chain sequence
   * and return the unwrapped value. Otherwise, the value must be unwrapped
   * with `_#value`.
   *
   * Explicit chain sequences, which must be unwrapped with `_#value`, may be
   * enabled using `_.chain`.
   *
   * The execution of chained methods is lazy, that is, it's deferred until
   * `_#value` is implicitly or explicitly called.
   *
   * Lazy evaluation allows several methods to support shortcut fusion.
   * Shortcut fusion is an optimization to merge iteratee calls; this avoids
   * the creation of intermediate arrays and can greatly reduce the number of
   * iteratee executions. Sections of a chain sequence qualify for shortcut
   * fusion if the section is applied to an array and iteratees accept only
   * one argument. The heuristic for whether a section qualifies for shortcut
   * fusion is subject to change.
   *
   * Chaining is supported in custom builds as long as the `_#value` method is
   * directly or indirectly included in the build.
   *
   * In addition to lodash methods, wrappers have `Array` and `String` methods.
   *
   * The wrapper `Array` methods are:
   * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`
   *
   * The wrapper `String` methods are:
   * `replace` and `split`
   *
   * The wrapper methods that support shortcut fusion are:
   * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,
   * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,
   * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`
   *
   * The chainable wrapper methods are:
   * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,
   * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,
   * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,
   * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,
   * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,
   * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,
   * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,
   * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,
   * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,
   * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,
   * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,
   * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,
   * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,
   * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,
   * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,
   * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,
   * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,
   * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,
   * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,
   * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,
   * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,
   * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,
   * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,
   * `zipObject`, `zipObjectDeep`, and `zipWith`
   *
   * The wrapper methods that are **not** chainable by default are:
   * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,
   * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,
   * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,
   * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,
   * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,
   * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,
   * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,
   * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,
   * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,
   * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,
   * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,
   * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,
   * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,
   * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,
   * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,
   * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,
   * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,
   * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
   * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,
   * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,
   * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,
   * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,
   * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,
   * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,
   * `upperFirst`, `value`, and `words`
   *
   * @name _
   * @constructor
   * @category Seq
   * @param {*} value The value to wrap in a `lodash` instance.
   * @returns {Object} Returns the new `lodash` wrapper instance.
   * @example
   *
   * function square(n) {
   *   return n * n;
   * }
   *
   * var wrapped = _([1, 2, 3]);
   *
   * // Returns an unwrapped value.
   * wrapped.reduce(_.add);
   * // => 6
   *
   * // Returns a wrapped value.
   * var squares = wrapped.map(square);
   *
   * _.isArray(squares);
   * // => false
   *
   * _.isArray(squares.value());
   * // => true
   */
  function lodash(value) {
    if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
      if (value instanceof LodashWrapper) {
        return value;
      }
      if (hasOwnProperty.call(value, '__wrapped__')) {
        return wrapperClone(value);
      }
    }
    return new LodashWrapper(value);
  }
  
  // Ensure wrappers are instances of `baseLodash`.
  lodash.prototype = baseLodash.prototype;
  lodash.prototype.constructor = lodash;
  
  module.exports = lodash;
  
  },{"./_LazyWrapper":19,"./_LodashWrapper":21,"./_baseLodash":69,"./_wrapperClone":196,"./isArray":232,"./isObjectLike":239}],263:[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 defaultSetTimout() {
      throw new Error('setTimeout has not been defined');
  }
  function defaultClearTimeout () {
      throw new Error('clearTimeout has not been defined');
  }
  (function () {
      try {
          if (typeof setTimeout === 'function') {
              cachedSetTimeout = setTimeout;
          } else {
              cachedSetTimeout = defaultSetTimout;
          }
      } catch (e) {
          cachedSetTimeout = defaultSetTimout;
      }
      try {
          if (typeof clearTimeout === 'function') {
              cachedClearTimeout = clearTimeout;
          } else {
              cachedClearTimeout = defaultClearTimeout;
          }
      } catch (e) {
          cachedClearTimeout = defaultClearTimeout;
      }
  } ())
  function runTimeout(fun) {
      if (cachedSetTimeout === setTimeout) {
          //normal enviroments in sane situations
          return setTimeout(fun, 0);
      }
      // if setTimeout wasn't available but was latter defined
      if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
          cachedSetTimeout = setTimeout;
          return setTimeout(fun, 0);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedSetTimeout(fun, 0);
      } catch(e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
              return cachedSetTimeout.call(null, fun, 0);
          } catch(e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
              return cachedSetTimeout.call(this, fun, 0);
          }
      }
  
  
  }
  function runClearTimeout(marker) {
      if (cachedClearTimeout === clearTimeout) {
          //normal enviroments in sane situations
          return clearTimeout(marker);
      }
      // if clearTimeout wasn't available but was latter defined
      if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
          cachedClearTimeout = clearTimeout;
          return clearTimeout(marker);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedClearTimeout(marker);
      } catch (e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
              return cachedClearTimeout.call(null, marker);
          } catch (e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
              // Some versions of I.E. have different rules for clearTimeout vs setTimeout
              return cachedClearTimeout.call(this, marker);
          }
      }
  
  
  
  }
  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 = runTimeout(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;
      runClearTimeout(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) {
          runTimeout(drainQueue);
      }
  };
  
  // 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; };
  
  },{}],"jsonapi-serializer":[function(require,module,exports){
  module.exports = {
    Serializer: require('./lib/serializer'),
    Deserializer: require('./lib/deserializer'),
  };
  
  },{"./lib/deserializer":2,"./lib/serializer":5}]},{},["jsonapi-serializer"]);
  