text: /*!
   * autocomplete.js 0.4.0
   * https://github.com/algolia/autocomplete.js
   * Copyright 2015 Algolia, Inc. and other contributors; Licensed MIT
   */
  
  
  (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';
  
  module.exports = require('./src/jquery/plugin.js');
  
  },{"./src/jquery/plugin.js":107}],2:[function(require,module,exports){
  /**
   * Gets the last element of `array`.
   *
   * @static
   * @memberOf _
   * @category Array
   * @param {Array} array The array to query.
   * @returns {*} Returns the last element of `array`.
   * @example
   *
   * _.last([1, 2, 3]);
   * // => 3
   */
  function last(array) {
    var length = array ? array.length : 0;
    return length ? array[length - 1] : undefined;
  }
  
  module.exports = last;
  
  },{}],3:[function(require,module,exports){
  var LazyWrapper = require('../internal/LazyWrapper'),
      LodashWrapper = require('../internal/LodashWrapper'),
      baseLodash = require('../internal/baseLodash'),
      isArray = require('../lang/isArray'),
      isObjectLike = require('../internal/isObjectLike'),
      wrapperClone = require('../internal/wrapperClone');
  
  /** Used for native 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 chaining.
   * 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 returning the unwrapped
   * value. Explicit chaining may be enabled using `_.chain`. The execution of
   * chained methods is lazy, that is, execution is deferred until `_#value`
   * is implicitly or explicitly called.
   *
   * Lazy evaluation allows several methods to support shortcut fusion. Shortcut
   * fusion is an optimization strategy which merge iteratee calls; this can help
   * to avoid the creation of intermediate data structures and greatly reduce the
   * number of iteratee executions.
   *
   * 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`, `reverse`, `shift`, `slice`, `sort`,
   * `splice`, and `unshift`
   *
   * The wrapper `String` methods are:
   * `replace` and `split`
   *
   * The wrapper methods that support shortcut fusion are:
   * `compact`, `drop`, `dropRight`, `dropRightWhile`, `dropWhile`, `filter`,
   * `first`, `initial`, `last`, `map`, `pluck`, `reject`, `rest`, `reverse`,
   * `slice`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, `toArray`,
   * and `where`
   *
   * The chainable wrapper methods are:
   * `after`, `ary`, `assign`, `at`, `before`, `bind`, `bindAll`, `bindKey`,
   * `callback`, `chain`, `chunk`, `commit`, `compact`, `concat`, `constant`,
   * `countBy`, `create`, `curry`, `debounce`, `defaults`, `defaultsDeep`,
   * `defer`, `delay`, `difference`, `drop`, `dropRight`, `dropRightWhile`,
   * `dropWhile`, `fill`, `filter`, `flatten`, `flattenDeep`, `flow`, `flowRight`,
   * `forEach`, `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`,
   * `functions`, `groupBy`, `indexBy`, `initial`, `intersection`, `invert`,
   * `invoke`, `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`,
   * `matchesProperty`, `memoize`, `merge`, `method`, `methodOf`, `mixin`,
   * `modArgs`, `negate`, `omit`, `once`, `pairs`, `partial`, `partialRight`,
   * `partition`, `pick`, `plant`, `pluck`, `property`, `propertyOf`, `pull`,
   * `pullAt`, `push`, `range`, `rearg`, `reject`, `remove`, `rest`, `restParam`,
   * `reverse`, `set`, `shuffle`, `slice`, `sort`, `sortBy`, `sortByAll`,
   * `sortByOrder`, `splice`, `spread`, `take`, `takeRight`, `takeRightWhile`,
   * `takeWhile`, `tap`, `throttle`, `thru`, `times`, `toArray`, `toPlainObject`,
   * `transform`, `union`, `uniq`, `unshift`, `unzip`, `unzipWith`, `values`,
   * `valuesIn`, `where`, `without`, `wrap`, `xor`, `zip`, `zipObject`, `zipWith`
   *
   * The wrapper methods that are **not** chainable by default are:
   * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clone`, `cloneDeep`,
   * `deburr`, `endsWith`, `escape`, `escapeRegExp`, `every`, `find`, `findIndex`,
   * `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `findWhere`, `first`,
   * `floor`, `get`, `gt`, `gte`, `has`, `identity`, `includes`, `indexOf`,
   * `inRange`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`,
   * `isEmpty`, `isEqual`, `isError`, `isFinite` `isFunction`, `isMatch`,
   * `isNative`, `isNaN`, `isNull`, `isNumber`, `isObject`, `isPlainObject`,
   * `isRegExp`, `isString`, `isUndefined`, `isTypedArray`, `join`, `kebabCase`,
   * `last`, `lastIndexOf`, `lt`, `lte`, `max`, `min`, `noConflict`, `noop`,
   * `now`, `pad`, `padLeft`, `padRight`, `parseInt`, `pop`, `random`, `reduce`,
   * `reduceRight`, `repeat`, `result`, `round`, `runInContext`, `shift`, `size`,
   * `snakeCase`, `some`, `sortedIndex`, `sortedLastIndex`, `startCase`,
   * `startsWith`, `sum`, `template`, `trim`, `trimLeft`, `trimRight`, `trunc`,
   * `unescape`, `uniqueId`, `value`, and `words`
   *
   * The wrapper method `sample` will return a wrapped value when `n` is provided,
   * otherwise an unwrapped value is returned.
   *
   * @name _
   * @constructor
   * @category Chain
   * @param {*} value The value to wrap in a `lodash` instance.
   * @returns {Object} Returns the new `lodash` wrapper instance.
   * @example
   *
   * var wrapped = _([1, 2, 3]);
   *
   * // returns an unwrapped value
   * wrapped.reduce(function(total, n) {
   *   return total + n;
   * });
   * // => 6
   *
   * // returns a wrapped value
   * var squares = wrapped.map(function(n) {
   *   return n * n;
   * });
   *
   * _.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, '__chain__') && hasOwnProperty.call(value, '__wrapped__')) {
        return wrapperClone(value);
      }
    }
    return new LodashWrapper(value);
  }
  
  // Ensure wrappers are instances of `baseLodash`.
  lodash.prototype = baseLodash.prototype;
  
  module.exports = lodash;
  
  },{"../internal/LazyWrapper":11,"../internal/LodashWrapper":12,"../internal/baseLodash":34,"../internal/isObjectLike":70,"../internal/wrapperClone":81,"../lang/isArray":83}],4:[function(require,module,exports){
  var arrayEvery = require('../internal/arrayEvery'),
      baseCallback = require('../internal/baseCallback'),
      baseEvery = require('../internal/baseEvery'),
      isArray = require('../lang/isArray'),
      isIterateeCall = require('../internal/isIterateeCall');
  
  /**
   * Checks if `predicate` returns truthy for **all** elements of `collection`.
   * The predicate is bound to `thisArg` and invoked with three arguments:
   * (value, index|key, collection).
   *
   * If a property name is provided for `predicate` the created `_.property`
   * style callback returns the property value of the given element.
   *
   * If a value is also provided for `thisArg` the created `_.matchesProperty`
   * style callback returns `true` for elements that have a matching property
   * value, else `false`.
   *
   * If an object is provided for `predicate` the created `_.matches` style
   * callback returns `true` for elements that have the properties of the given
   * object, else `false`.
   *
   * @static
   * @memberOf _
   * @alias all
   * @category Collection
   * @param {Array|Object|string} collection The collection to iterate over.
   * @param {Function|Object|string} [predicate=_.identity] The function invoked
   *  per iteration.
   * @param {*} [thisArg] The `this` binding of `predicate`.
   * @returns {boolean} Returns `true` if all elements pass the predicate check,
   *  else `false`.
   * @example
   *
   * _.every([true, 1, null, 'yes'], Boolean);
   * // => false
   *
   * var users = [
   *   { 'user': 'barney', 'active': false },
   *   { 'user': 'fred',   'active': false }
   * ];
   *
   * // using the `_.matches` callback shorthand
   * _.every(users, { 'user': 'barney', 'active': false });
   * // => false
   *
   * // using the `_.matchesProperty` callback shorthand
   * _.every(users, 'active', false);
   * // => true
   *
   * // using the `_.property` callback shorthand
   * _.every(users, 'active');
   * // => false
   */
  function every(collection, predicate, thisArg) {
    var func = isArray(collection) ? arrayEvery : baseEvery;
    if (thisArg && isIterateeCall(collection, predicate, thisArg)) {
      predicate = undefined;
    }
    if (typeof predicate != 'function' || thisArg !== undefined) {
      predicate = baseCallback(predicate, thisArg, 3);
    }
    return func(collection, predicate);
  }
  
  module.exports = every;
  
  },{"../internal/arrayEvery":15,"../internal/baseCallback":21,"../internal/baseEvery":25,"../internal/isIterateeCall":66,"../lang/isArray":83}],5:[function(require,module,exports){
  var arrayFilter = require('../internal/arrayFilter'),
      baseCallback = require('../internal/baseCallback'),
      baseFilter = require('../internal/baseFilter'),
      isArray = require('../lang/isArray');
  
  /**
   * Iterates over elements of `collection`, returning an array of all elements
   * `predicate` returns truthy for. The predicate is bound to `thisArg` and
   * invoked with three arguments: (value, index|key, collection).
   *
   * If a property name is provided for `predicate` the created `_.property`
   * style callback returns the property value of the given element.
   *
   * If a value is also provided for `thisArg` the created `_.matchesProperty`
   * style callback returns `true` for elements that have a matching property
   * value, else `false`.
   *
   * If an object is provided for `predicate` the created `_.matches` style
   * callback returns `true` for elements that have the properties of the given
   * object, else `false`.
   *
   * @static
   * @memberOf _
   * @alias select
   * @category Collection
   * @param {Array|Object|string} collection The collection to iterate over.
   * @param {Function|Object|string} [predicate=_.identity] The function invoked
   *  per iteration.
   * @param {*} [thisArg] The `this` binding of `predicate`.
   * @returns {Array} Returns the new filtered array.
   * @example
   *
   * _.filter([4, 5, 6], function(n) {
   *   return n % 2 == 0;
   * });
   * // => [4, 6]
   *
   * var users = [
   *   { 'user': 'barney', 'age': 36, 'active': true },
   *   { 'user': 'fred',   'age': 40, 'active': false }
   * ];
   *
   * // using the `_.matches` callback shorthand
   * _.pluck(_.filter(users, { 'age': 36, 'active': true }), 'user');
   * // => ['barney']
   *
   * // using the `_.matchesProperty` callback shorthand
   * _.pluck(_.filter(users, 'active', false), 'user');
   * // => ['fred']
   *
   * // using the `_.property` callback shorthand
   * _.pluck(_.filter(users, 'active'), 'user');
   * // => ['barney']
   */
  function filter(collection, predicate, thisArg) {
    var func = isArray(collection) ? arrayFilter : baseFilter;
    predicate = baseCallback(predicate, thisArg, 3);
    return func(collection, predicate);
  }
  
  module.exports = filter;
  
  },{"../internal/arrayFilter":16,"../internal/baseCallback":21,"../internal/baseFilter":26,"../lang/isArray":83}],6:[function(require,module,exports){
  var arrayEach = require('../internal/arrayEach'),
      baseEach = require('../internal/baseEach'),
      createForEach = require('../internal/createForEach');
  
  /**
   * Iterates over elements of `collection` invoking `iteratee` for each element.
   * The `iteratee` is bound to `thisArg` and 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 `_.forIn` or `_.forOwn`
   * may be used for object iteration.
   *
   * @static
   * @memberOf _
   * @alias each
   * @category Collection
   * @param {Array|Object|string} collection The collection to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @param {*} [thisArg] The `this` binding of `iteratee`.
   * @returns {Array|Object|string} Returns `collection`.
   * @example
   *
   * _([1, 2]).forEach(function(n) {
   *   console.log(n);
   * }).value();
   * // => logs each value from left to right and returns the array
   *
   * _.forEach({ 'a': 1, 'b': 2 }, function(n, key) {
   *   console.log(n, key);
   * });
   * // => logs each value-key pair and returns the object (iteration order is not guaranteed)
   */
  var forEach = createForEach(arrayEach, baseEach);
  
  module.exports = forEach;
  
  },{"../internal/arrayEach":14,"../internal/baseEach":24,"../internal/createForEach":51}],7:[function(require,module,exports){
  var arrayMap = require('../internal/arrayMap'),
      baseCallback = require('../internal/baseCallback'),
      baseMap = require('../internal/baseMap'),
      isArray = require('../lang/isArray');
  
  /**
   * Creates an array of values by running each element in `collection` through
   * `iteratee`. The `iteratee` is bound to `thisArg` and invoked with three
   * arguments: (value, index|key, collection).
   *
   * If a property name is provided for `iteratee` the created `_.property`
   * style callback returns the property value of the given element.
   *
   * If a value is also provided for `thisArg` the created `_.matchesProperty`
   * style callback returns `true` for elements that have a matching property
   * value, else `false`.
   *
   * If an object is provided for `iteratee` the created `_.matches` style
   * callback returns `true` for elements that have the properties of the given
   * object, else `false`.
   *
   * Many lodash methods are guarded to work as iteratees for methods like
   * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
   *
   * The guarded methods are:
   * `ary`, `callback`, `chunk`, `clone`, `create`, `curry`, `curryRight`,
   * `drop`, `dropRight`, `every`, `fill`, `flatten`, `invert`, `max`, `min`,
   * `parseInt`, `slice`, `sortBy`, `take`, `takeRight`, `template`, `trim`,
   * `trimLeft`, `trimRight`, `trunc`, `random`, `range`, `sample`, `some`,
   * `sum`, `uniq`, and `words`
   *
   * @static
   * @memberOf _
   * @alias collect
   * @category Collection
   * @param {Array|Object|string} collection The collection to iterate over.
   * @param {Function|Object|string} [iteratee=_.identity] The function invoked
   *  per iteration.
   * @param {*} [thisArg] The `this` binding of `iteratee`.
   * @returns {Array} Returns the new mapped array.
   * @example
   *
   * function timesThree(n) {
   *   return n * 3;
   * }
   *
   * _.map([1, 2], timesThree);
   * // => [3, 6]
   *
   * _.map({ 'a': 1, 'b': 2 }, timesThree);
   * // => [3, 6] (iteration order is not guaranteed)
   *
   * var users = [
   *   { 'user': 'barney' },
   *   { 'user': 'fred' }
   * ];
   *
   * // using the `_.property` callback shorthand
   * _.map(users, 'user');
   * // => ['barney', 'fred']
   */
  function map(collection, iteratee, thisArg) {
    var func = isArray(collection) ? arrayMap : baseMap;
    iteratee = baseCallback(iteratee, thisArg, 3);
    return func(collection, iteratee);
  }
  
  module.exports = map;
  
  },{"../internal/arrayMap":17,"../internal/baseCallback":21,"../internal/baseMap":35,"../lang/isArray":83}],8:[function(require,module,exports){
  var getNative = require('../internal/getNative');
  
  /* Native method references for those with the same name as other `lodash` methods. */
  var nativeNow = getNative(Date, 'now');
  
  /**
   * Gets the number of milliseconds that have elapsed since the Unix epoch
   * (1 January 1970 00:00:00 UTC).
   *
   * @static
   * @memberOf _
   * @category Date
   * @example
   *
   * _.defer(function(stamp) {
   *   console.log(_.now() - stamp);
   * }, _.now());
   * // => logs the number of milliseconds it took for the deferred function to be invoked
   */
  var now = nativeNow || function() {
    return new Date().getTime();
  };
  
  module.exports = now;
  
  },{"../internal/getNative":62}],9:[function(require,module,exports){
  var createWrapper = require('../internal/createWrapper'),
      replaceHolders = require('../internal/replaceHolders'),
      restParam = require('./restParam');
  
  /** Used to compose bitmasks for wrapper metadata. */
  var BIND_FLAG = 1,
      PARTIAL_FLAG = 32;
  
  /**
   * Creates a function that invokes `func` with the `this` binding of `thisArg`
   * and prepends any additional `_.bind` arguments to those provided to the
   * bound function.
   *
   * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,
   * may be used as a placeholder for partially applied arguments.
   *
   * **Note:** Unlike native `Function#bind` this method does not set the "length"
   * property of bound functions.
   *
   * @static
   * @memberOf _
   * @category Function
   * @param {Function} func The function to bind.
   * @param {*} thisArg The `this` binding of `func`.
   * @param {...*} [partials] The arguments to be partially applied.
   * @returns {Function} Returns the new bound function.
   * @example
   *
   * var greet = function(greeting, punctuation) {
   *   return greeting + ' ' + this.user + punctuation;
   * };
   *
   * var object = { 'user': 'fred' };
   *
   * var bound = _.bind(greet, object, 'hi');
   * bound('!');
   * // => 'hi fred!'
   *
   * // using placeholders
   * var bound = _.bind(greet, object, _, '!');
   * bound('hi');
   * // => 'hi fred!'
   */
  var bind = restParam(function(func, thisArg, partials) {
    var bitmask = BIND_FLAG;
    if (partials.length) {
      var holders = replaceHolders(partials, bind.placeholder);
      bitmask |= PARTIAL_FLAG;
    }
    return createWrapper(func, bitmask, thisArg, partials, holders);
  });
  
  // Assign default placeholders.
  bind.placeholder = {};
  
  module.exports = bind;
  
  },{"../internal/createWrapper":54,"../internal/replaceHolders":76,"./restParam":10}],10:[function(require,module,exports){
  /** Used as the `TypeError` message for "Functions" methods. */
  var FUNC_ERROR_TEXT = 'Expected a function';
  
  /* Native method references for those with the same name as other `lodash` methods. */
  var nativeMax = Math.max;
  
  /**
   * Creates a function that invokes `func` with the `this` binding of the
   * created function and arguments from `start` and beyond provided as an array.
   *
   * **Note:** This method is based on the [rest parameter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters).
   *
   * @static
   * @memberOf _
   * @category Function
   * @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.
   * @example
   *
   * var say = _.restParam(function(what, names) {
   *   return what + ' ' + _.initial(names).join(', ') +
   *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);
   * });
   *
   * say('hello', 'fred', 'barney', 'pebbles');
   * // => 'hello fred, barney, & pebbles'
   */
  function restParam(func, start) {
    if (typeof func != 'function') {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    start = nativeMax(start === undefined ? (func.length - 1) : (+start || 0), 0);
    return function() {
      var args = arguments,
          index = -1,
          length = nativeMax(args.length - start, 0),
          rest = Array(length);
  
      while (++index < length) {
        rest[index] = args[start + index];
      }
      switch (start) {
        case 0: return func.call(this, rest);
        case 1: return func.call(this, args[0], rest);
        case 2: return func.call(this, args[0], args[1], rest);
      }
      var otherArgs = Array(start + 1);
      index = -1;
      while (++index < start) {
        otherArgs[index] = args[index];
      }
      otherArgs[start] = rest;
      return func.apply(this, otherArgs);
    };
  }
  
  module.exports = restParam;
  
  },{}],11:[function(require,module,exports){
  var baseCreate = require('./baseCreate'),
      baseLodash = require('./baseLodash');
  
  /** Used as references for `-Infinity` and `Infinity`. */
  var POSITIVE_INFINITY = Number.POSITIVE_INFINITY;
  
  /**
   * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
   *
   * @private
   * @param {*} value The value to wrap.
   */
  function LazyWrapper(value) {
    this.__wrapped__ = value;
    this.__actions__ = [];
    this.__dir__ = 1;
    this.__filtered__ = false;
    this.__iteratees__ = [];
    this.__takeCount__ = POSITIVE_INFINITY;
    this.__views__ = [];
  }
  
  LazyWrapper.prototype = baseCreate(baseLodash.prototype);
  LazyWrapper.prototype.constructor = LazyWrapper;
  
  module.exports = LazyWrapper;
  
  },{"./baseCreate":23,"./baseLodash":34}],12:[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 chaining for all wrapper methods.
   * @param {Array} [actions=[]] Actions to peform to resolve the unwrapped value.
   */
  function LodashWrapper(value, chainAll, actions) {
    this.__wrapped__ = value;
    this.__actions__ = actions || [];
    this.__chain__ = !!chainAll;
  }
  
  LodashWrapper.prototype = baseCreate(baseLodash.prototype);
  LodashWrapper.prototype.constructor = LodashWrapper;
  
  module.exports = LodashWrapper;
  
  },{"./baseCreate":23,"./baseLodash":34}],13:[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 arrayCopy(source, array) {
    var index = -1,
        length = source.length;
  
    array || (array = Array(length));
    while (++index < length) {
      array[index] = source[index];
    }
    return array;
  }
  
  module.exports = arrayCopy;
  
  },{}],14:[function(require,module,exports){
  /**
   * A specialized version of `_.forEach` for arrays without support for callback
   * shorthands and `this` binding.
   *
   * @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.length;
  
    while (++index < length) {
      if (iteratee(array[index], index, array) === false) {
        break;
      }
    }
    return array;
  }
  
  module.exports = arrayEach;
  
  },{}],15:[function(require,module,exports){
  /**
   * A specialized version of `_.every` for arrays without support for callback
   * shorthands and `this` binding.
   *
   * @private
   * @param {Array} array The array to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {boolean} Returns `true` if all elements pass the predicate check,
   *  else `false`.
   */
  function arrayEvery(array, predicate) {
    var index = -1,
        length = array.length;
  
    while (++index < length) {
      if (!predicate(array[index], index, array)) {
        return false;
      }
    }
    return true;
  }
  
  module.exports = arrayEvery;
  
  },{}],16:[function(require,module,exports){
  /**
   * A specialized version of `_.filter` for arrays without support for callback
   * shorthands and `this` binding.
   *
   * @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.length,
        resIndex = -1,
        result = [];
  
    while (++index < length) {
      var value = array[index];
      if (predicate(value, index, array)) {
        result[++resIndex] = value;
      }
    }
    return result;
  }
  
  module.exports = arrayFilter;
  
  },{}],17:[function(require,module,exports){
  /**
   * A specialized version of `_.map` for arrays without support for callback
   * shorthands and `this` binding.
   *
   * @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.length,
        result = Array(length);
  
    while (++index < length) {
      result[index] = iteratee(array[index], index, array);
    }
    return result;
  }
  
  module.exports = arrayMap;
  
  },{}],18:[function(require,module,exports){
  /**
   * A specialized version of `_.some` for arrays without support for callback
   * shorthands and `this` binding.
   *
   * @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.length;
  
    while (++index < length) {
      if (predicate(array[index], index, array)) {
        return true;
      }
    }
    return false;
  }
  
  module.exports = arraySome;
  
  },{}],19:[function(require,module,exports){
  var keys = require('../object/keys');
  
  /**
   * A specialized version of `_.assign` for customizing assigned values without
   * support for argument juggling, multiple sources, and `this` binding `customizer`
   * functions.
   *
   * @private
   * @param {Object} object The destination object.
   * @param {Object} source The source object.
   * @param {Function} customizer The function to customize assigned values.
   * @returns {Object} Returns `object`.
   */
  function assignWith(object, source, customizer) {
    var index = -1,
        props = keys(source),
        length = props.length;
  
    while (++index < length) {
      var key = props[index],
          value = object[key],
          result = customizer(value, source[key], key, object, source);
  
      if ((result === result ? (result !== value) : (value === value)) ||
          (value === undefined && !(key in object))) {
        object[key] = result;
      }
    }
    return object;
  }
  
  module.exports = assignWith;
  
  },{"../object/keys":91}],20:[function(require,module,exports){
  var baseCopy = require('./baseCopy'),
      keys = require('../object/keys');
  
  /**
   * The base implementation of `_.assign` without support for argument juggling,
   * multiple sources, and `customizer` functions.
   *
   * @private
   * @param {Object} object The destination object.
   * @param {Object} source The source object.
   * @returns {Object} Returns `object`.
   */
  function baseAssign(object, source) {
    return source == null
      ? object
      : baseCopy(source, keys(source), object);
  }
  
  module.exports = baseAssign;
  
  },{"../object/keys":91,"./baseCopy":22}],21:[function(require,module,exports){
  var baseMatches = require('./baseMatches'),
      baseMatchesProperty = require('./baseMatchesProperty'),
      bindCallback = require('./bindCallback'),
      identity = require('../utility/identity'),
      property = require('../utility/property');
  
  /**
   * The base implementation of `_.callback` which supports specifying the
   * number of arguments to provide to `func`.
   *
   * @private
   * @param {*} [func=_.identity] The value to convert to a callback.
   * @param {*} [thisArg] The `this` binding of `func`.
   * @param {number} [argCount] The number of arguments to provide to `func`.
   * @returns {Function} Returns the callback.
   */
  function baseCallback(func, thisArg, argCount) {
    var type = typeof func;
    if (type == 'function') {
      return thisArg === undefined
        ? func
        : bindCallback(func, thisArg, argCount);
    }
    if (func == null) {
      return identity;
    }
    if (type == 'object') {
      return baseMatches(func);
    }
    return thisArg === undefined
      ? property(func)
      : baseMatchesProperty(func, thisArg);
  }
  
  module.exports = baseCallback;
  
  },{"../utility/identity":95,"../utility/property":97,"./baseMatches":36,"./baseMatchesProperty":37,"./bindCallback":43}],22:[function(require,module,exports){
  /**
   * Copies properties of `source` to `object`.
   *
   * @private
   * @param {Object} source The object to copy properties from.
   * @param {Array} props The property names to copy.
   * @param {Object} [object={}] The object to copy properties to.
   * @returns {Object} Returns `object`.
   */
  function baseCopy(source, props, object) {
    object || (object = {});
  
    var index = -1,
        length = props.length;
  
    while (++index < length) {
      var key = props[index];
      object[key] = source[key];
    }
    return object;
  }
  
  module.exports = baseCopy;
  
  },{}],23:[function(require,module,exports){
  var isObject = require('../lang/isObject');
  
  /**
   * The base implementation of `_.create` without support for assigning
   * properties to the created object.
   *
   * @private
   * @param {Object} prototype The object to inherit from.
   * @returns {Object} Returns the new object.
   */
  var baseCreate = (function() {
    function object() {}
    return function(prototype) {
      if (isObject(prototype)) {
        object.prototype = prototype;
        var result = new object;
        object.prototype = undefined;
      }
      return result || {};
    };
  }());
  
  module.exports = baseCreate;
  
  },{"../lang/isObject":86}],24:[function(require,module,exports){
  var baseForOwn = require('./baseForOwn'),
      createBaseEach = require('./createBaseEach');
  
  /**
   * The base implementation of `_.forEach` without support for callback
   * shorthands and `this` binding.
   *
   * @private
   * @param {Array|Object|string} collection The collection to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array|Object|string} Returns `collection`.
   */
  var baseEach = createBaseEach(baseForOwn);
  
  module.exports = baseEach;
  
  },{"./baseForOwn":29,"./createBaseEach":47}],25:[function(require,module,exports){
  var baseEach = require('./baseEach');
  
  /**
   * The base implementation of `_.every` without support for callback
   * shorthands and `this` binding.
   *
   * @private
   * @param {Array|Object|string} collection The collection to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {boolean} Returns `true` if all elements pass the predicate check,
   *  else `false`
   */
  function baseEvery(collection, predicate) {
    var result = true;
    baseEach(collection, function(value, index, collection) {
      result = !!predicate(value, index, collection);
      return result;
    });
    return result;
  }
  
  module.exports = baseEvery;
  
  },{"./baseEach":24}],26:[function(require,module,exports){
  var baseEach = require('./baseEach');
  
  /**
   * The base implementation of `_.filter` without support for callback
   * shorthands and `this` binding.
   *
   * @private
   * @param {Array|Object|string} collection The collection to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {Array} Returns the new filtered array.
   */
  function baseFilter(collection, predicate) {
    var result = [];
    baseEach(collection, function(value, index, collection) {
      if (predicate(value, index, collection)) {
        result.push(value);
      }
    });
    return result;
  }
  
  module.exports = baseFilter;
  
  },{"./baseEach":24}],27:[function(require,module,exports){
  var createBaseFor = require('./createBaseFor');
  
  /**
   * The base implementation of `baseForIn` and `baseForOwn` which iterates
   * over `object` properties returned by `keysFunc` invoking `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":48}],28:[function(require,module,exports){
  var baseFor = require('./baseFor'),
      keysIn = require('../object/keysIn');
  
  /**
   * The base implementation of `_.forIn` without support for callback
   * shorthands and `this` binding.
   *
   * @private
   * @param {Object} object The object to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Object} Returns `object`.
   */
  function baseForIn(object, iteratee) {
    return baseFor(object, iteratee, keysIn);
  }
  
  module.exports = baseForIn;
  
  },{"../object/keysIn":92,"./baseFor":27}],29:[function(require,module,exports){
  var baseFor = require('./baseFor'),
      keys = require('../object/keys');
  
  /**
   * The base implementation of `_.forOwn` without support for callback
   * shorthands and `this` binding.
   *
   * @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 baseFor(object, iteratee, keys);
  }
  
  module.exports = baseForOwn;
  
  },{"../object/keys":91,"./baseFor":27}],30:[function(require,module,exports){
  var toObject = require('./toObject');
  
  /**
   * The base implementation of `get` without support for string paths
   * and default values.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Array} path The path of the property to get.
   * @param {string} [pathKey] The key representation of path.
   * @returns {*} Returns the resolved value.
   */
  function baseGet(object, path, pathKey) {
    if (object == null) {
      return;
    }
    object = toObject(object);
    if (pathKey !== undefined && pathKey in object) {
      path = [pathKey];
    }
    var index = 0,
        length = path.length;
  
    while (object != null && index < length) {
      object = toObject(object)[path[index++]];
    }
    return (index && index == length) ? object : undefined;
  }
  
  module.exports = baseGet;
  
  },{"./toObject":79}],31:[function(require,module,exports){
  var baseIsEqualDeep = require('./baseIsEqualDeep'),
      isObject = require('../lang/isObject'),
      isObjectLike = require('./isObjectLike');
  
  /**
   * The base implementation of `_.isEqual` without support for `this` binding
   * `customizer` functions.
   *
   * @private
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @param {Function} [customizer] The function to customize comparing values.
   * @param {boolean} [isLoose] Specify performing partial comparisons.
   * @param {Array} [stackA] Tracks traversed `value` objects.
   * @param {Array} [stackB] Tracks traversed `other` objects.
   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
   */
  function baseIsEqual(value, other, customizer, isLoose, stackA, stackB) {
    if (value === other) {
      return true;
    }
    if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {
      return value !== value && other !== other;
    }
    return baseIsEqualDeep(value, other, baseIsEqual, customizer, isLoose, stackA, stackB);
  }
  
  module.exports = baseIsEqual;
  
  },{"../lang/isObject":86,"./baseIsEqualDeep":32,"./isObjectLike":70}],32:[function(require,module,exports){
  var equalArrays = require('./equalArrays'),
      equalByTag = require('./equalByTag'),
      equalObjects = require('./equalObjects'),
      isArray = require('../lang/isArray'),
      isHostObject = require('./isHostObject'),
      isTypedArray = require('../lang/isTypedArray');
  
  /** `Object#toString` result references. */
  var argsTag = '[object Arguments]',
      arrayTag = '[object Array]',
      objectTag = '[object Object]';
  
  /** Used for native 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/6.0/#sec-object.prototype.tostring)
   * of values.
   */
  var objToString = objectProto.toString;
  
  /**
   * 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 {Function} equalFunc The function to determine equivalents of values.
   * @param {Function} [customizer] The function to customize comparing objects.
   * @param {boolean} [isLoose] Specify performing partial comparisons.
   * @param {Array} [stackA=[]] Tracks traversed `value` objects.
   * @param {Array} [stackB=[]] Tracks traversed `other` objects.
   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
   */
  function baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA, stackB) {
    var objIsArr = isArray(object),
        othIsArr = isArray(other),
        objTag = arrayTag,
        othTag = arrayTag;
  
    if (!objIsArr) {
      objTag = objToString.call(object);
      if (objTag == argsTag) {
        objTag = objectTag;
      } else if (objTag != objectTag) {
        objIsArr = isTypedArray(object);
      }
    }
    if (!othIsArr) {
      othTag = objToString.call(other);
      if (othTag == argsTag) {
        othTag = objectTag;
      } else if (othTag != objectTag) {
        othIsArr = isTypedArray(other);
      }
    }
    var objIsObj = objTag == objectTag && !isHostObject(object),
        othIsObj = othTag == objectTag && !isHostObject(other),
        isSameTag = objTag == othTag;
  
    if (isSameTag && !(objIsArr || objIsObj)) {
      return equalByTag(object, other, objTag);
    }
    if (!isLoose) {
      var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
          othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
  
      if (objIsWrapped || othIsWrapped) {
        return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, isLoose, stackA, stackB);
      }
    }
    if (!isSameTag) {
      return false;
    }
    // Assume cyclic values are equal.
    // For more information on detecting circular references see https://es5.github.io/#JO.
    stackA || (stackA = []);
    stackB || (stackB = []);
  
    var length = stackA.length;
    while (length--) {
      if (stackA[length] == object) {
        return stackB[length] == other;
      }
    }
    // Add `object` and `other` to the stack of traversed objects.
    stackA.push(object);
    stackB.push(other);
  
    var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, isLoose, stackA, stackB);
  
    stackA.pop();
    stackB.pop();
  
    return result;
  }
  
  module.exports = baseIsEqualDeep;
  
  },{"../lang/isArray":83,"../lang/isTypedArray":89,"./equalArrays":55,"./equalByTag":56,"./equalObjects":57,"./isHostObject":64}],33:[function(require,module,exports){
  var baseIsEqual = require('./baseIsEqual'),
      toObject = require('./toObject');
  
  /**
   * The base implementation of `_.isMatch` without support for callback
   * shorthands and `this` binding.
   *
   * @private
   * @param {Object} object The object to inspect.
   * @param {Array} matchData The propery names, values, and compare flags to match.
   * @param {Function} [customizer] The function to customize comparing objects.
   * @returns {boolean} Returns `true` if `object` is a match, else `false`.
   */
  function baseIsMatch(object, matchData, customizer) {
    var index = matchData.length,
        length = index,
        noCustomizer = !customizer;
  
    if (object == null) {
      return !length;
    }
    object = toObject(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 result = customizer ? customizer(objValue, srcValue, key) : undefined;
        if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, true) : result)) {
          return false;
        }
      }
    }
    return true;
  }
  
  module.exports = baseIsMatch;
  
  },{"./baseIsEqual":31,"./toObject":79}],34:[function(require,module,exports){
  /**
   * The function whose prototype all chaining wrappers inherit from.
   *
   * @private
   */
  function baseLodash() {
    // No operation performed.
  }
  
  module.exports = baseLodash;
  
  },{}],35:[function(require,module,exports){
  var baseEach = require('./baseEach'),
      isArrayLike = require('./isArrayLike');
  
  /**
   * The base implementation of `_.map` without support for callback shorthands
   * and `this` binding.
   *
   * @private
   * @param {Array|Object|string} collection The collection to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array} Returns the new mapped array.
   */
  function baseMap(collection, iteratee) {
    var index = -1,
        result = isArrayLike(collection) ? Array(collection.length) : [];
  
    baseEach(collection, function(value, key, collection) {
      result[++index] = iteratee(value, key, collection);
    });
    return result;
  }
  
  module.exports = baseMap;
  
  },{"./baseEach":24,"./isArrayLike":63}],36:[function(require,module,exports){
  var baseIsMatch = require('./baseIsMatch'),
      getMatchData = require('./getMatchData'),
      toObject = require('./toObject');
  
  /**
   * The base implementation of `_.matches` which does not clone `source`.
   *
   * @private
   * @param {Object} source The object of property values to match.
   * @returns {Function} Returns the new function.
   */
  function baseMatches(source) {
    var matchData = getMatchData(source);
    if (matchData.length == 1 && matchData[0][2]) {
      var key = matchData[0][0],
          value = matchData[0][1];
  
      return function(object) {
        if (object == null) {
          return false;
        }
        object = toObject(object);
        return object[key] === value && (value !== undefined || (key in object));
      };
    }
    return function(object) {
      return baseIsMatch(object, matchData);
    };
  }
  
  module.exports = baseMatches;
  
  },{"./baseIsMatch":33,"./getMatchData":61,"./toObject":79}],37:[function(require,module,exports){
  var baseGet = require('./baseGet'),
      baseIsEqual = require('./baseIsEqual'),
      baseSlice = require('./baseSlice'),
      isArray = require('../lang/isArray'),
      isKey = require('./isKey'),
      isStrictComparable = require('./isStrictComparable'),
      last = require('../array/last'),
      toObject = require('./toObject'),
      toPath = require('./toPath');
  
  /**
   * The base implementation of `_.matchesProperty` which does not clone `srcValue`.
   *
   * @private
   * @param {string} path The path of the property to get.
   * @param {*} srcValue The value to compare.
   * @returns {Function} Returns the new function.
   */
  function baseMatchesProperty(path, srcValue) {
    var isArr = isArray(path),
        isCommon = isKey(path) && isStrictComparable(srcValue),
        pathKey = (path + '');
  
    path = toPath(path);
    return function(object) {
      if (object == null) {
        return false;
      }
      var key = pathKey;
      object = toObject(object);
      if ((isArr || !isCommon) && !(key in object)) {
        object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));
        if (object == null) {
          return false;
        }
        key = last(path);
        object = toObject(object);
      }
      return object[key] === srcValue
        ? (srcValue !== undefined || (key in object))
        : baseIsEqual(srcValue, object[key], undefined, true);
    };
  }
  
  module.exports = baseMatchesProperty;
  
  },{"../array/last":2,"../lang/isArray":83,"./baseGet":30,"./baseIsEqual":31,"./baseSlice":41,"./isKey":67,"./isStrictComparable":71,"./toObject":79,"./toPath":80}],38:[function(require,module,exports){
  var toObject = require('./toObject');
  
  /**
   * 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 function.
   */
  function baseProperty(key) {
    return function(object) {
      return object == null ? undefined : toObject(object)[key];
    };
  }
  
  module.exports = baseProperty;
  
  },{"./toObject":79}],39:[function(require,module,exports){
  var baseGet = require('./baseGet'),
      toPath = require('./toPath');
  
  /**
   * 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 function.
   */
  function basePropertyDeep(path) {
    var pathKey = (path + '');
    path = toPath(path);
    return function(object) {
      return baseGet(object, path, pathKey);
    };
  }
  
  module.exports = basePropertyDeep;
  
  },{"./baseGet":30,"./toPath":80}],40:[function(require,module,exports){
  var identity = require('../utility/identity'),
      metaMap = require('./metaMap');
  
  /**
   * The base implementation of `setData` without support for hot loop detection.
   *
   * @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;
  
  },{"../utility/identity":95,"./metaMap":73}],41:[function(require,module,exports){
  /**
   * The base implementation of `_.slice` without an iteratee call guard.
   *
   * @private
   * @param {Array} array The array to slice.
   * @param {number} [start=0] The start position.
   * @param {number} [end=array.length] The end position.
   * @returns {Array} Returns the slice of `array`.
   */
  function baseSlice(array, start, end) {
    var index = -1,
        length = array.length;
  
    start = start == null ? 0 : (+start || 0);
    if (start < 0) {
      start = -start > length ? 0 : (length + start);
    }
    end = (end === undefined || end > length) ? length : (+end || 0);
    if (end < 0) {
      end += length;
    }
    length = start > end ? 0 : ((end - start) >>> 0);
    start >>>= 0;
  
    var result = Array(length);
    while (++index < length) {
      result[index] = array[index + start];
    }
    return result;
  }
  
  module.exports = baseSlice;
  
  },{}],42:[function(require,module,exports){
  /**
   * Converts `value` to a string if it's not one. An empty string is returned
   * for `null` or `undefined` values.
   *
   * @private
   * @param {*} value The value to process.
   * @returns {string} Returns the string.
   */
  function baseToString(value) {
    return value == null ? '' : (value + '');
  }
  
  module.exports = baseToString;
  
  },{}],43:[function(require,module,exports){
  var identity = require('../utility/identity');
  
  /**
   * A specialized version of `baseCallback` which only supports `this` binding
   * and specifying the number of arguments to provide to `func`.
   *
   * @private
   * @param {Function} func The function to bind.
   * @param {*} thisArg The `this` binding of `func`.
   * @param {number} [argCount] The number of arguments to provide to `func`.
   * @returns {Function} Returns the callback.
   */
  function bindCallback(func, thisArg, argCount) {
    if (typeof func != 'function') {
      return identity;
    }
    if (thisArg === undefined) {
      return func;
    }
    switch (argCount) {
      case 1: return function(value) {
        return func.call(thisArg, value);
      };
      case 3: return function(value, index, collection) {
        return func.call(thisArg, value, index, collection);
      };
      case 4: return function(accumulator, value, index, collection) {
        return func.call(thisArg, accumulator, value, index, collection);
      };
      case 5: return function(value, other, key, object, source) {
        return func.call(thisArg, value, other, key, object, source);
      };
    }
    return function() {
      return func.apply(thisArg, arguments);
    };
  }
  
  module.exports = bindCallback;
  
  },{"../utility/identity":95}],44:[function(require,module,exports){
  /* Native 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|Object} args The provided arguments.
   * @param {Array} partials The arguments to prepend to those provided.
   * @param {Array} holders The `partials` placeholder indexes.
   * @returns {Array} Returns the new array of composed arguments.
   */
  function composeArgs(args, partials, holders) {
    var holdersLength = holders.length,
        argsIndex = -1,
        argsLength = nativeMax(args.length - holdersLength, 0),
        leftIndex = -1,
        leftLength = partials.length,
        result = Array(leftLength + argsLength);
  
    while (++leftIndex < leftLength) {
      result[leftIndex] = partials[leftIndex];
    }
    while (++argsIndex < holdersLength) {
      result[holders[argsIndex]] = args[argsIndex];
    }
    while (argsLength--) {
      result[leftIndex++] = args[argsIndex++];
    }
    return result;
  }
  
  module.exports = composeArgs;
  
  },{}],45:[function(require,module,exports){
  /* Native 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|Object} args The provided arguments.
   * @param {Array} partials The arguments to append to those provided.
   * @param {Array} holders The `partials` placeholder indexes.
   * @returns {Array} Returns the new array of composed arguments.
   */
  function composeArgsRight(args, partials, holders) {
    var holdersIndex = -1,
        holdersLength = holders.length,
        argsIndex = -1,
        argsLength = nativeMax(args.length - holdersLength, 0),
        rightIndex = -1,
        rightLength = partials.length,
        result = Array(argsLength + rightLength);
  
    while (++argsIndex < argsLength) {
      result[argsIndex] = args[argsIndex];
    }
    var offset = argsIndex;
    while (++rightIndex < rightLength) {
      result[offset + rightIndex] = partials[rightIndex];
    }
    while (++holdersIndex < holdersLength) {
      result[offset + holders[holdersIndex]] = args[argsIndex++];
    }
    return result;
  }
  
  module.exports = composeArgsRight;
  
  },{}],46:[function(require,module,exports){
  var bindCallback = require('./bindCallback'),
      isIterateeCall = require('./isIterateeCall'),
      restParam = require('../function/restParam');
  
  /**
   * Creates a `_.assign`, `_.defaults`, or `_.merge` function.
   *
   * @private
   * @param {Function} assigner The function to assign values.
   * @returns {Function} Returns the new assigner function.
   */
  function createAssigner(assigner) {
    return restParam(function(object, sources) {
      var index = -1,
          length = object == null ? 0 : sources.length,
          customizer = length > 2 ? sources[length - 2] : undefined,
          guard = length > 2 ? sources[2] : undefined,
          thisArg = length > 1 ? sources[length - 1] : undefined;
  
      if (typeof customizer == 'function') {
        customizer = bindCallback(customizer, thisArg, 5);
        length -= 2;
      } else {
        customizer = typeof thisArg == 'function' ? thisArg : undefined;
        length -= (customizer ? 1 : 0);
      }
      if (guard && isIterateeCall(sources[0], sources[1], guard)) {
        customizer = length < 3 ? undefined : customizer;
        length = 1;
      }
      while (++index < length) {
        var source = sources[index];
        if (source) {
          assigner(object, source, customizer);
        }
      }
      return object;
    });
  }
  
  module.exports = createAssigner;
  
  },{"../function/restParam":10,"./bindCallback":43,"./isIterateeCall":66}],47:[function(require,module,exports){
  var getLength = require('./getLength'),
      isLength = require('./isLength'),
      toObject = require('./toObject');
  
  /**
   * 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) {
      var length = collection ? getLength(collection) : 0;
      if (!isLength(length)) {
        return eachFunc(collection, iteratee);
      }
      var index = fromRight ? length : -1,
          iterable = toObject(collection);
  
      while ((fromRight ? index-- : ++index < length)) {
        if (iteratee(iterable[index], index, iterable) === false) {
          break;
        }
      }
      return collection;
    };
  }
  
  module.exports = createBaseEach;
  
  },{"./getLength":60,"./isLength":69,"./toObject":79}],48:[function(require,module,exports){
  var toObject = require('./toObject');
  
  /**
   * Creates a base function for `_.forIn` or `_.forInRight`.
   *
   * @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 iterable = toObject(object),
          props = keysFunc(object),
          length = props.length,
          index = fromRight ? length : -1;
  
      while ((fromRight ? index-- : ++index < length)) {
        var key = props[index];
        if (iteratee(iterable[key], key, iterable) === false) {
          break;
        }
      }
      return object;
    };
  }
  
  module.exports = createBaseFor;
  
  },{"./toObject":79}],49:[function(require,module,exports){
  (function (global){
  var createCtorWrapper = require('./createCtorWrapper');
  
  /**
   * Creates a function that wraps `func` and invokes it with the `this`
   * binding of `thisArg`.
   *
   * @private
   * @param {Function} func The function to bind.
   * @param {*} [thisArg] The `this` binding of `func`.
   * @returns {Function} Returns the new bound function.
   */
  function createBindWrapper(func, thisArg) {
    var Ctor = createCtorWrapper(func);
  
    function wrapper() {
      var fn = (this && this !== global && this instanceof wrapper) ? Ctor : func;
      return fn.apply(thisArg, arguments);
    }
    return wrapper;
  }
  
  module.exports = createBindWrapper;
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"./createCtorWrapper":50}],50:[function(require,module,exports){
  var baseCreate = require('./baseCreate'),
      isObject = require('../lang/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 createCtorWrapper(Ctor) {
    return function() {
      // Use a `switch` statement to work with class constructors.
      // See http://ecma-international.org/ecma-262/6.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 = createCtorWrapper;
  
  },{"../lang/isObject":86,"./baseCreate":23}],51:[function(require,module,exports){
  var bindCallback = require('./bindCallback'),
      isArray = require('../lang/isArray');
  
  /**
   * Creates a function for `_.forEach` or `_.forEachRight`.
   *
   * @private
   * @param {Function} arrayFunc The function to iterate over an array.
   * @param {Function} eachFunc The function to iterate over a collection.
   * @returns {Function} Returns the new each function.
   */
  function createForEach(arrayFunc, eachFunc) {
    return function(collection, iteratee, thisArg) {
      return (typeof iteratee == 'function' && thisArg === undefined && isArray(collection))
        ? arrayFunc(collection, iteratee)
        : eachFunc(collection, bindCallback(iteratee, thisArg, 3));
    };
  }
  
  module.exports = createForEach;
  
  },{"../lang/isArray":83,"./bindCallback":43}],52:[function(require,module,exports){
  (function (global){
  var arrayCopy = require('./arrayCopy'),
      composeArgs = require('./composeArgs'),
      composeArgsRight = require('./composeArgsRight'),
      createCtorWrapper = require('./createCtorWrapper'),
      isLaziable = require('./isLaziable'),
      reorder = require('./reorder'),
      replaceHolders = require('./replaceHolders'),
      setData = require('./setData');
  
  /** Used to compose bitmasks for wrapper metadata. */
  var BIND_FLAG = 1,
      BIND_KEY_FLAG = 2,
      CURRY_BOUND_FLAG = 4,
      CURRY_FLAG = 8,
      CURRY_RIGHT_FLAG = 16,
      PARTIAL_FLAG = 32,
      PARTIAL_RIGHT_FLAG = 64,
      ARY_FLAG = 128;
  
  /* Native method references for those with the same name as other `lodash` methods. */
  var nativeMax = Math.max;
  
  /**
   * Creates a function that wraps `func` and invokes it with optional `this`
   * binding of, partial application, and currying.
   *
   * @private
   * @param {Function|string} func The function or method name to reference.
   * @param {number} bitmask The bitmask of flags. See `createWrapper` 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 createHybridWrapper(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
    var isAry = bitmask & ARY_FLAG,
        isBind = bitmask & BIND_FLAG,
        isBindKey = bitmask & BIND_KEY_FLAG,
        isCurry = bitmask & CURRY_FLAG,
        isCurryBound = bitmask & CURRY_BOUND_FLAG,
        isCurryRight = bitmask & CURRY_RIGHT_FLAG,
        Ctor = isBindKey ? undefined : createCtorWrapper(func);
  
    function wrapper() {
      // Avoid `arguments` object use disqualifying optimizations by
      // converting it to an array before providing it to other functions.
      var length = arguments.length,
          index = length,
          args = Array(length);
  
      while (index--) {
        args[index] = arguments[index];
      }
      if (partials) {
        args = composeArgs(args, partials, holders);
      }
      if (partialsRight) {
        args = composeArgsRight(args, partialsRight, holdersRight);
      }
      if (isCurry || isCurryRight) {
        var placeholder = wrapper.placeholder,
            argsHolders = replaceHolders(args, placeholder);
  
        length -= argsHolders.length;
        if (length < arity) {
          var newArgPos = argPos ? arrayCopy(argPos) : undefined,
              newArity = nativeMax(arity - length, 0),
              newsHolders = isCurry ? argsHolders : undefined,
              newHoldersRight = isCurry ? undefined : argsHolders,
              newPartials = isCurry ? args : undefined,
              newPartialsRight = isCurry ? undefined : args;
  
          bitmask |= (isCurry ? PARTIAL_FLAG : PARTIAL_RIGHT_FLAG);
          bitmask &= ~(isCurry ? PARTIAL_RIGHT_FLAG : PARTIAL_FLAG);
  
          if (!isCurryBound) {
            bitmask &= ~(BIND_FLAG | BIND_KEY_FLAG);
          }
          var newData = [func, bitmask, thisArg, newPartials, newsHolders, newPartialsRight, newHoldersRight, newArgPos, ary, newArity],
              result = createHybridWrapper.apply(undefined, newData);
  
          if (isLaziable(func)) {
            setData(result, newData);
          }
          result.placeholder = placeholder;
          return result;
        }
      }
      var thisBinding = isBind ? thisArg : this,
          fn = isBindKey ? thisBinding[func] : func;
  
      if (argPos) {
        args = reorder(args, argPos);
      }
      if (isAry && ary < args.length) {
        args.length = ary;
      }
      if (this && this !== global && this instanceof wrapper) {
        fn = Ctor || createCtorWrapper(func);
      }
      return fn.apply(thisBinding, args);
    }
    return wrapper;
  }
  
  module.exports = createHybridWrapper;
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"./arrayCopy":13,"./composeArgs":44,"./composeArgsRight":45,"./createCtorWrapper":50,"./isLaziable":68,"./reorder":75,"./replaceHolders":76,"./setData":77}],53:[function(require,module,exports){
  (function (global){
  var createCtorWrapper = require('./createCtorWrapper');
  
  /** Used to compose bitmasks for wrapper metadata. */
  var BIND_FLAG = 1;
  
  /**
   * Creates a function that wraps `func` and invokes it with the optional `this`
   * binding of `thisArg` and the `partials` prepended to those provided to
   * the wrapper.
   *
   * @private
   * @param {Function} func The function to partially apply arguments to.
   * @param {number} bitmask The bitmask of flags. See `createWrapper` 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 bound function.
   */
  function createPartialWrapper(func, bitmask, thisArg, partials) {
    var isBind = bitmask & BIND_FLAG,
        Ctor = createCtorWrapper(func);
  
    function wrapper() {
      // Avoid `arguments` object use disqualifying optimizations by
      // converting it to an array before providing it `func`.
      var argsIndex = -1,
          argsLength = arguments.length,
          leftIndex = -1,
          leftLength = partials.length,
          args = Array(leftLength + argsLength);
  
      while (++leftIndex < leftLength) {
        args[leftIndex] = partials[leftIndex];
      }
      while (argsLength--) {
        args[leftIndex++] = arguments[++argsIndex];
      }
      var fn = (this && this !== global && this instanceof wrapper) ? Ctor : func;
      return fn.apply(isBind ? thisArg : this, args);
    }
    return wrapper;
  }
  
  module.exports = createPartialWrapper;
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"./createCtorWrapper":50}],54:[function(require,module,exports){
  var baseSetData = require('./baseSetData'),
      createBindWrapper = require('./createBindWrapper'),
      createHybridWrapper = require('./createHybridWrapper'),
      createPartialWrapper = require('./createPartialWrapper'),
      getData = require('./getData'),
      mergeData = require('./mergeData'),
      setData = require('./setData');
  
  /** Used to compose bitmasks for wrapper metadata. */
  var BIND_FLAG = 1,
      BIND_KEY_FLAG = 2,
      PARTIAL_FLAG = 32,
      PARTIAL_RIGHT_FLAG = 64;
  
  /** Used as the `TypeError` message for "Functions" methods. */
  var FUNC_ERROR_TEXT = 'Expected a function';
  
  /* Native 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 reference.
   * @param {number} bitmask The bitmask of flags.
   *  The bitmask may be composed of the following 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`
   * @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 createWrapper(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
    var isBindKey = bitmask & BIND_KEY_FLAG;
    if (!isBindKey && typeof func != 'function') {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    var length = partials ? partials.length : 0;
    if (!length) {
      bitmask &= ~(PARTIAL_FLAG | PARTIAL_RIGHT_FLAG);
      partials = holders = undefined;
    }
    length -= (holders ? holders.length : 0);
    if (bitmask & PARTIAL_RIGHT_FLAG) {
      var partialsRight = partials,
          holdersRight = holders;
  
      partials = holders = undefined;
    }
    var data = isBindKey ? undefined : getData(func),
        newData = [func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity];
  
    if (data) {
      mergeData(newData, data);
      bitmask = newData[1];
      arity = newData[9];
    }
    newData[9] = arity == null
      ? (isBindKey ? 0 : func.length)
      : (nativeMax(arity - length, 0) || 0);
  
    if (bitmask == BIND_FLAG) {
      var result = createBindWrapper(newData[0], newData[2]);
    } else if ((bitmask == PARTIAL_FLAG || bitmask == (BIND_FLAG | PARTIAL_FLAG)) && !newData[4].length) {
      result = createPartialWrapper.apply(undefined, newData);
    } else {
      result = createHybridWrapper.apply(undefined, newData);
    }
    var setter = data ? baseSetData : setData;
    return setter(result, newData);
  }
  
  module.exports = createWrapper;
  
  },{"./baseSetData":40,"./createBindWrapper":49,"./createHybridWrapper":52,"./createPartialWrapper":53,"./getData":58,"./mergeData":72,"./setData":77}],55:[function(require,module,exports){
  var arraySome = require('./arraySome');
  
  /**
   * 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 {Function} equalFunc The function to determine equivalents of values.
   * @param {Function} [customizer] The function to customize comparing arrays.
   * @param {boolean} [isLoose] Specify performing partial comparisons.
   * @param {Array} [stackA] Tracks traversed `value` objects.
   * @param {Array} [stackB] Tracks traversed `other` objects.
   * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
   */
  function equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) {
    var index = -1,
        arrLength = array.length,
        othLength = other.length;
  
    if (arrLength != othLength && !(isLoose && othLength > arrLength)) {
      return false;
    }
    // Ignore non-index properties.
    while (++index < arrLength) {
      var arrValue = array[index],
          othValue = other[index],
          result = customizer ? customizer(isLoose ? othValue : arrValue, isLoose ? arrValue : othValue, index) : undefined;
  
      if (result !== undefined) {
        if (result) {
          continue;
        }
        return false;
      }
      // Recursively compare arrays (susceptible to call stack limits).
      if (isLoose) {
        if (!arraySome(other, function(othValue) {
              return arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB);
            })) {
          return false;
        }
      } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB))) {
        return false;
      }
    }
    return true;
  }
  
  module.exports = equalArrays;
  
  },{"./arraySome":18}],56:[function(require,module,exports){
  /** `Object#toString` result references. */
  var boolTag = '[object Boolean]',
      dateTag = '[object Date]',
      errorTag = '[object Error]',
      numberTag = '[object Number]',
      regexpTag = '[object RegExp]',
      stringTag = '[object String]';
  
  /**
   * 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.
   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
   */
  function equalByTag(object, other, tag) {
    switch (tag) {
      case boolTag:
      case dateTag:
        // Coerce dates and booleans to numbers, dates to milliseconds and booleans
        // to `1` or `0` treating invalid dates coerced to `NaN` as not equal.
        return +object == +other;
  
      case errorTag:
        return object.name == other.name && object.message == other.message;
  
      case numberTag:
        // Treat `NaN` vs. `NaN` as equal.
        return (object != +object)
          ? other != +other
          : object == +other;
  
      case regexpTag:
      case stringTag:
        // Coerce regexes to strings and treat strings primitives and string
        // objects as equal. See https://es5.github.io/#x15.10.6.4 for more details.
        return object == (other + '');
    }
    return false;
  }
  
  module.exports = equalByTag;
  
  },{}],57:[function(require,module,exports){
  var keys = require('../object/keys');
  
  /** Used for native 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 {Function} equalFunc The function to determine equivalents of values.
   * @param {Function} [customizer] The function to customize comparing values.
   * @param {boolean} [isLoose] Specify performing partial comparisons.
   * @param {Array} [stackA] Tracks traversed `value` objects.
   * @param {Array} [stackB] Tracks traversed `other` objects.
   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
   */
  function equalObjects(object, other, equalFunc, customizer, isLoose, stackA, stackB) {
    var objProps = keys(object),
        objLength = objProps.length,
        othProps = keys(other),
        othLength = othProps.length;
  
    if (objLength != othLength && !isLoose) {
      return false;
    }
    var index = objLength;
    while (index--) {
      var key = objProps[index];
      if (!(isLoose ? key in other : hasOwnProperty.call(other, key))) {
        return false;
      }
    }
    var skipCtor = isLoose;
    while (++index < objLength) {
      key = objProps[index];
      var objValue = object[key],
          othValue = other[key],
          result = customizer ? customizer(isLoose ? othValue : objValue, isLoose? objValue : othValue, key) : undefined;
  
      // Recursively compare objects (susceptible to call stack limits).
      if (!(result === undefined ? equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB) : result)) {
        return false;
      }
      skipCtor || (skipCtor = key == 'constructor');
    }
    if (!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)) {
        return false;
      }
    }
    return true;
  }
  
  module.exports = equalObjects;
  
  },{"../object/keys":91}],58:[function(require,module,exports){
  var metaMap = require('./metaMap'),
      noop = require('../utility/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;
  
  },{"../utility/noop":96,"./metaMap":73}],59:[function(require,module,exports){
  var realNames = require('./realNames');
  
  /**
   * 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 = array ? 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":74}],60:[function(require,module,exports){
  var baseProperty = require('./baseProperty');
  
  /**
   * Gets the "length" property value of `object`.
   *
   * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)
   * that affects Safari on at least iOS 8.1-8.3 ARM64.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {*} Returns the "length" value.
   */
  var getLength = baseProperty('length');
  
  module.exports = getLength;
  
  },{"./baseProperty":38}],61:[function(require,module,exports){
  var isStrictComparable = require('./isStrictComparable'),
      pairs = require('../object/pairs');
  
  /**
   * Gets the propery 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 = pairs(object),
        length = result.length;
  
    while (length--) {
      result[length][2] = isStrictComparable(result[length][1]);
    }
    return result;
  }
  
  module.exports = getMatchData;
  
  },{"../object/pairs":93,"./isStrictComparable":71}],62:[function(require,module,exports){
  var isNative = require('../lang/isNative');
  
  /**
   * 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 = object == null ? undefined : object[key];
    return isNative(value) ? value : undefined;
  }
  
  module.exports = getNative;
  
  },{"../lang/isNative":85}],63:[function(require,module,exports){
  var getLength = require('./getLength'),
      isLength = require('./isLength');
  
  /**
   * Checks if `value` is array-like.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
   */
  function isArrayLike(value) {
    return value != null && isLength(getLength(value));
  }
  
  module.exports = isArrayLike;
  
  },{"./getLength":60,"./isLength":69}],64:[function(require,module,exports){
  /**
   * Checks if `value` is a host object in IE < 9.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
   */
  var isHostObject = (function() {
    try {
      Object({ 'toString': 0 } + '');
    } catch(e) {
      return function() { return false; };
    }
    return function(value) {
      // IE < 9 presents many host objects as `Object` objects that can coerce
      // to strings despite having improperly defined `toString` methods.
      return typeof value.toString != 'function' && typeof (value + '') == 'string';
    };
  }());
  
  module.exports = isHostObject;
  
  },{}],65:[function(require,module,exports){
  /** Used to detect unsigned integer values. */
  var reIsUint = /^\d+$/;
  
  /**
   * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
   * of an array-like value.
   */
  var MAX_SAFE_INTEGER = 9007199254740991;
  
  /**
   * 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) {
    value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;
    length = length == null ? MAX_SAFE_INTEGER : length;
    return value > -1 && value % 1 == 0 && value < length;
  }
  
  module.exports = isIndex;
  
  },{}],66:[function(require,module,exports){
  var isArrayLike = require('./isArrayLike'),
      isIndex = require('./isIndex'),
      isObject = require('../lang/isObject');
  
  /**
   * Checks if the provided 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)) {
      var other = object[index];
      return value === value ? (value === other) : (other !== other);
    }
    return false;
  }
  
  module.exports = isIterateeCall;
  
  },{"../lang/isObject":86,"./isArrayLike":63,"./isIndex":65}],67:[function(require,module,exports){
  var isArray = require('../lang/isArray'),
      toObject = require('./toObject');
  
  /** Used to match property names within property paths. */
  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\n\\]|\\.)*?\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) {
    var type = typeof value;
    if ((type == 'string' && reIsPlainProp.test(value)) || type == 'number') {
      return true;
    }
    if (isArray(value)) {
      return false;
    }
    var result = !reIsDeepProp.test(value);
    return result || (object != null && value in toObject(object));
  }
  
  module.exports = isKey;
  
  },{"../lang/isArray":83,"./toObject":79}],68:[function(require,module,exports){
  var LazyWrapper = require('./LazyWrapper'),
      getData = require('./getData'),
      getFuncName = require('./getFuncName'),
      lodash = require('../chain/lodash');
  
  /**
   * 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);
    if (!(funcName in LazyWrapper.prototype)) {
      return false;
    }
    var other = lodash[funcName];
    if (func === other) {
      return true;
    }
    var data = getData(other);
    return !!data && func === data[0];
  }
  
  module.exports = isLaziable;
  
  },{"../chain/lodash":3,"./LazyWrapper":11,"./getData":58,"./getFuncName":59}],69:[function(require,module,exports){
  /**
   * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
   * of an array-like value.
   */
  var MAX_SAFE_INTEGER = 9007199254740991;
  
  /**
   * Checks if `value` is a valid array-like length.
   *
   * **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
   */
  function isLength(value) {
    return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
  }
  
  module.exports = isLength;
  
  },{}],70:[function(require,module,exports){
  /**
   * Checks if `value` is object-like.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
   */
  function isObjectLike(value) {
    return !!value && typeof value == 'object';
  }
  
  module.exports = isObjectLike;
  
  },{}],71:[function(require,module,exports){
  var isObject = require('../lang/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;
  
  },{"../lang/isObject":86}],72:[function(require,module,exports){
  var arrayCopy = require('./arrayCopy'),
      composeArgs = require('./composeArgs'),
      composeArgsRight = require('./composeArgsRight'),
      replaceHolders = require('./replaceHolders');
  
  /** Used to compose bitmasks for wrapper metadata. */
  var BIND_FLAG = 1,
      CURRY_BOUND_FLAG = 4,
      CURRY_FLAG = 8,
      ARY_FLAG = 128,
      REARG_FLAG = 256;
  
  /** Used as the internal argument placeholder. */
  var PLACEHOLDER = '__lodash_placeholder__';
  
  /* Native 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 required 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`
   * augment function arguments, making the order in which they are executed important,
   * preventing the merging of metadata. However, we make an exception for a safe
   * common 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 < ARY_FLAG;
  
    var isCombo =
      (srcBitmask == ARY_FLAG && bitmask == CURRY_FLAG) ||
      (srcBitmask == ARY_FLAG && bitmask == REARG_FLAG && data[7].length <= source[8]) ||
      (srcBitmask == (ARY_FLAG | REARG_FLAG) && bitmask == CURRY_FLAG);
  
    // Exit early if metadata can't be merged.
    if (!(isCommon || isCombo)) {
      return data;
    }
    // Use source `thisArg` if available.
    if (srcBitmask & BIND_FLAG) {
      data[2] = source[2];
      // Set when currying a bound function.
      newBitmask |= (bitmask & BIND_FLAG) ? 0 : CURRY_BOUND_FLAG;
    }
    // Compose partial arguments.
    var value = source[3];
    if (value) {
      var partials = data[3];
      data[3] = partials ? composeArgs(partials, value, source[4]) : arrayCopy(value);
      data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : arrayCopy(source[4]);
    }
    // Compose partial right arguments.
    value = source[5];
    if (value) {
      partials = data[5];
      data[5] = partials ? composeArgsRight(partials, value, source[6]) : arrayCopy(value);
      data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : arrayCopy(source[6]);
    }
    // Use source `argPos` if available.
    value = source[7];
    if (value) {
      data[7] = arrayCopy(value);
    }
    // Use source `ary` if it's smaller.
    if (srcBitmask & 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;
  
  },{"./arrayCopy":13,"./composeArgs":44,"./composeArgsRight":45,"./replaceHolders":76}],73:[function(require,module,exports){
  (function (global){
  var getNative = require('./getNative');
  
  /** Native method references. */
  var WeakMap = getNative(global, 'WeakMap');
  
  /** Used to store function metadata. */
  var metaMap = WeakMap && new WeakMap;
  
  module.exports = metaMap;
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"./getNative":62}],74:[function(require,module,exports){
  /** Used to lookup unminified function names. */
  var realNames = {};
  
  module.exports = realNames;
  
  },{}],75:[function(require,module,exports){
  var arrayCopy = require('./arrayCopy'),
      isIndex = require('./isIndex');
  
  /* Native 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 = arrayCopy(array);
  
    while (length--) {
      var index = indexes[length];
      array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;
    }
    return array;
  }
  
  module.exports = reorder;
  
  },{"./arrayCopy":13,"./isIndex":65}],76:[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 = -1,
        result = [];
  
    while (++index < length) {
      if (array[index] === placeholder) {
        array[index] = PLACEHOLDER;
        result[++resIndex] = index;
      }
    }
    return result;
  }
  
  module.exports = replaceHolders;
  
  },{}],77:[function(require,module,exports){
  var baseSetData = require('./baseSetData'),
      now = require('../date/now');
  
  /** Used to detect when a function becomes hot. */
  var HOT_COUNT = 150,
      HOT_SPAN = 16;
  
  /**
   * 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://code.google.com/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 = (function() {
    var count = 0,
        lastCalled = 0;
  
    return function(key, value) {
      var stamp = now(),
          remaining = HOT_SPAN - (stamp - lastCalled);
  
      lastCalled = stamp;
      if (remaining > 0) {
        if (++count >= HOT_COUNT) {
          return key;
        }
      } else {
        count = 0;
      }
      return baseSetData(key, value);
    };
  }());
  
  module.exports = setData;
  
  },{"../date/now":8,"./baseSetData":40}],78:[function(require,module,exports){
  var isArguments = require('../lang/isArguments'),
      isArray = require('../lang/isArray'),
      isIndex = require('./isIndex'),
      isLength = require('./isLength'),
      isString = require('../lang/isString'),
      keysIn = require('../object/keysIn');
  
  /** Used for native method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * A fallback implementation of `Object.keys` which creates an array of the
   * own enumerable property names of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   */
  function shimKeys(object) {
    var props = keysIn(object),
        propsLength = props.length,
        length = propsLength && object.length;
  
    var allowIndexes = !!length && isLength(length) &&
      (isArray(object) || isArguments(object) || isString(object));
  
    var index = -1,
        result = [];
  
    while (++index < propsLength) {
      var key = props[index];
      if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) {
        result.push(key);
      }
    }
    return result;
  }
  
  module.exports = shimKeys;
  
  },{"../lang/isArguments":82,"../lang/isArray":83,"../lang/isString":88,"../object/keysIn":92,"./isIndex":65,"./isLength":69}],79:[function(require,module,exports){
  var isObject = require('../lang/isObject'),
      isString = require('../lang/isString'),
      support = require('../support');
  
  /**
   * Converts `value` to an object if it's not one.
   *
   * @private
   * @param {*} value The value to process.
   * @returns {Object} Returns the object.
   */
  function toObject(value) {
    if (support.unindexedChars && isString(value)) {
      var index = -1,
          length = value.length,
          result = Object(value);
  
      while (++index < length) {
        result[index] = value.charAt(index);
      }
      return result;
    }
    return isObject(value) ? value : Object(value);
  }
  
  module.exports = toObject;
  
  },{"../lang/isObject":86,"../lang/isString":88,"../support":94}],80:[function(require,module,exports){
  var baseToString = require('./baseToString'),
      isArray = require('../lang/isArray');
  
  /** Used to match property names within property paths. */
  var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\n\\]|\\.)*?)\2)\]/g;
  
  /** Used to match backslashes in property paths. */
  var reEscapeChar = /\\(\\)?/g;
  
  /**
   * Converts `value` to property path array if it's not one.
   *
   * @private
   * @param {*} value The value to process.
   * @returns {Array} Returns the property path array.
   */
  function toPath(value) {
    if (isArray(value)) {
      return value;
    }
    var result = [];
    baseToString(value).replace(rePropName, function(match, number, quote, string) {
      result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
    });
    return result;
  }
  
  module.exports = toPath;
  
  },{"../lang/isArray":83,"./baseToString":42}],81:[function(require,module,exports){
  var LazyWrapper = require('./LazyWrapper'),
      LodashWrapper = require('./LodashWrapper'),
      arrayCopy = require('./arrayCopy');
  
  /**
   * Creates a clone of `wrapper`.
   *
   * @private
   * @param {Object} wrapper The wrapper to clone.
   * @returns {Object} Returns the cloned wrapper.
   */
  function wrapperClone(wrapper) {
    return wrapper instanceof LazyWrapper
      ? wrapper.clone()
      : new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__, arrayCopy(wrapper.__actions__));
  }
  
  module.exports = wrapperClone;
  
  },{"./LazyWrapper":11,"./LodashWrapper":12,"./arrayCopy":13}],82:[function(require,module,exports){
  var isArrayLike = require('../internal/isArrayLike'),
      isObjectLike = require('../internal/isObjectLike');
  
  /** Used for native method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /** Native method references. */
  var propertyIsEnumerable = objectProto.propertyIsEnumerable;
  
  /**
   * Checks if `value` is classified as an `arguments` object.
   *
   * @static
   * @memberOf _
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
   * @example
   *
   * _.isArguments(function() { return arguments; }());
   * // => true
   *
   * _.isArguments([1, 2, 3]);
   * // => false
   */
  function isArguments(value) {
    return isObjectLike(value) && isArrayLike(value) &&
      hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
  }
  
  module.exports = isArguments;
  
  },{"../internal/isArrayLike":63,"../internal/isObjectLike":70}],83:[function(require,module,exports){
  var getNative = require('../internal/getNative'),
      isLength = require('../internal/isLength'),
      isObjectLike = require('../internal/isObjectLike');
  
  /** `Object#toString` result references. */
  var arrayTag = '[object Array]';
  
  /** Used for native method references. */
  var objectProto = Object.prototype;
  
  /**
   * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
   * of values.
   */
  var objToString = objectProto.toString;
  
  /* Native method references for those with the same name as other `lodash` methods. */
  var nativeIsArray = getNative(Array, 'isArray');
  
  /**
   * Checks if `value` is classified as an `Array` object.
   *
   * @static
   * @memberOf _
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
   * @example
   *
   * _.isArray([1, 2, 3]);
   * // => true
   *
   * _.isArray(function() { return arguments; }());
   * // => false
   */
  var isArray = nativeIsArray || function(value) {
    return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;
  };
  
  module.exports = isArray;
  
  },{"../internal/getNative":62,"../internal/isLength":69,"../internal/isObjectLike":70}],84:[function(require,module,exports){
  var isObject = require('./isObject');
  
  /** `Object#toString` result references. */
  var funcTag = '[object Function]';
  
  /** Used for native method references. */
  var objectProto = Object.prototype;
  
  /**
   * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
   * of values.
   */
  var objToString = objectProto.toString;
  
  /**
   * Checks if `value` is classified as a `Function` object.
   *
   * @static
   * @memberOf _
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
   * @example
   *
   * _.isFunction(_);
   * // => true
   *
   * _.isFunction(/abc/);
   * // => false
   */
  function isFunction(value) {
    // The use of `Object#toString` avoids issues with the `typeof` operator
    // in older versions of Chrome and Safari which return 'function' for regexes
    // and Safari 8 equivalents which return 'object' for typed array constructors.
    return isObject(value) && objToString.call(value) == funcTag;
  }
  
  module.exports = isFunction;
  
  },{"./isObject":86}],85:[function(require,module,exports){
  var isFunction = require('./isFunction'),
      isHostObject = require('../internal/isHostObject'),
      isObjectLike = require('../internal/isObjectLike');
  
  /** Used to detect host constructors (Safari > 5). */
  var reIsHostCtor = /^\[object .+?Constructor\]$/;
  
  /** Used for native method references. */
  var objectProto = Object.prototype;
  
  /** Used to resolve the decompiled source of functions. */
  var fnToString = Function.prototype.toString;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /** Used to detect if a method is native. */
  var reIsNative = RegExp('^' +
    fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
    .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
  );
  
  /**
   * Checks if `value` is a native function.
   *
   * @static
   * @memberOf _
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a native function, else `false`.
   * @example
   *
   * _.isNative(Array.prototype.push);
   * // => true
   *
   * _.isNative(_);
   * // => false
   */
  function isNative(value) {
    if (value == null) {
      return false;
    }
    if (isFunction(value)) {
      return reIsNative.test(fnToString.call(value));
    }
    return isObjectLike(value) && (isHostObject(value) ? reIsNative : reIsHostCtor).test(value);
  }
  
  module.exports = isNative;
  
  },{"../internal/isHostObject":64,"../internal/isObjectLike":70,"./isFunction":84}],86:[function(require,module,exports){
  /**
   * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
   * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
   *
   * @static
   * @memberOf _
   * @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(1);
   * // => false
   */
  function isObject(value) {
    // Avoid a V8 JIT bug in Chrome 19-20.
    // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
    var type = typeof value;
    return !!value && (type == 'object' || type == 'function');
  }
  
  module.exports = isObject;
  
  },{}],87:[function(require,module,exports){
  var baseForIn = require('../internal/baseForIn'),
      isArguments = require('./isArguments'),
      isHostObject = require('../internal/isHostObject'),
      isObjectLike = require('../internal/isObjectLike'),
      support = require('../support');
  
  /** `Object#toString` result references. */
  var objectTag = '[object Object]';
  
  /** Used for native 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/6.0/#sec-object.prototype.tostring)
   * of values.
   */
  var objToString = objectProto.toString;
  
  /**
   * Checks if `value` is a plain object, that is, an object created by the
   * `Object` constructor or one with a `[[Prototype]]` of `null`.
   *
   * **Note:** This method assumes objects created by the `Object` constructor
   * have no inherited enumerable properties.
   *
   * @static
   * @memberOf _
   * @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) {
    var Ctor;
  
    // Exit early for non `Object` objects.
    if (!(isObjectLike(value) && objToString.call(value) == objectTag && !isHostObject(value) && !isArguments(value)) ||
        (!hasOwnProperty.call(value, 'constructor') && (Ctor = value.constructor, typeof Ctor == 'function' && !(Ctor instanceof Ctor)))) {
      return false;
    }
    // IE < 9 iterates inherited properties before own properties. If the first
    // iterated property is an object's own property then there are no inherited
    // enumerable properties.
    var result;
    if (support.ownLast) {
      baseForIn(value, function(subValue, key, object) {
        result = hasOwnProperty.call(object, key);
        return false;
      });
      return result !== false;
    }
    // In most environments an object's own properties are iterated before
    // its inherited properties. If the last iterated property is an object's
    // own property then there are no inherited enumerable properties.
    baseForIn(value, function(subValue, key) {
      result = key;
    });
    return result === undefined || hasOwnProperty.call(value, result);
  }
  
  module.exports = isPlainObject;
  
  },{"../internal/baseForIn":28,"../internal/isHostObject":64,"../internal/isObjectLike":70,"../support":94,"./isArguments":82}],88:[function(require,module,exports){
  var isObjectLike = require('../internal/isObjectLike');
  
  /** `Object#toString` result references. */
  var stringTag = '[object String]';
  
  /** Used for native method references. */
  var objectProto = Object.prototype;
  
  /**
   * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
   * of values.
   */
  var objToString = objectProto.toString;
  
  /**
   * Checks if `value` is classified as a `String` primitive or object.
   *
   * @static
   * @memberOf _
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
   * @example
   *
   * _.isString('abc');
   * // => true
   *
   * _.isString(1);
   * // => false
   */
  function isString(value) {
    return typeof value == 'string' || (isObjectLike(value) && objToString.call(value) == stringTag);
  }
  
  module.exports = isString;
  
  },{"../internal/isObjectLike":70}],89:[function(require,module,exports){
  var isLength = require('../internal/isLength'),
      isObjectLike = require('../internal/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]',
      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[dateTag] = typedArrayTags[errorTag] =
  typedArrayTags[funcTag] = typedArrayTags[mapTag] =
  typedArrayTags[numberTag] = typedArrayTags[objectTag] =
  typedArrayTags[regexpTag] = typedArrayTags[setTag] =
  typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
  
  /** Used for native method references. */
  var objectProto = Object.prototype;
  
  /**
   * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
   * of values.
   */
  var objToString = objectProto.toString;
  
  /**
   * Checks if `value` is classified as a typed array.
   *
   * @static
   * @memberOf _
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
   * @example
   *
   * _.isTypedArray(new Uint8Array);
   * // => true
   *
   * _.isTypedArray([]);
   * // => false
   */
  function isTypedArray(value) {
    return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)];
  }
  
  module.exports = isTypedArray;
  
  },{"../internal/isLength":69,"../internal/isObjectLike":70}],90:[function(require,module,exports){
  var assignWith = require('../internal/assignWith'),
      baseAssign = require('../internal/baseAssign'),
      createAssigner = require('../internal/createAssigner');
  
  /**
   * Assigns own enumerable properties of source object(s) to the destination
   * object. Subsequent sources overwrite property assignments of previous sources.
   * If `customizer` is provided it is invoked to produce the assigned values.
   * The `customizer` is bound to `thisArg` and invoked with five arguments:
   * (objectValue, sourceValue, key, object, source).
   *
   * **Note:** This method mutates `object` and is based on
   * [`Object.assign`](http://ecma-international.org/ecma-262/6.0/#sec-object.assign).
   *
   * @static
   * @memberOf _
   * @alias extend
   * @category Object
   * @param {Object} object The destination object.
   * @param {...Object} [sources] The source objects.
   * @param {Function} [customizer] The function to customize assigned values.
   * @param {*} [thisArg] The `this` binding of `customizer`.
   * @returns {Object} Returns `object`.
   * @example
   *
   * _.assign({ 'user': 'barney' }, { 'age': 40 }, { 'user': 'fred' });
   * // => { 'user': 'fred', 'age': 40 }
   *
   * // using a customizer callback
   * var defaults = _.partialRight(_.assign, function(value, other) {
   *   return _.isUndefined(value) ? other : value;
   * });
   *
   * defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });
   * // => { 'user': 'barney', 'age': 36 }
   */
  var assign = createAssigner(function(object, source, customizer) {
    return customizer
      ? assignWith(object, source, customizer)
      : baseAssign(object, source);
  });
  
  module.exports = assign;
  
  },{"../internal/assignWith":19,"../internal/baseAssign":20,"../internal/createAssigner":46}],91:[function(require,module,exports){
  var getNative = require('../internal/getNative'),
      isArrayLike = require('../internal/isArrayLike'),
      isObject = require('../lang/isObject'),
      shimKeys = require('../internal/shimKeys'),
      support = require('../support');
  
  /* Native method references for those with the same name as other `lodash` methods. */
  var nativeKeys = getNative(Object, 'keys');
  
  /**
   * 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/6.0/#sec-object.keys)
   * for more details.
   *
   * @static
   * @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']
   */
  var keys = !nativeKeys ? shimKeys : function(object) {
    var Ctor = object == null ? undefined : object.constructor;
    if ((typeof Ctor == 'function' && Ctor.prototype === object) ||
        (typeof object == 'function' ? support.enumPrototypes : isArrayLike(object))) {
      return shimKeys(object);
    }
    return isObject(object) ? nativeKeys(object) : [];
  };
  
  module.exports = keys;
  
  },{"../internal/getNative":62,"../internal/isArrayLike":63,"../internal/shimKeys":78,"../lang/isObject":86,"../support":94}],92:[function(require,module,exports){
  var arrayEach = require('../internal/arrayEach'),
      isArguments = require('../lang/isArguments'),
      isArray = require('../lang/isArray'),
      isFunction = require('../lang/isFunction'),
      isIndex = require('../internal/isIndex'),
      isLength = require('../internal/isLength'),
      isObject = require('../lang/isObject'),
      isString = require('../lang/isString'),
      support = require('../support');
  
  /** `Object#toString` result references. */
  var arrayTag = '[object Array]',
      boolTag = '[object Boolean]',
      dateTag = '[object Date]',
      errorTag = '[object Error]',
      funcTag = '[object Function]',
      numberTag = '[object Number]',
      objectTag = '[object Object]',
      regexpTag = '[object RegExp]',
      stringTag = '[object String]';
  
  /** Used to fix the JScript `[[DontEnum]]` bug. */
  var shadowProps = [
    'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',
    'toLocaleString', 'toString', 'valueOf'
  ];
  
  /** Used for native method references. */
  var errorProto = Error.prototype,
      objectProto = Object.prototype,
      stringProto = String.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
   * of values.
   */
  var objToString = objectProto.toString;
  
  /** Used to avoid iterating over non-enumerable properties in IE < 9. */
  var nonEnumProps = {};
  nonEnumProps[arrayTag] = nonEnumProps[dateTag] = nonEnumProps[numberTag] = { 'constructor': true, 'toLocaleString': true, 'toString': true, 'valueOf': true };
  nonEnumProps[boolTag] = nonEnumProps[stringTag] = { 'constructor': true, 'toString': true, 'valueOf': true };
  nonEnumProps[errorTag] = nonEnumProps[funcTag] = nonEnumProps[regexpTag] = { 'constructor': true, 'toString': true };
  nonEnumProps[objectTag] = { 'constructor': true };
  
  arrayEach(shadowProps, function(key) {
    for (var tag in nonEnumProps) {
      if (hasOwnProperty.call(nonEnumProps, tag)) {
        var props = nonEnumProps[tag];
        props[key] = hasOwnProperty.call(props, key);
      }
    }
  });
  
  /**
   * Creates an array of the own and inherited enumerable property names of `object`.
   *
   * **Note:** Non-object values are coerced to objects.
   *
   * @static
   * @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;
   *
   * _.keysIn(new Foo);
   * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
   */
  function keysIn(object) {
    if (object == null) {
      return [];
    }
    if (!isObject(object)) {
      object = Object(object);
    }
    var length = object.length;
  
    length = (length && isLength(length) &&
      (isArray(object) || isArguments(object) || isString(object)) && length) || 0;
  
    var Ctor = object.constructor,
        index = -1,
        proto = (isFunction(Ctor) && Ctor.prototype) || objectProto,
        isProto = proto === object,
        result = Array(length),
        skipIndexes = length > 0,
        skipErrorProps = support.enumErrorProps && (object === errorProto || object instanceof Error),
        skipProto = support.enumPrototypes && isFunction(object);
  
    while (++index < length) {
      result[index] = (index + '');
    }
    // lodash skips the `constructor` property when it infers it is iterating
    // over a `prototype` object because IE < 9 can't set the `[[Enumerable]]`
    // attribute of an existing property and the `constructor` property of a
    // prototype defaults to non-enumerable.
    for (var key in object) {
      if (!(skipProto && key == 'prototype') &&
          !(skipErrorProps && (key == 'message' || key == 'name')) &&
          !(skipIndexes && isIndex(key, length)) &&
          !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
        result.push(key);
      }
    }
    if (support.nonEnumShadows && object !== objectProto) {
      var tag = object === stringProto ? stringTag : (object === errorProto ? errorTag : objToString.call(object)),
          nonEnums = nonEnumProps[tag] || nonEnumProps[objectTag];
  
      if (tag == objectTag) {
        proto = objectProto;
      }
      length = shadowProps.length;
      while (length--) {
        key = shadowProps[length];
        var nonEnum = nonEnums[key];
        if (!(isProto && nonEnum) &&
            (nonEnum ? hasOwnProperty.call(object, key) : object[key] !== proto[key])) {
          result.push(key);
        }
      }
    }
    return result;
  }
  
  module.exports = keysIn;
  
  },{"../internal/arrayEach":14,"../internal/isIndex":65,"../internal/isLength":69,"../lang/isArguments":82,"../lang/isArray":83,"../lang/isFunction":84,"../lang/isObject":86,"../lang/isString":88,"../support":94}],93:[function(require,module,exports){
  var keys = require('./keys'),
      toObject = require('../internal/toObject');
  
  /**
   * Creates a two dimensional array of the key-value pairs for `object`,
   * e.g. `[[key1, value1], [key2, value2]]`.
   *
   * @static
   * @memberOf _
   * @category Object
   * @param {Object} object The object to query.
   * @returns {Array} Returns the new array of key-value pairs.
   * @example
   *
   * _.pairs({ 'barney': 36, 'fred': 40 });
   * // => [['barney', 36], ['fred', 40]] (iteration order is not guaranteed)
   */
  function pairs(object) {
    object = toObject(object);
  
    var index = -1,
        props = keys(object),
        length = props.length,
        result = Array(length);
  
    while (++index < length) {
      var key = props[index];
      result[index] = [key, object[key]];
    }
    return result;
  }
  
  module.exports = pairs;
  
  },{"../internal/toObject":79,"./keys":91}],94:[function(require,module,exports){
  /** Used for native method references. */
  var arrayProto = Array.prototype,
      errorProto = Error.prototype,
      objectProto = Object.prototype;
  
  /** Native method references. */
  var propertyIsEnumerable = objectProto.propertyIsEnumerable,
      splice = arrayProto.splice;
  
  /**
   * An object environment feature flags.
   *
   * @static
   * @memberOf _
   * @type Object
   */
  var support = {};
  
  (function(x) {
    var Ctor = function() { this.x = x; },
        object = { '0': x, 'length': x },
        props = [];
  
    Ctor.prototype = { 'valueOf': x, 'y': x };
    for (var key in new Ctor) { props.push(key); }
  
    /**
     * Detect if `name` or `message` properties of `Error.prototype` are
     * enumerable by default (IE < 9, Safari < 5.1).
     *
     * @memberOf _.support
     * @type boolean
     */
    support.enumErrorProps = propertyIsEnumerable.call(errorProto, 'message') ||
      propertyIsEnumerable.call(errorProto, 'name');
  
    /**
     * Detect if `prototype` properties are enumerable by default.
     *
     * Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1
     * (if the prototype or a property on the prototype has been set)
     * incorrectly set the `[[Enumerable]]` value of a function's `prototype`
     * property to `true`.
     *
     * @memberOf _.support
     * @type boolean
     */
    support.enumPrototypes = propertyIsEnumerable.call(Ctor, 'prototype');
  
    /**
     * Detect if properties shadowing those on `Object.prototype` are non-enumerable.
     *
     * In IE < 9 an object's own properties, shadowing non-enumerable ones,
     * are made non-enumerable as well (a.k.a the JScript `[[DontEnum]]` bug).
     *
     * @memberOf _.support
     * @type boolean
     */
    support.nonEnumShadows = !/valueOf/.test(props);
  
    /**
     * Detect if own properties are iterated after inherited properties (IE < 9).
     *
     * @memberOf _.support
     * @type boolean
     */
    support.ownLast = props[0] != 'x';
  
    /**
     * Detect if `Array#shift` and `Array#splice` augment array-like objects
     * correctly.
     *
     * Firefox < 10, compatibility modes of IE 8, and IE < 9 have buggy Array
     * `shift()` and `splice()` functions that fail to remove the last element,
     * `value[0]`, of array-like objects even though the "length" property is
     * set to `0`. The `shift()` method is buggy in compatibility modes of IE 8,
     * while `splice()` is buggy regardless of mode in IE < 9.
     *
     * @memberOf _.support
     * @type boolean
     */
    support.spliceObjects = (splice.call(object, 0, 1), !object[0]);
  
    /**
     * Detect lack of support for accessing string characters by index.
     *
     * IE < 8 can't access characters by index. IE 8 can only access characters
     * by index on string literals, not string objects.
     *
     * @memberOf _.support
     * @type boolean
     */
    support.unindexedChars = ('x'[0] + Object('x')[0]) != 'xx';
  }(1, 0));
  
  module.exports = support;
  
  },{}],95:[function(require,module,exports){
  /**
   * This method returns the first argument provided to it.
   *
   * @static
   * @memberOf _
   * @category Utility
   * @param {*} value Any value.
   * @returns {*} Returns `value`.
   * @example
   *
   * var object = { 'user': 'fred' };
   *
   * _.identity(object) === object;
   * // => true
   */
  function identity(value) {
    return value;
  }
  
  module.exports = identity;
  
  },{}],96:[function(require,module,exports){
  /**
   * A no-operation function that returns `undefined` regardless of the
   * arguments it receives.
   *
   * @static
   * @memberOf _
   * @category Utility
   * @example
   *
   * var object = { 'user': 'fred' };
   *
   * _.noop(object) === undefined;
   * // => true
   */
  function noop() {
    // No operation performed.
  }
  
  module.exports = noop;
  
  },{}],97:[function(require,module,exports){
  var baseProperty = require('../internal/baseProperty'),
      basePropertyDeep = require('../internal/basePropertyDeep'),
      isKey = require('../internal/isKey');
  
  /**
   * Creates a function that returns the property value at `path` on a
   * given object.
   *
   * @static
   * @memberOf _
   * @category Utility
   * @param {Array|string} path The path of the property to get.
   * @returns {Function} Returns the new function.
   * @example
   *
   * var objects = [
   *   { 'a': { 'b': { 'c': 2 } } },
   *   { 'a': { 'b': { 'c': 1 } } }
   * ];
   *
   * _.map(objects, _.property('a.b.c'));
   * // => [2, 1]
   *
   * _.pluck(_.sortBy(objects, _.property(['a', 'b', 'c'])), 'a.b.c');
   * // => [1, 2]
   */
  function property(path) {
    return isKey(path) ? baseProperty(path) : basePropertyDeep(path);
  }
  
  module.exports = property;
  
  },{"../internal/baseProperty":38,"../internal/basePropertyDeep":39,"../internal/isKey":67}],98:[function(require,module,exports){
  'use strict';
  
  var _ = require('../common/utils.js');
  
  var css = {
    wrapper: {
      position: 'relative',
      display: 'inline-block'
    },
    hint: {
      position: 'absolute',
      top: '0',
      left: '0',
      borderColor: 'transparent',
      boxShadow: 'none',
      // #741: fix hint opacity issue on iOS
      opacity: '1'
    },
    input: {
      position: 'relative',
      verticalAlign: 'top',
      backgroundColor: 'transparent'
    },
    inputWithNoHint: {
      position: 'relative',
      verticalAlign: 'top'
    },
    dropdown: {
      position: 'absolute',
      top: '100%',
      left: '0',
      zIndex: '100',
      display: 'none'
    },
    suggestions: {
      display: 'block'
    },
    suggestion: {
      whiteSpace: 'nowrap',
      cursor: 'pointer'
    },
    suggestionChild: {
      whiteSpace: 'normal'
    },
    ltr: {
      left: '0',
      right: 'auto'
    },
    rtl: {
      left: 'auto',
      right: '0'
    }
  };
  
  // ie specific styling
  if (_.isMsie()) {
    // ie6-8 (and 9?) doesn't fire hover and click events for elements with
    // transparent backgrounds, for a workaround, use 1x1 transparent gif
    _.mixin(css.input, {
      backgroundImage: 'url(data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)'
    });
  }
  
  // ie7 and under specific styling
  if (_.isMsie() && _.isMsie() <= 7) {
    // if someone can tell me why this is necessary to align
    // the hint with the query in ie7, i'll send you $5 - @JakeHarding
    _.mixin(css.input, {marginTop: '-1px'});
  }
  
  module.exports = css;
  
  },{"../common/utils.js":106}],99:[function(require,module,exports){
  'use strict';
  
  var datasetKey = 'aaDataset';
  var valueKey = 'aaValue';
  var datumKey = 'aaDatum';
  
  var _ = require('../common/utils.js');
  var html = require('./html.js');
  var css = require('./css.js');
  var EventEmitter = require('./event_emitter.js');
  
  // constructor
  // -----------
  
  function Dataset(o) {
    o = o || {};
    o.templates = o.templates || {};
  
    if (!o.source) {
      _.error('missing source');
    }
  
    if (o.name && !isValidName(o.name)) {
      _.error('invalid dataset name: ' + o.name);
    }
  
    // tracks the last query the dataset was updated for
    this.query = null;
  
    this.highlight = !!o.highlight;
    this.name = o.name || _.getUniqueId();
  
    this.source = o.source;
    this.displayFn = getDisplayFn(o.display || o.displayKey);
  
    this.templates = getTemplates(o.templates, this.displayFn);
  
    this.$el = o.$menu && this.name && o.$menu.find('.aa-dataset-' + this.name).length > 0 ?
      $(o.$menu.find('.aa-dataset-' + this.name)[0]) : $(html.dataset.replace('%CLASS%', this.name));
  
    this.$menu = o.$menu;
  }
  
  // static methods
  // --------------
  
  Dataset.extractDatasetName = function extractDatasetName(el) {
    return $(el).data(datasetKey);
  };
  
  Dataset.extractValue = function extractDatum(el) {
    return $(el).data(valueKey);
  };
  
  Dataset.extractDatum = function extractDatum(el) {
    return $(el).data(datumKey);
  };
  
  // instance methods
  // ----------------
  
  _.mixin(Dataset.prototype, EventEmitter, {
  
    // ### private
  
    _render: function render(query, suggestions) {
      if (!this.$el) {
        return;
      }
  
      var that = this;
      var hasSuggestions;
      var renderArgs = [].slice.call(arguments, 2);
  
      this.$el.empty();
      hasSuggestions = suggestions && suggestions.length;
  
      if (!hasSuggestions && this.templates.empty) {
        this.$el
          .html(getEmptyHtml.apply(this, renderArgs))
          .prepend(that.templates.header ? getHeaderHtml.apply(this, renderArgs) : null)
          .append(that.templates.footer ? getFooterHtml.apply(this, renderArgs) : null);
      } else if (hasSuggestions) {
        this.$el
          .html(getSuggestionsHtml.apply(this, renderArgs))
          .prepend(that.templates.header ? getHeaderHtml.apply(this, renderArgs) : null)
          .append(that.templates.footer ? getFooterHtml.apply(this, renderArgs) : null);
      }
  
      if (this.$menu) {
        this.$menu.addClass('aa-' + (hasSuggestions ? 'with' : 'without') + '-' + this.name)
          .removeClass('aa-' + (hasSuggestions ? 'without' : 'with') + '-' + this.name);
      }
  
      this.trigger('rendered');
  
      function getEmptyHtml() {
        var args = [].slice.call(arguments, 0);
        args = [{query: query, isEmpty: true}].concat(args);
        return that.templates.empty.apply(this, args);
      }
  
      function getSuggestionsHtml() {
        var args = [].slice.call(arguments, 0);
        var $suggestions;
        var nodes;
  
        $suggestions = $(html.suggestions).css(css.suggestions);
  
        // jQuery#append doesn't support arrays as the first argument
        // until version 1.8, see http://bugs.jquery.com/ticket/11231
        nodes = _.map(suggestions, getSuggestionNode);
        $suggestions.append.apply($suggestions, nodes);
  
        return $suggestions;
  
        function getSuggestionNode(suggestion) {
          var $el;
  
          $el = $(html.suggestion)
            .append(that.templates.suggestion.apply(this, [suggestion].concat(args)))
            .data(datasetKey, that.name)
            .data(valueKey, that.displayFn(suggestion))
            .data(datumKey, suggestion);
  
          $el.children().each(function() { $(this).css(css.suggestionChild); });
  
          return $el;
        }
      }
  
      function getHeaderHtml() {
        var args = [].slice.call(arguments, 0);
        args = [{query: query, isEmpty: !hasSuggestions}].concat(args);
        return that.templates.header.apply(this, args);
      }
  
      function getFooterHtml() {
        var args = [].slice.call(arguments, 0);
        args = [{query: query, isEmpty: !hasSuggestions}].concat(args);
        return that.templates.footer.apply(this, args);
      }
    },
  
    // ### public
  
    getRoot: function getRoot() {
      return this.$el;
    },
  
    update: function update(query) {
      var that = this;
  
      this.query = query;
      this.canceled = false;
      this.source(query, render);
  
      function render(suggestions) {
        // if the update has been canceled or if the query has changed
        // do not render the suggestions as they've become outdated
        if (!that.canceled && query === that.query) {
          // concat all the other arguments that could have been passed
          // to the render function, and forward them to _render
          var args = [].slice.call(arguments, 1);
          args = [query, suggestions].concat(args);
          that._render.apply(that, args);
        }
      }
    },
  
    cancel: function cancel() {
      this.canceled = true;
    },
  
    clear: function clear() {
      this.cancel();
      this.$el.empty();
      this.trigger('rendered');
    },
  
    isEmpty: function isEmpty() {
      return this.$el.is(':empty');
    },
  
    destroy: function destroy() {
      this.$el = null;
    }
  });
  
  // helper functions
  // ----------------
  
  function getDisplayFn(display) {
    display = display || 'value';
  
    return _.isFunction(display) ? display : displayFn;
  
    function displayFn(obj) {
      return obj[display];
    }
  }
  
  function getTemplates(templates, displayFn) {
    return {
      empty: templates.empty && _.templatify(templates.empty),
      header: templates.header && _.templatify(templates.header),
      footer: templates.footer && _.templatify(templates.footer),
      suggestion: templates.suggestion || suggestionTemplate
    };
  
    function suggestionTemplate(context) {
      return '<p>' + displayFn(context) + '</p>';
    }
  }
  
  function isValidName(str) {
    // dashes, underscores, letters, and numbers
    return (/^[_a-zA-Z0-9-]+$/).test(str);
  }
  
  module.exports = Dataset;
  
  },{"../common/utils.js":106,"./css.js":98,"./event_emitter.js":102,"./html.js":103}],100:[function(require,module,exports){
  'use strict';
  
  var _ = require('../common/utils.js');
  var EventEmitter = require('./event_emitter.js');
  var Dataset = require('./dataset.js');
  var css = require('./css.js');
  
  // constructor
  // -----------
  
  function Dropdown(o) {
    var that = this;
    var onSuggestionClick;
    var onSuggestionMouseEnter;
    var onSuggestionMouseLeave;
  
    o = o || {};
  
    if (!o.menu) {
      _.error('menu is required');
    }
  
    if (!_.isArray(o.datasets) && !_.isObject(o.datasets)) {
      _.error('1 or more datasets required');
    }
    if (!o.datasets) {
      $.error('datasets is required');
    }
  
    this.isOpen = false;
    this.isEmpty = true;
  
    // bound functions
    onSuggestionClick = _.bind(this._onSuggestionClick, this);
    onSuggestionMouseEnter = _.bind(this._onSuggestionMouseEnter, this);
    onSuggestionMouseLeave = _.bind(this._onSuggestionMouseLeave, this);
  
    this.$menu = $(o.menu)
      .on('click.aa', '.aa-suggestion', onSuggestionClick)
      .on('mouseenter.aa', '.aa-suggestion', onSuggestionMouseEnter)
      .on('mouseleave.aa', '.aa-suggestion', onSuggestionMouseLeave);
  
    if (o.templates && o.templates.header) {
      this.$menu.prepend(_.templatify(o.templates.header));
    }
  
    this.datasets = _.map(o.datasets, function(oDataset) { return initializeDataset(that.$menu, oDataset); });
    _.each(this.datasets, function(dataset) {
      var root = dataset.getRoot();
      if (root && root.parent().length === 0) {
        that.$menu.append(root);
      }
      dataset.onSync('rendered', that._onRendered, that);
    });
  
    if (o.templates && o.templates.footer) {
      this.$menu.append(_.templatify(o.templates.footer));
    }
  }
  
  // instance methods
  // ----------------
  
  _.mixin(Dropdown.prototype, EventEmitter, {
  
    // ### private
  
    _onSuggestionClick: function onSuggestionClick($e) {
      this.trigger('suggestionClicked', $($e.currentTarget));
    },
  
    _onSuggestionMouseEnter: function onSuggestionMouseEnter($e) {
      this._removeCursor();
      this._setCursor($($e.currentTarget), true);
    },
  
    _onSuggestionMouseLeave: function onSuggestionMouseLeave() {
      this._removeCursor();
    },
  
    _onRendered: function onRendered() {
      this.isEmpty = _.every(this.datasets, isDatasetEmpty);
  
      if (this.isEmpty) {
        this._hide();
      } else if (this.isOpen) {
        this._show();
      }
  
      this.trigger('datasetRendered');
  
      function isDatasetEmpty(dataset) {
        return dataset.isEmpty();
      }
    },
  
    _hide: function() {
      this.$menu.hide();
    },
  
    _show: function() {
      // can't use jQuery#show because $menu is a span element we want
      // display: block; not dislay: inline;
      this.$menu.css('display', 'block');
    },
  
    _getSuggestions: function getSuggestions() {
      return this.$menu.find('.aa-suggestion');
    },
  
    _getCursor: function getCursor() {
      return this.$menu.find('.aa-cursor').first();
    },
  
    _setCursor: function setCursor($el, silent) {
      $el.first().addClass('aa-cursor');
  
      if (!silent) {
        this.trigger('cursorMoved');
      }
    },
  
    _removeCursor: function removeCursor() {
      this._getCursor().removeClass('aa-cursor');
    },
  
    _moveCursor: function moveCursor(increment) {
      var $suggestions;
      var $oldCursor;
      var newCursorIndex;
      var $newCursor;
  
      if (!this.isOpen) {
        return;
      }
  
      $oldCursor = this._getCursor();
      $suggestions = this._getSuggestions();
  
      this._removeCursor();
  
      // shifting before and after modulo to deal with -1 index
      newCursorIndex = $suggestions.index($oldCursor) + increment;
      newCursorIndex = (newCursorIndex + 1) % ($suggestions.length + 1) - 1;
  
      if (newCursorIndex === -1) {
        this.trigger('cursorRemoved');
  
        return;
      } else if (newCursorIndex < -1) {
        newCursorIndex = $suggestions.length - 1;
      }
  
      this._setCursor($newCursor = $suggestions.eq(newCursorIndex));
  
      // in the case of scrollable overflow
      // make sure the cursor is visible in the menu
      this._ensureVisible($newCursor);
    },
  
    _ensureVisible: function ensureVisible($el) {
      var elTop;
      var elBottom;
      var menuScrollTop;
      var menuHeight;
  
      elTop = $el.position().top;
      elBottom = elTop + $el.outerHeight(true);
      menuScrollTop = this.$menu.scrollTop();
      menuHeight = this.$menu.height() +
        parseInt(this.$menu.css('paddingTop'), 10) +
        parseInt(this.$menu.css('paddingBottom'), 10);
  
      if (elTop < 0) {
        this.$menu.scrollTop(menuScrollTop + elTop);
      } else if (menuHeight < elBottom) {
        this.$menu.scrollTop(menuScrollTop + (elBottom - menuHeight));
      }
    },
  
    // ### public
  
    close: function close() {
      if (this.isOpen) {
        this.isOpen = false;
  
        this._removeCursor();
        this._hide();
  
        this.trigger('closed');
      }
    },
  
    open: function open() {
      if (!this.isOpen) {
        this.isOpen = true;
  
        if (!this.isEmpty) {
          this._show();
        }
  
        this.trigger('opened');
      }
    },
  
    setLanguageDirection: function setLanguageDirection(dir) {
      this.$menu.css(dir === 'ltr' ? css.ltr : css.rtl);
    },
  
    moveCursorUp: function moveCursorUp() {
      this._moveCursor(-1);
    },
  
    moveCursorDown: function moveCursorDown() {
      this._moveCursor(+1);
    },
  
    getDatumForSuggestion: function getDatumForSuggestion($el) {
      var datum = null;
  
      if ($el.length) {
        datum = {
          raw: Dataset.extractDatum($el),
          value: Dataset.extractValue($el),
          datasetName: Dataset.extractDatasetName($el)
        };
      }
  
      return datum;
    },
  
    getDatumForCursor: function getDatumForCursor() {
      return this.getDatumForSuggestion(this._getCursor().first());
    },
  
    getDatumForTopSuggestion: function getDatumForTopSuggestion() {
      return this.getDatumForSuggestion(this._getSuggestions().first());
    },
  
    update: function update(query) {
      _.each(this.datasets, updateDataset);
  
      function updateDataset(dataset) {
        dataset.update(query);
      }
    },
  
    empty: function empty() {
      _.each(this.datasets, clearDataset);
      this.isEmpty = true;
  
      function clearDataset(dataset) {
        dataset.clear();
      }
    },
  
    isVisible: function isVisible() {
      return this.isOpen && !this.isEmpty;
    },
  
    destroy: function destroy() {
      this.$menu.off('.aa');
  
      this.$menu = null;
  
      _.each(this.datasets, destroyDataset);
  
      function destroyDataset(dataset) {
        dataset.destroy();
      }
    }
  });
  
  // helper functions
  // ----------------
  Dropdown.Dataset = Dataset;
  
  function initializeDataset($menu, oDataset) {
    return new Dropdown.Dataset(_.mixin({'$menu': $menu}, oDataset));
  }
  
  module.exports = Dropdown;
  
  },{"../common/utils.js":106,"./css.js":98,"./dataset.js":99,"./event_emitter.js":102}],101:[function(require,module,exports){
  'use strict';
  
  var namespace = 'autocomplete:';
  
  var _ = require('../common/utils.js');
  
  // constructor
  // -----------
  
  function EventBus(o) {
    if (!o || !o.el) {
      _.error('EventBus initialized without el');
    }
  
    this.$el = $(o.el);
  }
  
  // instance methods
  // ----------------
  
  _.mixin(EventBus.prototype, {
  
    // ### public
  
    trigger: function(type) {
      var args = [].slice.call(arguments, 1);
  
      this.$el.trigger(namespace + type, args);
    }
  });
  
  module.exports = EventBus;
  
  },{"../common/utils.js":106}],102:[function(require,module,exports){
  'use strict';
  
  var splitter = /\s+/;
  var nextTick = getNextTick();
  
  module.exports = {
    onSync: onSync,
    onAsync: onAsync,
    off: off,
    trigger: trigger
  };
  
  function on(method, types, cb, context) {
    var type;
  
    if (!cb) {
      return this;
    }
  
    types = types.split(splitter);
    cb = context ? bindContext(cb, context) : cb;
  
    this._callbacks = this._callbacks || {};
  
    while (type = types.shift()) {
      this._callbacks[type] = this._callbacks[type] || {sync: [], async: []};
      this._callbacks[type][method].push(cb);
    }
  
    return this;
  }
  
  function onAsync(types, cb, context) {
    return on.call(this, 'async', types, cb, context);
  }
  
  function onSync(types, cb, context) {
    return on.call(this, 'sync', types, cb, context);
  }
  
  function off(types) {
    var type;
  
    if (!this._callbacks) {
      return this;
    }
  
    types = types.split(splitter);
  
    while (type = types.shift()) {
      delete this._callbacks[type];
    }
  
    return this;
  }
  
  function trigger(types) {
    var type;
    var callbacks;
    var args;
    var syncFlush;
    var asyncFlush;
  
    if (!this._callbacks) {
      return this;
    }
  
    types = types.split(splitter);
    args = [].slice.call(arguments, 1);
  
    while ((type = types.shift()) && (callbacks = this._callbacks[type])) { // eslint-disable-line
      syncFlush = getFlush(callbacks.sync, this, [type].concat(args));
      asyncFlush = getFlush(callbacks.async, this, [type].concat(args));
  
      if (syncFlush()) {
        nextTick(asyncFlush);
      }
    }
  
    return this;
  }
  
  function getFlush(callbacks, context, args) {
    return flush;
  
    function flush() {
      var cancelled;
  
      for (var i = 0, len = callbacks.length; !cancelled && i < len; i += 1) {
        // only cancel if the callback explicitly returns false
        cancelled = callbacks[i].apply(context, args) === false;
      }
  
      return !cancelled;
    }
  }
  
  function getNextTick() {
    var nextTickFn;
  
    if (window.setImmediate) { // IE10+
      nextTickFn = function nextTickSetImmediate(fn) {
        setImmediate(function() { fn(); });
      };
    } else { // old browsers
      nextTickFn = function nextTickSetTimeout(fn) {
        setTimeout(function() { fn(); }, 0);
      };
    }
  
    return nextTickFn;
  }
  
  function bindContext(fn, context) {
    return fn.bind ?
      fn.bind(context) :
      function() { fn.apply(context, [].slice.call(arguments, 0)); };
  }
  
  },{}],103:[function(require,module,exports){
  'use strict';
  
  module.exports = {
    wrapper: '<span class="algolia-autocomplete"></span>',
    dropdown: '<span class="aa-dropdown-menu"></span>',
    dataset: '<div class="aa-dataset-%CLASS%"></div>',
    suggestions: '<span class="aa-suggestions"></span>',
    suggestion: '<div class="aa-suggestion"></div>'
  };
  
  },{}],104:[function(require,module,exports){
  'use strict';
  
  var specialKeyCodeMap;
  
  specialKeyCodeMap = {
    9: 'tab',
    27: 'esc',
    37: 'left',
    39: 'right',
    13: 'enter',
    38: 'up',
    40: 'down'
  };
  
  var _ = require('../common/utils.js');
  var EventEmitter = require('./event_emitter.js');
  
  // constructor
  // -----------
  
  function Input(o) {
    var that = this;
    var onBlur;
    var onFocus;
    var onKeydown;
    var onInput;
  
    o = o || {};
  
    if (!o.input) {
      _.error('input is missing');
    }
  
    // bound functions
    onBlur = _.bind(this._onBlur, this);
    onFocus = _.bind(this._onFocus, this);
    onKeydown = _.bind(this._onKeydown, this);
    onInput = _.bind(this._onInput, this);
  
    this.$hint = $(o.hint);
    this.$input = $(o.input)
      .on('blur.aa', onBlur)
      .on('focus.aa', onFocus)
      .on('keydown.aa', onKeydown);
  
    // if no hint, noop all the hint related functions
    if (this.$hint.length === 0) {
      this.setHint = this.getHint = this.clearHint = this.clearHintIfInvalid = _.noop;
    }
  
    // ie7 and ie8 don't support the input event
    // ie9 doesn't fire the input event when characters are removed
    // not sure if ie10 is compatible
    if (!_.isMsie()) {
      this.$input.on('input.aa', onInput);
    } else {
      this.$input.on('keydown.aa keypress.aa cut.aa paste.aa', function($e) {
        // if a special key triggered this, ignore it
        if (specialKeyCodeMap[$e.which || $e.keyCode]) {
          return;
        }
  
        // give the browser a chance to update the value of the input
        // before checking to see if the query changed
        _.defer(_.bind(that._onInput, that, $e));
      });
    }
  
    // the query defaults to whatever the value of the input is
    // on initialization, it'll most likely be an empty string
    this.query = this.$input.val();
  
    // helps with calculating the width of the input's value
    this.$overflowHelper = buildOverflowHelper(this.$input);
  }
  
  // static methods
  // --------------
  
  Input.normalizeQuery = function(str) {
    // strips leading whitespace and condenses all whitespace
    return (str || '').replace(/^\s*/g, '').replace(/\s{2,}/g, ' ');
  };
  
  // instance methods
  // ----------------
  
  _.mixin(Input.prototype, EventEmitter, {
  
    // ### private
  
    _onBlur: function onBlur() {
      this.resetInputValue();
      this.trigger('blurred');
    },
  
    _onFocus: function onFocus() {
      this.trigger('focused');
    },
  
    _onKeydown: function onKeydown($e) {
      // which is normalized and consistent (but not for ie)
      var keyName = specialKeyCodeMap[$e.which || $e.keyCode];
  
      this._managePreventDefault(keyName, $e);
      if (keyName && this._shouldTrigger(keyName, $e)) {
        this.trigger(keyName + 'Keyed', $e);
      }
    },
  
    _onInput: function onInput() {
      this._checkInputValue();
    },
  
    _managePreventDefault: function managePreventDefault(keyName, $e) {
      var preventDefault;
      var hintValue;
      var inputValue;
  
      switch (keyName) {
        case 'tab':
          hintValue = this.getHint();
          inputValue = this.getInputValue();
  
          preventDefault = hintValue &&
            hintValue !== inputValue &&
            !withModifier($e);
          break;
  
        case 'up':
        case 'down':
          preventDefault = !withModifier($e);
          break;
  
        default:
          preventDefault = false;
      }
  
      if (preventDefault) {
        $e.preventDefault();
      }
    },
  
    _shouldTrigger: function shouldTrigger(keyName, $e) {
      var trigger;
  
      switch (keyName) {
        case 'tab':
          trigger = !withModifier($e);
          break;
  
        default:
          trigger = true;
      }
  
      return trigger;
    },
  
    _checkInputValue: function checkInputValue() {
      var inputValue;
      var areEquivalent;
      var hasDifferentWhitespace;
  
      inputValue = this.getInputValue();
      areEquivalent = areQueriesEquivalent(inputValue, this.query);
      hasDifferentWhitespace = areEquivalent ?
        this.query.length !== inputValue.length : false;
  
      this.query = inputValue;
  
      if (!areEquivalent) {
        this.trigger('queryChanged', this.query);
      } else if (hasDifferentWhitespace) {
        this.trigger('whitespaceChanged', this.query);
      }
    },
  
    // ### public
  
    focus: function focus() {
      this.$input.focus();
    },
  
    blur: function blur() {
      this.$input.blur();
    },
  
    getQuery: function getQuery() {
      return this.query;
    },
  
    setQuery: function setQuery(query) {
      this.query = query;
    },
  
    getInputValue: function getInputValue() {
      return this.$input.val();
    },
  
    setInputValue: function setInputValue(value, silent) {
      this.$input.val(value);
  
      // silent prevents any additional events from being triggered
      if (silent) {
        this.clearHint();
      } else {
        this._checkInputValue();
      }
    },
  
    resetInputValue: function resetInputValue() {
      this.setInputValue(this.query, true);
    },
  
    getHint: function getHint() {
      return this.$hint.val();
    },
  
    setHint: function setHint(value) {
      this.$hint.val(value);
    },
  
    clearHint: function clearHint() {
      this.setHint('');
    },
  
    clearHintIfInvalid: function clearHintIfInvalid() {
      var val;
      var hint;
      var valIsPrefixOfHint;
      var isValid;
  
      val = this.getInputValue();
      hint = this.getHint();
      valIsPrefixOfHint = val !== hint && hint.indexOf(val) === 0;
      isValid = val !== '' && valIsPrefixOfHint && !this.hasOverflow();
  
      if (!isValid) {
        this.clearHint();
      }
    },
  
    getLanguageDirection: function getLanguageDirection() {
      return (this.$input.css('direction') || 'ltr').toLowerCase();
    },
  
    hasOverflow: function hasOverflow() {
      // 2 is arbitrary, just picking a small number to handle edge cases
      var constraint = this.$input.width() - 2;
  
      this.$overflowHelper.text(this.getInputValue());
  
      return this.$overflowHelper.width() >= constraint;
    },
  
    isCursorAtEnd: function() {
      var valueLength;
      var selectionStart;
      var range;
  
      valueLength = this.$input.val().length;
      selectionStart = this.$input[0].selectionStart;
  
      if (_.isNumber(selectionStart)) {
        return selectionStart === valueLength;
      } else if (document.selection) {
        // NOTE: this won't work unless the input has focus, the good news
        // is this code should only get called when the input has focus
        range = document.selection.createRange();
        range.moveStart('character', -valueLength);
  
        return valueLength === range.text.length;
      }
  
      return true;
    },
  
    destroy: function destroy() {
      this.$hint.off('.aa');
      this.$input.off('.aa');
  
      this.$hint = this.$input = this.$overflowHelper = null;
    }
  });
  
  // helper functions
  // ----------------
  
  function buildOverflowHelper($input) {
    return $('<pre aria-hidden="true"></pre>')
      .css({
        // position helper off-screen
        position: 'absolute',
        visibility: 'hidden',
        // avoid line breaks and whitespace collapsing
        whiteSpace: 'pre',
        // use same font css as input to calculate accurate width
        fontFamily: $input.css('font-family'),
        fontSize: $input.css('font-size'),
        fontStyle: $input.css('font-style'),
        fontVariant: $input.css('font-variant'),
        fontWeight: $input.css('font-weight'),
        wordSpacing: $input.css('word-spacing'),
        letterSpacing: $input.css('letter-spacing'),
        textIndent: $input.css('text-indent'),
        textRendering: $input.css('text-rendering'),
        textTransform: $input.css('text-transform')
      })
      .insertAfter($input);
  }
  
  function areQueriesEquivalent(a, b) {
    return Input.normalizeQuery(a) === Input.normalizeQuery(b);
  }
  
  function withModifier($e) {
    return $e.altKey || $e.ctrlKey || $e.metaKey || $e.shiftKey;
  }
  
  module.exports = Input;
  
  },{"../common/utils.js":106,"./event_emitter.js":102}],105:[function(require,module,exports){
  'use strict';
  
  var attrsKey = 'aaAttrs';
  
  var _ = require('../common/utils.js');
  var EventBus = require('./event_bus.js');
  var Input = require('./input.js');
  var Dropdown = require('./dropdown.js');
  var html = require('./html.js');
  var css = require('./css.js');
  
  // constructor
  // -----------
  
  // THOUGHT: what if datasets could dynamically be added/removed?
  function Typeahead(o) {
    var $menu;
    var $input;
    var $hint;
  
    o = o || {};
  
    if (!o.input) {
      _.error('missing input');
    }
  
    this.isActivated = false;
    this.debug = !!o.debug;
    this.autoselect = !!o.autoselect;
    this.openOnFocus = !!o.openOnFocus;
    this.minLength = _.isNumber(o.minLength) ? o.minLength : 1;
    this.$node = buildDom(o);
  
    $menu = this.$node.find('.aa-dropdown-menu');
    $input = this.$node.find('.aa-input');
    $hint = this.$node.find('.aa-hint');
  
    // #705: if there's scrollable overflow, ie doesn't support
    // blur cancellations when the scrollbar is clicked
    //
    // #351: preventDefault won't cancel blurs in ie <= 8
    $input.on('blur.aa', function($e) {
      var active;
      var isActive;
      var hasActive;
  
      active = document.activeElement;
      isActive = $menu.is(active);
      hasActive = $menu.has(active).length > 0;
  
      if (_.isMsie() && (isActive || hasActive)) {
        $e.preventDefault();
        // stop immediate in order to prevent Input#_onBlur from
        // getting exectued
        $e.stopImmediatePropagation();
        _.defer(function() { $input.focus(); });
      }
    });
  
    // #351: prevents input blur due to clicks within dropdown menu
    $menu.on('mousedown.aa', function($e) { $e.preventDefault(); });
  
    this.eventBus = o.eventBus || new EventBus({el: $input});
  
    this.dropdown = new Typeahead.Dropdown({menu: $menu, datasets: o.datasets, templates: o.templates})
      .onSync('suggestionClicked', this._onSuggestionClicked, this)
      .onSync('cursorMoved', this._onCursorMoved, this)
      .onSync('cursorRemoved', this._onCursorRemoved, this)
      .onSync('opened', this._onOpened, this)
      .onSync('closed', this._onClosed, this)
      .onAsync('datasetRendered', this._onDatasetRendered, this);
  
    this.input = new Typeahead.Input({input: $input, hint: $hint})
      .onSync('focused', this._onFocused, this)
      .onSync('blurred', this._onBlurred, this)
      .onSync('enterKeyed', this._onEnterKeyed, this)
      .onSync('tabKeyed', this._onTabKeyed, this)
      .onSync('escKeyed', this._onEscKeyed, this)
      .onSync('upKeyed', this._onUpKeyed, this)
      .onSync('downKeyed', this._onDownKeyed, this)
      .onSync('leftKeyed', this._onLeftKeyed, this)
      .onSync('rightKeyed', this._onRightKeyed, this)
      .onSync('queryChanged', this._onQueryChanged, this)
      .onSync('whitespaceChanged', this._onWhitespaceChanged, this);
  
    this._setLanguageDirection();
  }
  
  // instance methods
  // ----------------
  
  _.mixin(Typeahead.prototype, {
  
    // ### private
  
    _onSuggestionClicked: function onSuggestionClicked(type, $el) {
      var datum;
  
      if (datum = this.dropdown.getDatumForSuggestion($el)) {
        this._select(datum);
      }
    },
  
    _onCursorMoved: function onCursorMoved() {
      var datum = this.dropdown.getDatumForCursor();
  
      this.input.setInputValue(datum.value, true);
  
      this.eventBus.trigger('cursorchanged', datum.raw, datum.datasetName);
    },
  
    _onCursorRemoved: function onCursorRemoved() {
      this.input.resetInputValue();
      this._updateHint();
    },
  
    _onDatasetRendered: function onDatasetRendered() {
      this._updateHint();
    },
  
    _onOpened: function onOpened() {
      this._updateHint();
  
      this.eventBus.trigger('opened');
    },
  
    _onClosed: function onClosed() {
      this.input.clearHint();
  
      this.eventBus.trigger('closed');
    },
  
    _onFocused: function onFocused() {
      this.isActivated = true;
  
      if (this.openOnFocus) {
        var query = this.input.getQuery();
        if (query.length >= this.minLength) {
          this.dropdown.update(query);
        } else {
          this.dropdown.empty();
        }
  
        this.dropdown.open();
      }
    },
  
    _onBlurred: function onBlurred() {
      if (!this.debug) {
        this.isActivated = false;
        this.dropdown.empty();
        this.dropdown.close();
      }
    },
  
    _onEnterKeyed: function onEnterKeyed(type, $e) {
      var cursorDatum;
      var topSuggestionDatum;
  
      cursorDatum = this.dropdown.getDatumForCursor();
      topSuggestionDatum = this.dropdown.getDatumForTopSuggestion();
  
      if (cursorDatum) {
        this._select(cursorDatum);
        $e.preventDefault();
      } else if (this.autoselect && topSuggestionDatum) {
        this._select(topSuggestionDatum);
        $e.preventDefault();
      }
    },
  
    _onTabKeyed: function onTabKeyed(type, $e) {
      var datum;
  
      if (datum = this.dropdown.getDatumForCursor()) {
        this._select(datum);
        $e.preventDefault();
      } else {
        this._autocomplete(true);
      }
    },
  
    _onEscKeyed: function onEscKeyed() {
      this.dropdown.close();
      this.input.resetInputValue();
    },
  
    _onUpKeyed: function onUpKeyed() {
      var query = this.input.getQuery();
  
      if (this.dropdown.isEmpty && query.length >= this.minLength) {
        this.dropdown.update(query);
      } else {
        this.dropdown.moveCursorUp();
      }
  
      this.dropdown.open();
    },
  
    _onDownKeyed: function onDownKeyed() {
      var query = this.input.getQuery();
  
      if (this.dropdown.isEmpty && query.length >= this.minLength) {
        this.dropdown.update(query);
      } else {
        this.dropdown.moveCursorDown();
      }
  
      this.dropdown.open();
    },
  
    _onLeftKeyed: function onLeftKeyed() {
      if (this.dir === 'rtl') {
        this._autocomplete();
      }
    },
  
    _onRightKeyed: function onRightKeyed() {
      if (this.dir === 'ltr') {
        this._autocomplete();
      }
    },
  
    _onQueryChanged: function onQueryChanged(e, query) {
      this.input.clearHintIfInvalid();
  
      if (query.length >= this.minLength) {
        this.dropdown.update(query);
      } else {
        this.dropdown.empty();
      }
  
      this.dropdown.open();
      this._setLanguageDirection();
    },
  
    _onWhitespaceChanged: function onWhitespaceChanged() {
      this._updateHint();
      this.dropdown.open();
    },
  
    _setLanguageDirection: function setLanguageDirection() {
      var dir = this.input.getLanguageDirection();
  
      if (this.dir !== dir) {
        this.dir = dir;
        this.$node.css('direction', dir);
        this.dropdown.setLanguageDirection(dir);
      }
    },
  
    _updateHint: function updateHint() {
      var datum;
      var val;
      var query;
      var escapedQuery;
      var frontMatchRegEx;
      var match;
  
      datum = this.dropdown.getDatumForTopSuggestion();
  
      if (datum && this.dropdown.isVisible() && !this.input.hasOverflow()) {
        val = this.input.getInputValue();
        query = Input.normalizeQuery(val);
        escapedQuery = _.escapeRegExChars(query);
  
        // match input value, then capture trailing text
        frontMatchRegEx = new RegExp('^(?:' + escapedQuery + ')(.+$)', 'i');
        match = frontMatchRegEx.exec(datum.value);
  
        // clear hint if there's no trailing text
        if (match) {
          this.input.setHint(val + match[1]);
        } else {
          this.input.clearHint();
        }
      } else {
        this.input.clearHint();
      }
    },
  
    _autocomplete: function autocomplete(laxCursor) {
      var hint;
      var query;
      var isCursorAtEnd;
      var datum;
  
      hint = this.input.getHint();
      query = this.input.getQuery();
      isCursorAtEnd = laxCursor || this.input.isCursorAtEnd();
  
      if (hint && query !== hint && isCursorAtEnd) {
        datum = this.dropdown.getDatumForTopSuggestion();
        if (datum) {
          this.input.setInputValue(datum.value);
        }
  
        this.eventBus.trigger('autocompleted', datum.raw, datum.datasetName);
      }
    },
  
    _select: function select(datum) {
      this.input.setQuery(datum.value);
      this.input.setInputValue(datum.value, true);
  
      this._setLanguageDirection();
  
      this.eventBus.trigger('selected', datum.raw, datum.datasetName);
      this.dropdown.close();
  
      // #118: allow click event to bubble up to the body before removing
      // the suggestions otherwise we break event delegation
      _.defer(_.bind(this.dropdown.empty, this.dropdown));
    },
  
    // ### public
  
    open: function open() {
      // if the menu is not activated yet, we need to update
      // the underlying dropdown menu to trigger the search
      // otherwise we're not gonna see anything
      if (!this.isActivated) {
        var query = this.input.getInputValue();
        if (query.length >= this.minLength) {
          this.dropdown.update(query);
        } else {
          this.dropdown.empty();
        }
      }
      this.dropdown.open();
    },
  
    close: function close() {
      this.dropdown.close();
    },
  
    setVal: function setVal(val) {
      // expect val to be a string, so be safe, and coerce
      val = _.toStr(val);
  
      if (this.isActivated) {
        this.input.setInputValue(val);
      } else {
        this.input.setQuery(val);
        this.input.setInputValue(val, true);
      }
  
      this._setLanguageDirection();
    },
  
    getVal: function getVal() {
      return this.input.getQuery();
    },
  
    destroy: function destroy() {
      this.input.destroy();
      this.dropdown.destroy();
  
      destroyDomStructure(this.$node);
  
      this.$node = null;
    }
  });
  
  function buildDom(options) {
    var $input;
    var $wrapper;
    var $dropdown;
    var $hint;
  
    $input = $(options.input);
    $wrapper = $(html.wrapper).css(css.wrapper);
    $dropdown = $(html.dropdown).css(css.dropdown);
    if (options.templates && options.templates.dropdownMenu) {
      $dropdown.html(_.templatify(options.templates.dropdownMenu)());
    }
    $hint = $input.clone().css(css.hint).css(getBackgroundStyles($input));
  
    $hint
      .val('')
      .removeData()
      .addClass('aa-hint')
      .removeAttr('id name placeholder required')
      .prop('readonly', true)
      .attr({autocomplete: 'off', spellcheck: 'false', tabindex: -1});
  
    // store the original values of the attrs that get modified
    // so modifications can be reverted on destroy
    $input.data(attrsKey, {
      dir: $input.attr('dir'),
      autocomplete: $input.attr('autocomplete'),
      spellcheck: $input.attr('spellcheck'),
      style: $input.attr('style')
    });
  
    $input
      .addClass('aa-input')
      .attr({autocomplete: 'off', spellcheck: false})
      .css(options.hint ? css.input : css.inputWithNoHint);
  
    // ie7 does not like it when dir is set to auto
    try {
      if (!$input.attr('dir')) {
        $input.attr('dir', 'auto');
      }
    } catch (e) {
      // ignore
    }
  
    return $input
      .wrap($wrapper)
      .parent()
      .prepend(options.hint ? $hint : null)
      .append($dropdown);
  }
  
  function getBackgroundStyles($el) {
    return {
      backgroundAttachment: $el.css('background-attachment'),
      backgroundClip: $el.css('background-clip'),
      backgroundColor: $el.css('background-color'),
      backgroundImage: $el.css('background-image'),
      backgroundOrigin: $el.css('background-origin'),
      backgroundPosition: $el.css('background-position'),
      backgroundRepeat: $el.css('background-repeat'),
      backgroundSize: $el.css('background-size')
    };
  }
  
  function destroyDomStructure($node) {
    var $input = $node.find('.aa-input');
  
    // need to remove attrs that weren't previously defined and
    // revert attrs that originally had a value
    _.each($input.data(attrsKey), function(val, key) {
      if (val === undefined) {
        $input.removeAttr(key);
      } else {
        $input.attr(key, val);
      }
    });
  
    $input
      .detach()
      .removeData(attrsKey)
      .removeClass('aa-input')
      .insertAfter($node);
  
    $node.remove();
  }
  
  Typeahead.Dropdown = Dropdown;
  Typeahead.Input = Input;
  
  module.exports = Typeahead;
  
  },{"../common/utils.js":106,"./css.js":98,"./dropdown.js":100,"./event_bus.js":101,"./html.js":103,"./input.js":104}],106:[function(require,module,exports){
  'use strict';
  
  module.exports = {
    isMsie: function() {
      // from https://github.com/ded/bowser/blob/master/bowser.js
      return (/(msie|trident)/i).test(navigator.userAgent) ?
        navigator.userAgent.match(/(msie |rv:)(\d+(.\d+)?)/i)[2] : false;
    },
  
    // http://stackoverflow.com/a/6969486
    escapeRegExChars: function(str) {
      return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
    },
  
    isNumber: function(obj) { return typeof obj === 'number'; },
  
    isArray: require('lodash-compat/lang/isArray'),
  
    isFunction: require('lodash-compat/lang/isFunction'),
  
    isObject: require('lodash-compat/lang/isPlainObject'),
  
    toStr: function toStr(s) {
      return s === undefined || s === null ? '' : s + '';
    },
  
    bind: require('lodash-compat/function/bind'),
  
    each: require('lodash-compat/collection/forEach'),
  
    map: require('lodash-compat/collection/map'),
  
    filter: require('lodash-compat/collection/filter'),
  
    error: function(msg) {
      throw new Error(msg);
    },
  
    every: require('lodash-compat/collection/every'),
  
    mixin: require('lodash-compat/object/assign'),
  
    getUniqueId: (function() {
      var counter = 0;
      return function() { return counter++; };
    })(),
  
    templatify: function templatify(obj) {
      var isFunction = require('lodash-compat/lang/isFunction');
  
      if (isFunction(obj)) {
        return obj;
      }
      var $template = $(obj);
      if ($template.prop('tagName') === 'SCRIPT') {
        return function template() { return $template.text(); };
      }
      return function template() { return String(obj); };
    },
  
    defer: function(fn) { setTimeout(fn, 0); },
  
    noop: function() {}
  };
  
  },{"lodash-compat/collection/every":4,"lodash-compat/collection/filter":5,"lodash-compat/collection/forEach":6,"lodash-compat/collection/map":7,"lodash-compat/function/bind":9,"lodash-compat/lang/isArray":83,"lodash-compat/lang/isFunction":84,"lodash-compat/lang/isPlainObject":87,"lodash-compat/object/assign":90}],107:[function(require,module,exports){
  'use strict';
  
  var _ = require('../common/utils.js');
  var Typeahead = require('../autocomplete/typeahead.js');
  var EventBus = require('../autocomplete/event_bus.js');
  
  
  var old;
  var typeaheadKey;
  var methods;
  
  old = $.fn.autocomplete;
  
  typeaheadKey = 'aaAutocomplete';
  
  methods = {
    // supported signatures:
    // function(o, dataset, dataset, ...)
    // function(o, [dataset, dataset, ...])
    initialize: function initialize(o, datasets) {
      datasets = _.isArray(datasets) ? datasets : [].slice.call(arguments, 1);
  
      o = o || {};
  
      return this.each(attach);
  
      function attach() {
        var $input = $(this);
        var eventBus = new EventBus({el: $input});
        var typeahead;
  
        typeahead = new Typeahead({
          input: $input,
          eventBus: eventBus,
          hint: o.hint === undefined ? true : !!o.hint,
          minLength: o.minLength,
          autoselect: o.autoselect,
          openOnFocus: o.openOnFocus,
          templates: o.templates,
          debug: o.debug,
          datasets: datasets
        });
  
        $input.data(typeaheadKey, typeahead);
      }
    },
  
    open: function open() {
      return this.each(openTypeahead);
  
      function openTypeahead() {
        var $input = $(this);
        var typeahead;
  
        if (typeahead = $input.data(typeaheadKey)) {
          typeahead.open();
        }
      }
    },
  
    close: function close() {
      return this.each(closeTypeahead);
  
      function closeTypeahead() {
        var $input = $(this);
        var typeahead;
  
        if (typeahead = $input.data(typeaheadKey)) {
          typeahead.close();
        }
      }
    },
  
    val: function val(newVal) {
      // mirror jQuery#val functionality: reads opearte on first match,
      // write operates on all matches
      return !arguments.length ? getVal(this.first()) : this.each(setVal);
  
      function setVal() {
        var $input = $(this);
        var typeahead;
  
        if (typeahead = $input.data(typeaheadKey)) {
          typeahead.setVal(newVal);
        }
      }
  
      function getVal($input) {
        var typeahead;
        var query;
  
        if (typeahead = $input.data(typeaheadKey)) {
          query = typeahead.getVal();
        }
  
        return query;
      }
    },
  
    destroy: function destroy() {
      return this.each(unattach);
  
      function unattach() {
        var $input = $(this);
        var typeahead;
  
        if (typeahead = $input.data(typeaheadKey)) {
          typeahead.destroy();
          $input.removeData(typeaheadKey);
        }
      }
    }
  };
  
  $.fn.autocomplete = function(method) {
    var tts;
  
    // methods that should only act on intialized typeaheads
    if (methods[method] && method !== 'initialize') {
      // filter out non-typeahead inputs
      tts = this.filter(function() { return !!$(this).data(typeaheadKey); });
      return methods[method].apply(tts, [].slice.call(arguments, 1));
    }
    return methods.initialize.apply(this, arguments);
  };
  
  $.fn.autocomplete.noConflict = function noConflict() {
    $.fn.autocomplete = old;
    return this;
  };
  
  module.exports = $.fn.autocomplete;
  
  },{"../autocomplete/event_bus.js":101,"../autocomplete/typeahead.js":105,"../common/utils.js":106}]},{},[1]);
  