text: /*!
  
   * typeahead.js 0.10.5
  
   * https://github.com/twitter/typeahead.js
  
   * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
  
   */
  
  
  
  (function($) {
  
      var _ = function() {
  
          "use strict";
  
          return {
  
              isMsie: function() {
  
                  return /(msie|trident)/i.test(navigator.userAgent) ? navigator.userAgent.match(/(msie |rv:)(\d+(.\d+)?)/i)[2] : false;
  
              },
  
              isBlankString: function(str) {
  
                  return !str || /^\s*$/.test(str);
  
              },
  
              escapeRegExChars: function(str) {
  
                  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
  
              },
  
              isString: function(obj) {
  
                  return typeof obj === "string";
  
              },
  
              isNumber: function(obj) {
  
                  return typeof obj === "number";
  
              },
  
              isArray: $.isArray,
  
              isFunction: $.isFunction,
  
              isObject: $.isPlainObject,
  
              isUndefined: function(obj) {
  
                  return typeof obj === "undefined";
  
              },
  
              toStr: function toStr(s) {
  
                  return _.isUndefined(s) || s === null ? "" : s + "";
  
              },
  
              bind: $.proxy,
  
              each: function(collection, cb) {
  
                  $.each(collection, reverseArgs);
  
                  function reverseArgs(index, value) {
  
                      return cb(value, index);
  
                  }
  
              },
  
              map: $.map,
  
              filter: $.grep,
  
              every: function(obj, test) {
  
                  var result = true;
  
                  if (!obj) {
  
                      return result;
  
                  }
  
                  $.each(obj, function(key, val) {
  
                      if (!(result = test.call(null, val, key, obj))) {
  
                          return false;
  
                      }
  
                  });
  
                  return !!result;
  
              },
  
              some: function(obj, test) {
  
                  var result = false;
  
                  if (!obj) {
  
                      return result;
  
                  }
  
                  $.each(obj, function(key, val) {
  
                      if (result = test.call(null, val, key, obj)) {
  
                          return false;
  
                      }
  
                  });
  
                  return !!result;
  
              },
  
              mixin: $.extend,
  
              getUniqueId: function() {
  
                  var counter = 0;
  
                  return function() {
  
                      return counter++;
  
                  };
  
              }(),
  
              templatify: function templatify(obj) {
  
                  return $.isFunction(obj) ? obj : template;
  
                  function template() {
  
                      return String(obj);
  
                  }
  
              },
  
              defer: function(fn) {
  
                  setTimeout(fn, 0);
  
              },
  
              debounce: function(func, wait, immediate) {
  
                  var timeout, result;
  
                  return function() {
  
                      var context = this, args = arguments, later, callNow;
  
                      later = function() {
  
                          timeout = null;
  
                          if (!immediate) {
  
                              result = func.apply(context, args);
  
                          }
  
                      };
  
                      callNow = immediate && !timeout;
  
                      clearTimeout(timeout);
  
                      timeout = setTimeout(later, wait);
  
                      if (callNow) {
  
                          result = func.apply(context, args);
  
                      }
  
                      return result;
  
                  };
  
              },
  
              throttle: function(func, wait) {
  
                  var context, args, timeout, result, previous, later;
  
                  previous = 0;
  
                  later = function() {
  
                      previous = new Date();
  
                      timeout = null;
  
                      result = func.apply(context, args);
  
                  };
  
                  return function() {
  
                      var now = new Date(), remaining = wait - (now - previous);
  
                      context = this;
  
                      args = arguments;
  
                      if (remaining <= 0) {
  
                          clearTimeout(timeout);
  
                          timeout = null;
  
                          previous = now;
  
                          result = func.apply(context, args);
  
                      } else if (!timeout) {
  
                          timeout = setTimeout(later, remaining);
  
                      }
  
                      return result;
  
                  };
  
              },
  
              noop: function() {}
  
          };
  
      }();
  
      var VERSION = "0.10.5";
  
      var tokenizers = function() {
  
          "use strict";
  
          return {
  
              nonword: nonword,
  
              whitespace: whitespace,
  
              obj: {
  
                  nonword: getObjTokenizer(nonword),
  
                  whitespace: getObjTokenizer(whitespace)
  
              }
  
          };
  
          function whitespace(str) {
  
              str = _.toStr(str);
  
              return str ? str.split(/\s+/) : [];
  
          }
  
          function nonword(str) {
  
              str = _.toStr(str);
  
              return str ? str.split(/\W+/) : [];
  
          }
  
          function getObjTokenizer(tokenizer) {
  
              return function setKey() {
  
                  var args = [].slice.call(arguments, 0);
  
                  return function tokenize(o) {
  
                      var tokens = [];
  
                      _.each(args, function(k) {
  
                          tokens = tokens.concat(tokenizer(_.toStr(o[k])));
  
                      });
  
                      return tokens;
  
                  };
  
              };
  
          }
  
      }();
  
      var LruCache = function() {
  
          "use strict";
  
          function LruCache(maxSize) {
  
              this.maxSize = _.isNumber(maxSize) ? maxSize : 100;
  
              this.reset();
  
              if (this.maxSize <= 0) {
  
                  this.set = this.get = $.noop;
  
              }
  
          }
  
          _.mixin(LruCache.prototype, {
  
              set: function set(key, val) {
  
                  var tailItem = this.list.tail, node;
  
                  if (this.size >= this.maxSize) {
  
                      this.list.remove(tailItem);
  
                      delete this.hash[tailItem.key];
  
                  }
  
                  if (node = this.hash[key]) {
  
                      node.val = val;
  
                      this.list.moveToFront(node);
  
                  } else {
  
                      node = new Node(key, val);
  
                      this.list.add(node);
  
                      this.hash[key] = node;
  
                      this.size++;
  
                  }
  
              },
  
              get: function get(key) {
  
                  var node = this.hash[key];
  
                  if (node) {
  
                      this.list.moveToFront(node);
  
                      return node.val;
  
                  }
  
              },
  
              reset: function reset() {
  
                  this.size = 0;
  
                  this.hash = {};
  
                  this.list = new List();
  
              }
  
          });
  
          function List() {
  
              this.head = this.tail = null;
  
          }
  
          _.mixin(List.prototype, {
  
              add: function add(node) {
  
                  if (this.head) {
  
                      node.next = this.head;
  
                      this.head.prev = node;
  
                  }
  
                  this.head = node;
  
                  this.tail = this.tail || node;
  
              },
  
              remove: function remove(node) {
  
                  node.prev ? node.prev.next = node.next : this.head = node.next;
  
                  node.next ? node.next.prev = node.prev : this.tail = node.prev;
  
              },
  
              moveToFront: function(node) {
  
                  this.remove(node);
  
                  this.add(node);
  
              }
  
          });
  
          function Node(key, val) {
  
              this.key = key;
  
              this.val = val;
  
              this.prev = this.next = null;
  
          }
  
          return LruCache;
  
      }();
  
      var PersistentStorage = function() {
  
          "use strict";
  
          var ls, methods;
  
          try {
  
              ls = window.localStorage;
  
              ls.setItem("~~~", "!");
  
              ls.removeItem("~~~");
  
          } catch (err) {
  
              ls = null;
  
          }
  
          function PersistentStorage(namespace) {
  
              this.prefix = [ "__", namespace, "__" ].join("");
  
              this.ttlKey = "__ttl__";
  
              this.keyMatcher = new RegExp("^" + _.escapeRegExChars(this.prefix));
  
          }
  
          if (ls && window.JSON) {
  
              methods = {
  
                  _prefix: function(key) {
  
                      return this.prefix + key;
  
                  },
  
                  _ttlKey: function(key) {
  
                      return this._prefix(key) + this.ttlKey;
  
                  },
  
                  get: function(key) {
  
                      if (this.isExpired(key)) {
  
                          this.remove(key);
  
                      }
  
                      return decode(ls.getItem(this._prefix(key)));
  
                  },
  
                  set: function(key, val, ttl) {
  
                      if (_.isNumber(ttl)) {
  
                          ls.setItem(this._ttlKey(key), encode(now() + ttl));
  
                      } else {
  
                          ls.removeItem(this._ttlKey(key));
  
                      }
  
                      return ls.setItem(this._prefix(key), encode(val));
  
                  },
  
                  remove: function(key) {
  
                      ls.removeItem(this._ttlKey(key));
  
                      ls.removeItem(this._prefix(key));
  
                      return this;
  
                  },
  
                  clear: function() {
  
                      var i, key, keys = [], len = ls.length;
  
                      for (i = 0; i < len; i++) {
  
                          if ((key = ls.key(i)).match(this.keyMatcher)) {
  
                              keys.push(key.replace(this.keyMatcher, ""));
  
                          }
  
                      }
  
                      for (i = keys.length; i--; ) {
  
                          this.remove(keys[i]);
  
                      }
  
                      return this;
  
                  },
  
                  isExpired: function(key) {
  
                      var ttl = decode(ls.getItem(this._ttlKey(key)));
  
                      return _.isNumber(ttl) && now() > ttl ? true : false;
  
                  }
  
              };
  
          } else {
  
              methods = {
  
                  get: _.noop,
  
                  set: _.noop,
  
                  remove: _.noop,
  
                  clear: _.noop,
  
                  isExpired: _.noop
  
              };
  
          }
  
          _.mixin(PersistentStorage.prototype, methods);
  
          return PersistentStorage;
  
          function now() {
  
              return new Date().getTime();
  
          }
  
          function encode(val) {
  
              return JSON.stringify(_.isUndefined(val) ? null : val);
  
          }
  
          function decode(val) {
  
              return JSON.parse(val);
  
          }
  
      }();
  
      var Transport = function() {
  
          "use strict";
  
          var pendingRequestsCount = 0, pendingRequests = {}, maxPendingRequests = 6, sharedCache = new LruCache(10);
  
          function Transport(o) {
  
              o = o || {};
  
              this.cancelled = false;
  
              this.lastUrl = null;
  
              this._send = o.transport ? callbackToDeferred(o.transport) : $.ajax;
  
              this._get = o.rateLimiter ? o.rateLimiter(this._get) : this._get;
  
              this._cache = o.cache === false ? new LruCache(0) : sharedCache;
  
          }
  
          Transport.setMaxPendingRequests = function setMaxPendingRequests(num) {
  
              maxPendingRequests = num;
  
          };
  
          Transport.resetCache = function resetCache() {
  
              sharedCache.reset();
  
          };
  
          _.mixin(Transport.prototype, {
  
              _get: function(url, o, cb) {
  
                  var that = this, jqXhr;
  
                  if (this.cancelled || url !== this.lastUrl) {
  
                      return;
  
                  }
  
                  if (jqXhr = pendingRequests[url]) {
  
                      jqXhr.done(done).fail(fail);
  
                  } else if (pendingRequestsCount < maxPendingRequests) {
  
                      pendingRequestsCount++;
  
                      pendingRequests[url] = this._send(url, o).done(done).fail(fail).always(always);
  
                  } else {
  
                      this.onDeckRequestArgs = [].slice.call(arguments, 0);
  
                  }
  
                  function done(resp) {
  
                      cb && cb(null, resp);
  
                      that._cache.set(url, resp);
  
                  }
  
                  function fail() {
  
                      cb && cb(true);
  
                  }
  
                  function always() {
  
                      pendingRequestsCount--;
  
                      delete pendingRequests[url];
  
                      if (that.onDeckRequestArgs) {
  
                          that._get.apply(that, that.onDeckRequestArgs);
  
                          that.onDeckRequestArgs = null;
  
                      }
  
                  }
  
              },
  
              get: function(url, o, cb) {
  
                  var resp;
  
                  if (_.isFunction(o)) {
  
                      cb = o;
  
                      o = {};
  
                  }
  
                  this.cancelled = false;
  
                  this.lastUrl = url;
  
                  if (resp = this._cache.get(url)) {
  
                      _.defer(function() {
  
                          cb && cb(null, resp);
  
                      });
  
                  } else {
  
                      this._get(url, o, cb);
  
                  }
  
                  return !!resp;
  
              },
  
              cancel: function() {
  
                  this.cancelled = true;
  
              }
  
          });
  
          return Transport;
  
          function callbackToDeferred(fn) {
  
              return function customSendWrapper(url, o) {
  
                  var deferred = $.Deferred();
  
                  fn(url, o, onSuccess, onError);
  
                  return deferred;
  
                  function onSuccess(resp) {
  
                      _.defer(function() {
  
                          deferred.resolve(resp);
  
                      });
  
                  }
  
                  function onError(err) {
  
                      _.defer(function() {
  
                          deferred.reject(err);
  
                      });
  
                  }
  
              };
  
          }
  
      }();
  
      var SearchIndex = function() {
  
          "use strict";
  
          function SearchIndex(o) {
  
              o = o || {};
  
              if (!o.datumTokenizer || !o.queryTokenizer) {
  
                  $.error("datumTokenizer and queryTokenizer are both required");
  
              }
  
              this.datumTokenizer = o.datumTokenizer;
  
              this.queryTokenizer = o.queryTokenizer;
  
              this.reset();
  
          }
  
          _.mixin(SearchIndex.prototype, {
  
              bootstrap: function bootstrap(o) {
  
                  this.datums = o.datums;
  
                  this.trie = o.trie;
  
              },
  
              add: function(data) {
  
                  var that = this;
  
                  data = _.isArray(data) ? data : [ data ];
  
                  _.each(data, function(datum) {
  
                      var id, tokens;
  
                      id = that.datums.push(datum) - 1;
  
                      tokens = normalizeTokens(that.datumTokenizer(datum));
  
                      _.each(tokens, function(token) {
  
                          var node, chars, ch;
  
                          node = that.trie;
  
                          chars = token.split("");
  
                          while (ch = chars.shift()) {
  
                              node = node.children[ch] || (node.children[ch] = newNode());
  
                              node.ids.push(id);
  
                          }
  
                      });
  
                  });
  
              },
  
              get: function get(query) {
  
                  var that = this, tokens, matches;
  
                  tokens = normalizeTokens(this.queryTokenizer(query));
  
                  _.each(tokens, function(token) {
  
                      var node, chars, ch, ids;
  
                      if (matches && matches.length === 0) {
  
                          return false;
  
                      }
  
                      node = that.trie;
  
                      chars = token.split("");
  
                      while (node && (ch = chars.shift())) {
  
                          node = node.children[ch];
  
                      }
  
                      if (node && chars.length === 0) {
  
                          ids = node.ids.slice(0);
  
                          matches = matches ? getIntersection(matches, ids) : ids;
  
                      } else {
  
                          matches = [];
  
                          return false;
  
                      }
  
                  });
  
                  return matches ? _.map(unique(matches), function(id) {
  
                      return that.datums[id];
  
                  }) : [];
  
              },
  
              reset: function reset() {
  
                  this.datums = [];
  
                  this.trie = newNode();
  
              },
  
              serialize: function serialize() {
  
                  return {
  
                      datums: this.datums,
  
                      trie: this.trie
  
                  };
  
              }
  
          });
  
          return SearchIndex;
  
          function normalizeTokens(tokens) {
  
              tokens = _.filter(tokens, function(token) {
  
                  return !!token;
  
              });
  
              tokens = _.map(tokens, function(token) {
  
                  return token.toLowerCase();
  
              });
  
              return tokens;
  
          }
  
          function newNode() {
  
              return {
  
                  ids: [],
  
                  children: {}
  
              };
  
          }
  
          function unique(array) {
  
              var seen = {}, uniques = [];
  
              for (var i = 0, len = array.length; i < len; i++) {
  
                  if (!seen[array[i]]) {
  
                      seen[array[i]] = true;
  
                      uniques.push(array[i]);
  
                  }
  
              }
  
              return uniques;
  
          }
  
          function getIntersection(arrayA, arrayB) {
  
              var ai = 0, bi = 0, intersection = [];
  
              arrayA = arrayA.sort(compare);
  
              arrayB = arrayB.sort(compare);
  
              var lenArrayA = arrayA.length, lenArrayB = arrayB.length;
  
              while (ai < lenArrayA && bi < lenArrayB) {
  
                  if (arrayA[ai] < arrayB[bi]) {
  
                      ai++;
  
                  } else if (arrayA[ai] > arrayB[bi]) {
  
                      bi++;
  
                  } else {
  
                      intersection.push(arrayA[ai]);
  
                      ai++;
  
                      bi++;
  
                  }
  
              }
  
              return intersection;
  
              function compare(a, b) {
  
                  return a - b;
  
              }
  
          }
  
      }();
  
      var oParser = function() {
  
          "use strict";
  
          return {
  
              local: getLocal,
  
              prefetch: getPrefetch,
  
              remote: getRemote
  
          };
  
          function getLocal(o) {
  
              return o.local || null;
  
          }
  
          function getPrefetch(o) {
  
              var prefetch, defaults;
  
              defaults = {
  
                  url: null,
  
                  thumbprint: "",
  
                  ttl: 24 * 60 * 60 * 1e3,
  
                  filter: null,
  
                  ajax: {}
  
              };
  
              if (prefetch = o.prefetch || null) {
  
                  prefetch = _.isString(prefetch) ? {
  
                      url: prefetch
  
                  } : prefetch;
  
                  prefetch = _.mixin(defaults, prefetch);
  
                  prefetch.thumbprint = VERSION + prefetch.thumbprint;
  
                  prefetch.ajax.type = prefetch.ajax.type || "GET";
  
                  prefetch.ajax.dataType = prefetch.ajax.dataType || "json";
  
                  !prefetch.url && $.error("prefetch requires url to be set");
  
              }
  
              return prefetch;
  
          }
  
          function getRemote(o) {
  
              var remote, defaults;
  
              defaults = {
  
                  url: null,
  
                  cache: true,
  
                  wildcard: "%QUERY",
  
                  replace: null,
  
                  rateLimitBy: "debounce",
  
                  rateLimitWait: 300,
  
                  send: null,
  
                  filter: null,
  
                  ajax: {}
  
              };
  
              if (remote = o.remote || null) {
  
                  remote = _.isString(remote) ? {
  
                      url: remote
  
                  } : remote;
  
                  remote = _.mixin(defaults, remote);
  
                  remote.rateLimiter = /^throttle$/i.test(remote.rateLimitBy) ? byThrottle(remote.rateLimitWait) : byDebounce(remote.rateLimitWait);
  
                  remote.ajax.type = remote.ajax.type || "GET";
  
                  remote.ajax.dataType = remote.ajax.dataType || "json";
  
                  delete remote.rateLimitBy;
  
                  delete remote.rateLimitWait;
  
                  !remote.url && $.error("remote requires url to be set");
  
              }
  
              return remote;
  
              function byDebounce(wait) {
  
                  return function(fn) {
  
                      return _.debounce(fn, wait);
  
                  };
  
              }
  
              function byThrottle(wait) {
  
                  return function(fn) {
  
                      return _.throttle(fn, wait);
  
                  };
  
              }
  
          }
  
      }();
  
      (function(root) {
  
          "use strict";
  
          var old, keys;
  
          old = root.Bloodhound;
  
          keys = {
  
              data: "data",
  
              protocol: "protocol",
  
              thumbprint: "thumbprint"
  
          };
  
          root.Bloodhound = Bloodhound;
  
          function Bloodhound(o) {
  
              if (!o || !o.local && !o.prefetch && !o.remote) {
  
                  $.error("one of local, prefetch, or remote is required");
  
              }
  
              this.limit = o.limit || 5;
  
              this.sorter = getSorter(o.sorter);
  
              this.dupDetector = o.dupDetector || ignoreDuplicates;
  
              this.local = oParser.local(o);
  
              this.prefetch = oParser.prefetch(o);
  
              this.remote = oParser.remote(o);
  
              this.cacheKey = this.prefetch ? this.prefetch.cacheKey || this.prefetch.url : null;
  
              this.index = new SearchIndex({
  
                  datumTokenizer: o.datumTokenizer,
  
                  queryTokenizer: o.queryTokenizer
  
              });
  
              this.storage = this.cacheKey ? new PersistentStorage(this.cacheKey) : null;
  
          }
  
          Bloodhound.noConflict = function noConflict() {
  
              root.Bloodhound = old;
  
              return Bloodhound;
  
          };
  
          Bloodhound.tokenizers = tokenizers;
  
          _.mixin(Bloodhound.prototype, {
  
              _loadPrefetch: function loadPrefetch(o) {
  
                  var that = this, serialized, deferred;
  
                  if (serialized = this._readFromStorage(o.thumbprint)) {
  
                      this.index.bootstrap(serialized);
  
                      deferred = $.Deferred().resolve();
  
                  } else {
  
                      deferred = $.ajax(o.url, o.ajax).done(handlePrefetchResponse);
  
                  }
  
                  return deferred;
  
                  function handlePrefetchResponse(resp) {
  
                      that.clear();
  
                      that.add(o.filter ? o.filter(resp) : resp);
  
                      that._saveToStorage(that.index.serialize(), o.thumbprint, o.ttl);
  
                  }
  
              },
  
              _getFromRemote: function getFromRemote(query, cb) {
  
                  var that = this, url, uriEncodedQuery;
  
                  if (!this.transport) {
  
                      return;
  
                  }
  
                  query = query || "";
  
                  uriEncodedQuery = encodeURIComponent(query);
  
                  url = this.remote.replace ? this.remote.replace(this.remote.url, query) : this.remote.url.replace(this.remote.wildcard, uriEncodedQuery);
  
                  return this.transport.get(url, this.remote.ajax, handleRemoteResponse);
  
                  function handleRemoteResponse(err, resp) {
  
                      err ? cb([]) : cb(that.remote.filter ? that.remote.filter(resp) : resp);
  
                  }
  
              },
  
              _cancelLastRemoteRequest: function cancelLastRemoteRequest() {
  
                  this.transport && this.transport.cancel();
  
              },
  
              _saveToStorage: function saveToStorage(data, thumbprint, ttl) {
  
                  if (this.storage) {
  
                      this.storage.set(keys.data, data, ttl);
  
                      this.storage.set(keys.protocol, location.protocol, ttl);
  
                      this.storage.set(keys.thumbprint, thumbprint, ttl);
  
                  }
  
              },
  
              _readFromStorage: function readFromStorage(thumbprint) {
  
                  var stored = {}, isExpired;
  
                  if (this.storage) {
  
                      stored.data = this.storage.get(keys.data);
  
                      stored.protocol = this.storage.get(keys.protocol);
  
                      stored.thumbprint = this.storage.get(keys.thumbprint);
  
                  }
  
                  isExpired = stored.thumbprint !== thumbprint || stored.protocol !== location.protocol;
  
                  return stored.data && !isExpired ? stored.data : null;
  
              },
  
              _initialize: function initialize() {
  
                  var that = this, local = this.local, deferred;
  
                  deferred = this.prefetch ? this._loadPrefetch(this.prefetch) : $.Deferred().resolve();
  
                  local && deferred.done(addLocalToIndex);
  
                  this.transport = this.remote ? new Transport(this.remote) : null;
  
                  return this.initPromise = deferred.promise();
  
                  function addLocalToIndex() {
  
                      that.add(_.isFunction(local) ? local() : local);
  
                  }
  
              },
  
              initialize: function initialize(force) {
  
                  return !this.initPromise || force ? this._initialize() : this.initPromise;
  
              },
  
              add: function add(data) {
  
                  this.index.add(data);
  
              },
  
              get: function get(query, cb) {
  
                  var that = this, matches = [], cacheHit = false;
  
                  matches = this.index.get(query);
  
                  matches = this.sorter(matches).slice(0, this.limit);
  
                  matches.length < this.limit ? cacheHit = this._getFromRemote(query, returnRemoteMatches) : this._cancelLastRemoteRequest();
  
                  if (!cacheHit) {
  
                      (matches.length > 0 || !this.transport) && cb && cb(matches);
  
                  }
  
                  function returnRemoteMatches(remoteMatches) {
  
                      var matchesWithBackfill = matches.slice(0);
  
                      _.each(remoteMatches, function(remoteMatch) {
  
                          var isDuplicate;
  
                          isDuplicate = _.some(matchesWithBackfill, function(match) {
  
                              return that.dupDetector(remoteMatch, match);
  
                          });
  
                          !isDuplicate && matchesWithBackfill.push(remoteMatch);
  
                          return matchesWithBackfill.length < that.limit;
  
                      });
  
                      cb && cb(that.sorter(matchesWithBackfill));
  
                  }
  
              },
  
              clear: function clear() {
  
                  this.index.reset();
  
              },
  
              clearPrefetchCache: function clearPrefetchCache() {
  
                  this.storage && this.storage.clear();
  
              },
  
              clearRemoteCache: function clearRemoteCache() {
  
                  this.transport && Transport.resetCache();
  
              },
  
              ttAdapter: function ttAdapter() {
  
                  return _.bind(this.get, this);
  
              }
  
          });
  
          return Bloodhound;
  
          function getSorter(sortFn) {
  
              return _.isFunction(sortFn) ? sort : noSort;
  
              function sort(array) {
  
                  return array.sort(sortFn);
  
              }
  
              function noSort(array) {
  
                  return array;
  
              }
  
          }
  
          function ignoreDuplicates() {
  
              return false;
  
          }
  
      })(this);
  
  })(window.jQuery);