https://spectrumnews1.com/etc/designs/news/clientlibs/js.min.ACSHASH7b03e7fbfa607f63001bceceaa5ed9cb.js

1/*!
2 * @overview es6-promise - a tiny implementation of Promises/A+.
3 * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
4 * @license   Licensed under MIT license
5 *            See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
6 * @version   v4.2.8+1e68dce6
7 */
8
9(function (global, factory) {
10	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
11	typeof define === 'function' && define.amd ? define(factory) :
12	(global.ES6Promise = factory());
13}(this, (function () { 'use strict';
14
15function objectOrFunction(x) {
16  var type = typeof x;
17  return x !== null && (type === 'object' || type === 'function');
18}
19
20function isFunction(x) {
21  return typeof x === 'function';
22}
23
24
25
26var _isArray = void 0;
27if (Array.isArray) {
28  _isArray = Array.isArray;
29} else {
30  _isArray = function (x) {
31    return Object.prototype.toString.call(x) === '[object Array]';
32  };
33}
34
35var isArray = _isArray;
36
37var len = 0;
38var vertxNext = void 0;
39var customSchedulerFn = void 0;
40
41var asap = function asap(callback, arg) {
42  queue[len] = callback;
43  queue[len + 1] = arg;
44  len += 2;
45  if (len === 2) {
46    // If len is 2, that means that we need to schedule an async flush.
47    // If additional callbacks are queued before the queue is flushed, they
48    // will be processed by this flush that we are scheduling.
49    if (customSchedulerFn) {
50      customSchedulerFn(flush);
51    } else {
52      scheduleFlush();
53    }
54  }
55};
56
57function setScheduler(scheduleFn) {
58  customSchedulerFn = scheduleFn;
59}
60
61function setAsap(asapFn) {
62  asap = asapFn;
63}
64
65var browserWindow = typeof window !== 'undefined' ? window : undefined;
66var browserGlobal = browserWindow || {};
67var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
68var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
69
70// test for web worker but not in IE10
71var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
72
73// node
74function useNextTick() {
75  // node version 0.10.x displays a deprecation warning when nextTick is used recursively
76  // see https://github.com/cujojs/when/issues/410 for details
77  return function () {
78    return process.nextTick(flush);
79  };
80}
81
82// vertx
83function useVertxTimer() {
84  if (typeof vertxNext !== 'undefined') {
85    return function () {
86      vertxNext(flush);
87    };
88  }
89
90  return useSetTimeout();
91}
92
93function useMutationObserver() {
94  var iterations = 0;
95  var observer = new BrowserMutationObserver(flush);
96  var node = document.createTextNode('');
97  observer.observe(node, { characterData: true });
98
99  return function () {
100    node.data = iterations = ++iterations % 2;
101  };
102}
103
104// web worker
105function useMessageChannel() {
106  var channel = new MessageChannel();
107  channel.port1.onmessage = flush;
108  return function () {
109    return channel.port2.postMessage(0);
110  };
111}
112
113function useSetTimeout() {
114  // Store setTimeout reference so es6-promise will be unaffected by
115  // other code modifying setTimeout (like sinon.useFakeTimers())
116  var globalSetTimeout = setTimeout;
117  return function () {
118    return globalSetTimeout(flush, 1);
119  };
120}
121
122var queue = new Array(1000);
123function flush() {
124  for (var i = 0; i < len; i += 2) {
125    var callback = queue[i];
126    var arg = queue[i + 1];
127
128    callback(arg);
129
130    queue[i] = undefined;
131    queue[i + 1] = undefined;
132  }
133
134  len = 0;
135}
136
137function attemptVertx() {
138  try {
139    var vertx = Function('return this')().require('vertx');
140    vertxNext = vertx.runOnLoop || vertx.runOnContext;
141    return useVertxTimer();
142  } catch (e) {
143    return useSetTimeout();
144  }
145}
146
147var scheduleFlush = void 0;
148// Decide what async method to use to triggering processing of queued callbacks:
149if (isNode) {
150  scheduleFlush = useNextTick();
151} else if (BrowserMutationObserver) {
152  scheduleFlush = useMutationObserver();
153} else if (isWorker) {
154  scheduleFlush = useMessageChannel();
155} else if (browserWindow === undefined && typeof require === 'function') {
156  scheduleFlush = attemptVertx();
157} else {
158  scheduleFlush = useSetTimeout();
159}
160
161function then(onFulfillment, onRejection) {
162  var parent = this;
163
164  var child = new this.constructor(noop);
165
166  if (child[PROMISE_ID] === undefined) {
167    makePromise(child);
168  }
169
170  var _state = parent._state;
171
172
173  if (_state) {
174    var callback = arguments[_state - 1];
175    asap(function () {
176      return invokeCallback(_state, child, callback, parent._result);
177    });
178  } else {
179    subscribe(parent, child, onFulfillment, onRejection);
180  }
181
182  return child;
183}
184
185/**
186  `Promise.resolve` returns a promise that will become resolved with the
187  passed `value`. It is shorthand for the following:
188
189  ```javascript
190  let promise = new Promise(function(resolve, reject){
191    resolve(1);
192  });
193
194  promise.then(function(value){
195    // value === 1
196  });
197  ```
198

199  Instead of writing the above, your code now simply becomes the following:
200
201  ```javascript
202  let promise = Promise.resolve(1);
203
204  promise.then(function(value){
205    // value === 1
206  });
207  ```
208
209  @method resolve
210  @static
211  @param {Any} value value that the returned promise will be resolved with
212  Useful for tooling.
213  @return {Promise} a promise that will become fulfilled with the given
214  `value`
215*/
216function resolve$1(object) {
217  /*jshint validthis:true */
218  var Constructor = this;
219
220  if (object && typeof object === 'object' && object.constructor === Constructor) {
221    return object;
222  }
223
224  var promise = new Constructor(noop);
225  resolve(promise, object);
226  return promise;
227}
228
229var PROMISE_ID = Math.random().toString(36).substring(2);
230
231function noop() {}
232
233var PENDING = void 0;
234var FULFILLED = 1;
235var REJECTED = 2;
236
237function selfFulfillment() {
238  return new TypeError("You cannot resolve a promise with itself");
239}
240
241function cannotReturnOwn() {
242  return new TypeError('A promises callback cannot return that same promise.');
243}
244
245function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
246  try {
247    then$$1.call(value, fulfillmentHandler, rejectionHandler);
248  } catch (e) {
249    return e;
250  }
251}
252
253function handleForeignThenable(promise, thenable, then$$1) {
254  asap(function (promise) {
255    var sealed = false;
256    var error = tryThen(then$$1, thenable, function (value) {
257      if (sealed) {
258        return;
259      }
260      sealed = true;
261      if (thenable !== value) {
262        resolve(promise, value);
263      } else {
264        fulfill(promise, value);
265      }
266    }, function (reason) {
267      if (sealed) {
268        return;
269      }
270      sealed = true;
271
272      reject(promise, reason);
273    }, 'Settle: ' + (promise._label || ' unknown promise'));
274
275    if (!sealed && error) {
276      sealed = true;
277      reject(promise, error);
278    }
279  }, promise);
280}
281
282function handleOwnThenable(promise, thenable) {
283  if (thenable._state === FULFILLED) {
284    fulfill(promise, thenable._result);
285  } else if (thenable._state === REJECTED) {
286    reject(promise, thenable._result);
287  } else {
288    subscribe(thenable, undefined, function (value) {
289      return resolve(promise, value);
290    }, function (reason) {
291      return reject(promise, reason);
292    });
293  }
294}
295
296function handleMaybeThenable(promise, maybeThenable, then$$1) {
297  if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
298    handleOwnThenable(promise, maybeThenable);
299  } else {
300    if (then$$1 === undefined) {
301      fulfill(promise, maybeThenable);
302    } else if (isFunction(then$$1)) {
303      handleForeignThenable(promise, maybeThenable, then$$1);
304    } else {
305      fulfill(promise, maybeThenable);
306    }
307  }
308}
309
310function resolve(promise, value) {
311  if (promise === value) {
312    reject(promise, selfFulfillment());
313  } else if (objectOrFunction(value)) {
314    var then$$1 = void 0;
315    try {
316      then$$1 = value.then;
317    } catch (error) {
318      reject(promise, error);
319      return;
320    }
321    handleMaybeThenable(promise, value, then$$1);
322  } else {
323    fulfill(promise, value);
324  }
325}
326
327function publishRejection(promise) {
328  if (promise._onerror) {
329    promise._onerror(promise._result);
330  }
331
332  publish(promise);
333}
334
335function fulfill(promise, value) {
336  if (promise._state !== PENDING) {
337    return;
338  }
339
340  promise._result = value;
341  promise._state = FULFILLED;
342
343  if (promise._subscribers.length !== 0) {
344    asap(publish, promise);
345  }
346}
347
348function reject(promise, reason) {
349  if (promise._state !== PENDING) {
350    return;
351  }
352  promise._state = REJECTED;
353  promise._result = reason;
354
355  asap(publishRejection, promise);
356}
357
358function subscribe(parent, child, onFulfillment, onRejection) {
359  var _subscribers = parent._subscribers;
360  var length = _subscribers.length;
361
362
363  parent._onerror = null;
364
365  _subscribers[length] = child;
366  _subscribers[length + FULFILLED] = onFulfillment;
367  _subscribers[length + REJECTED] = onRejection;
368
369  if (length === 0 && parent._state) {
370    asap(publish, parent);
371  }
372}
373
374function publish(promise) {
375  var subscribers = promise._subscribers;
376  var settled = promise._state;
377
378  if (subscribers.length === 0) {
379    return;
380  }
381
382  var child = void 0,
383      callback = void 0,
384      detail = promise._result;
385
386  for (var i = 0; i < subscribers.length; i += 3) {
387    child = subscribers[i];
388    callback = subscribers[i + settled];
389
390    if (child) {
391      invokeCallback(settled, child, callback, detail);
392    } else {
393      callback(detail);
394    }
395  }
396
397  promise._subscribers.length = 0;
398}
399
400function invokeCallback(settled, promise, callback, detail) {
401  var hasCallback = isFunction(callback),
402      value = void 0,
403      error = void 0,
404      succeeded = true;
405
406  if (hasCallback) {
407    try {
408      value = callback(detail);
409    } catch (e) {
410      succeeded = false;
411      error = e;
412    }
413
414    if (promise === value) {
415      reject(promise, cannotReturnOwn());
416      return;
417    }
418  } else {
419    value = detail;
420  }
421
422  if (promise._state !== PENDING) {
423    // noop
424  } else if (hasCallback && succeeded) {
425    resolve(promise, value);
426  } else if (succeeded === false) {
427    reject(promise, error);
428  } else if (settled === FULFILLED) {
429    fulfill(promise, value);
430  } else if (settled === REJECTED) {
431    reject(promise, value);
432  }
433}
434
435function initializePromise(promise, resolver) {
436  try {
437    resolver(function resolvePromise(value) {
438      resolve(promise, value);
439    }, function rejectPromise(reason) {
440      reject(promise, reason);
441    });
442  } catch (e) {
443    reject(promise, e);
444  }
445}
446
447var id = 0;
448function nextId() {
449  return id++;
450}
451
452function makePromise(promise) {
453  promise[PROMISE_ID] = id++;
454  promise._state = undefined;
455  promise._result = undefined;
456  promise._subscribers = [];
457}
458
459function validationError() {
460  return new Error('Array Methods must be provided an Array');
461}
462
463var Enumerator = function () {
464  function Enumerator(Constructor, input) {
465    this._instanceConstructor = Constructor;
466    this.promise = new Constructor(noop);
467
468    if (!this.promise[PROMISE_ID]) {
469      makePromise(this.promise);
470    }
471
472    if (isArray(input)) {
473      this.length = input.length;
474      this._remaining = input.length;
475
476      this._result = new Array(this.length);
477
478      if (this.length === 0) {
479        fulfill(this.promise, this._result);
480      } else {
481        this.length = this.length || 0;
482        this._enumerate(input);
483        if (this._remaining === 0) {
484          fulfill(this.promise, this._result);
485        }
486      }
487    } else {
488      reject(this.promise, validationError());
489    }
490  }
491
492  Enumerator.prototype._enumerate = function _enumerate(input) {
493    for (var i = 0; this._state === PENDING && i < input.length; i++) {
494      this._eachEntry(input[i], i);
495    }
496  };
497
498  Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
499    var c = this._instanceConstructor;
500    var resolve$$1 = c.resolve;
501
502
503    if (resolve$$1 === resolve$1) {
504      var _then = void 0;
505      var error = void 0;
506      var didError = false;
507      try {
508        _then = entry.then;
509      } catch (e) {
510        didError = true;
511        error = e;
512      }
513
514      if (_then === then && entry._state !== PENDING) {
515        this._settledAt(entry._state, i, entry._result);
516      } else if (typeof _then !== 'function') {
517        this._remaining--;
518        this._result[i] = entry;
519      } else if (c === Promise$2

519) {
520        var promise = new c(noop);
521        if (didError) {
522          reject(promise, error);
523        } else {
524          handleMaybeThenable(promise, entry, _then);
525        }
526        this._willSettleAt(promise, i);
527      } else {
528        this._willSettleAt(new c(function (resolve$$1) {
529          return resolve$$1(entry);
530        }), i);
531      }
532    } else {
533      this._willSettleAt(resolve$$1(entry), i);
534    }
535  };
536
537  Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
538    var promise = this.promise;
539
540
541    if (promise._state === PENDING) {
542      this._remaining--;
543
544      if (state === REJECTED) {
545        reject(promise, value);
546      } else {
547        this._result[i] = value;
548      }
549    }
550
551    if (this._remaining === 0) {
552      fulfill(promise, this._result);
553    }
554  };
555
556  Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
557    var enumerator = this;
558
559    subscribe(promise, undefined, function (value) {
560      return enumerator._settledAt(FULFILLED, i, value);
561    }, function (reason) {
562      return enumerator._settledAt(REJECTED, i, reason);
563    });
564  };
565
566  return Enumerator;
567}();
568
569/**
570  `Promise.all` accepts an array of promises, and returns a new promise which
571  is fulfilled with an array of fulfillment values for the passed promises, or
572  rejected with the reason of the first passed promise to be rejected. It casts all
573  elements of the passed iterable to promises as it runs this algorithm.
574
575  Example:
576
577  ```javascript
578  let promise1 = resolve(1);
579  let promise2 = resolve(2);
580  let promise3 = resolve(3);
581  let promises = [ promise1, promise2, promise3 ];
582
583  Promise.all(promises).then(function(array){
584    // The array here would be [ 1, 2, 3 ];
585  });
586  ```
587
588  If any of the `promises` given to `all` are rejected, the first promise
589  that is rejected will be given as an argument to the returned promises's
590  rejection handler. For example:
591
592  Example:
593
594  ```javascript
595  let promise1 = resolve(1);
596  let promise2 = reject(new Error("2"));
597  let promise3 = reject(new Error("3"));
598  let promises = [ promise1, promise2, promise3 ];
599
600  Promise.all(promises).then(function(array){
601    // Code here never runs because there are rejected promises!
602  }, function(error) {
603    // error.message === "2"
604  });
605  ```
606
607  @method all
608  @static
609  @param {Array} entries array of promises
610  @param {String} label optional string for labeling the promise.
611  Useful for tooling.
612  @return {Promise} promise that is fulfilled when all `promises` have been
613  fulfilled, or rejected if any of them become rejected.
614  @static
615*/
616function all(entries) {
617  return new Enumerator(this, entries).promise;
618}
619
620/**
621  `Promise.race` returns a new promise which is settled in the same way as the
622  first passed promise to settle.
623
624  Example:
625
626  ```javascript
627  let promise1 = new Promise(function(resolve, reject){
628    setTimeout(function(){
629      resolve('promise 1');
630    }, 200);
631  });
632
633  let promise2 = new Promise(function(resolve, reject){
634    setTimeout(function(){
635      resolve('promise 2');
636    }, 100);
637  });
638
639  Promise.race([promise1, promise2]).then(function(result){
640    // result === 'promise 2' because it was resolved before promise1
641    // was resolved.
642  });
643  ```
644
645  `Promise.race` is deterministic in that only the state of the first
646  settled promise matters. For example, even if other promises given to the
647  `promises` array argument are resolved, but the first settled promise has
648  become rejected before the other promises became fulfilled, the returned
649  promise will become rejected:
650
651  ```javascript
652  let promise1 = new Promise(function(resolve, reject){
653    setTimeout(function(){
654      resolve('promise 1');
655    }, 200);
656  });
657
658  let promise2 = new Promise(function(resolve, reject){
659    setTimeout(function(){
660      reject(new Error('promise 2'));
661    }, 100);
662  });
663
664  Promise.race([promise1, promise2]).then(function(result){
665    // Code here never runs
666  }, function(reason){
667    // reason.message === 'promise 2' because promise 2 became rejected before
668    // promise 1 became fulfilled
669  });
670  ```
671
672  An example real-world use case is implementing timeouts:
673
674  ```javascript
675  Promise.race([ajax('foo.json'), timeout(5000)])
676  ```
677
678  @method race
679  @static
680  @param {Array} promises array of promises to observe
681  Useful for tooling.
682  @return {Promise} a promise which settles in the same way as the first passed
683  promise to settle.
684*/
685function race(entries) {
686  /*jshint validthis:true */
687  var Constructor = this;
688
689  if (!isArray(entries)) {
690    return new Constructor(function (_, reject) {
691      return reject(new TypeError('You must pass an array to race.'));
692    });
693  } else {
694    return new Constructor(function (resolve, reject) {
695      var length = entries.length;
696      for (var i = 0; i < length; i++) {
697        Constructor.resolve(entries[i]).then(resolve, reject);
698      }
699    });
700  }
701}
702
703/**
704  `Promise.reject` returns a promise rejected with the passed `reason`.
705  It is shorthand for the following:
706
707  ```javascript
708  let promise = new Promise(function(resolve, reject){
709    reject(new Error('WHOOPS'));
710  });
711
712  promise.then(function(value){
713    // Code here doesn't run because the promise is rejected!
714  }, function(reason){
715    // reason.message === 'WHOOPS'
716  });
717  ```
718
719  Instead of writing the above, your code now simply becomes the following:
720
721  ```javascript
722  let promise = Promise.reject(new Error('WHOOPS'));
723
724  promise.then(function(value){
725    // Code here doesn't run because the promise is rejected!
726  }, function(reason){
727    // reason.message === 'WHOOPS'
728  });
729  ```
730
731  @method reject
732  @static
733  @param {Any} reason value that the returned promise will be rejected with.
734  Useful for tooling.
735  @return {Promise} a promise rejected with the given `reason`.
736*/
737function reject$1(reason) {
738  /*jshint validthis:true */
739  var Constructor = this;
740  var promise = new Constructor(noop);
741  reject(promise, reason);
742  return promise;
743}
744
745function needsResolver() {
746  throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
747}
748
749function needsNew() {
750  throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
751}
752
753/**
754  Promise objects represent the eventual result of an asynchronous operation. The
755  primary way of interacting with a promise is through its `then` method, which
756  registers callbacks to receive either a promise's eventual value or the reason
757  why the promise cannot be fulfilled.
758
759  Terminology
760  -----------
761
762  - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
763  - `thenable` is an object or function that defines a `then` method.
764  - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
765  - `exception` is a value that is thrown using the throw statement.
766  - `reason` is a value that indicates why a promise was rejected.
767  - `settled` the final resting state of a promise, fulfilled or rejected.
768
769  A promise can be in one of three states: pending, fulfilled, or rejected.
770
771  Promises that are fulfilled have a fulfillment value and are in the fulfilled
772  state.  Promises that are rejected have a rejection reason and are in the
773  rejected state.  A fulfillment value is never a thenable.
774
775  Promises can also be said to *resolve* a value.  If this value is also a
776  promise, then the original promise's settled state will match the value's
777  settled state.  So a promise that *resolves* a promise that rejects will
778  itself reject, and a promise that *resolves* a promise that fulfills will
779  itself fulfill.
780
781
782  Basic Usage:
783  ------------
784
785  ```js
786  let promise = new Promise(function(resolve, reject) {
787    // on success
788    resolve(value);
789
790    // on failure
791    reject(reason);
792  });
793
794  promise.then(function(value) {
795    // on fulfillment
796  }, function(reason) {
797    // on rejection
798  });
799  ```
800
801  Advanced Usage:
802  ---------------
803
804  Promises shine when abstracting away asynchronous interactions such as
805  `XMLHttpRequest`s.
806
807  ```js
808  function getJSON(url) {
809    return new Promise(function(resolve, reject){
810      let xhr = new XMLHttpRequest();
811
812      xhr.open('GET', url);
813      xhr.onreadystatechange = handler;
814      xhr.responseType = 'json';
815      xhr.setRequestHeader('Accept', 'application/json');
816      xhr.send();
817
818      function handler() {
819        if (this.readyState === this.DONE) {
820          if (this.status === 200) {
821            resolve(this.response);
822          } else {
823            reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
824          }
825        }
826      };
827    });
828  }
829
830  getJSON('/posts.json').then(function(json) {
831    // on fulfillment
832  }, function(reason) {
833    // on rejection
834  });
835  ```
836
837  Unlike callbacks, promises are great composable primitives.
838
839  ```js
840  Promise.all([
841    getJSON('/posts'),
842    getJSON('/comments')
843  ]).then(function(values){
844    values[0] // => postsJSON
845    values[1] // => commentsJSON
846
847    return values;
848  });
849  ```
850
851  @class Promise
852  @param {Function} resolver
853  Useful for tooling.
854  @constructor
855*/
856
857var Promise$

1181/* jshint latedef: false */
1182
1183+function ($) {
1184  'use strict';
1185
1186  // COLLAPSE PUBLIC CLASS DEFINITION
1187  // ================================
1188
1189  var Collapse = function (element, options) {
1190    this.$element      = $(element)
1191    this.options       = $.extend({}, Collapse.DEFAULTS, options)
1192    this.$trigger      = $('[data-toggle="collapse"][href="#' + element.id + '"],' +
1193                           '[data-toggle="collapse"][data-target="#' + element.id + '"]')
1194    this.transitioning = null
1195
1196    if (this.options.parent) {
1197      this.$parent = this.getParent()
1198    } else {
1199      this.addAriaAndCollapsedClass(this.$element, this.$trigger)
1200    }
1201
1202    if (this.options.toggle) this.toggle()
1203  }
1204
1205  Collapse.VERSION  = '3.3.7'
1206
1207  Collapse.TRANSITION_DURATION = 350
1208
1209  Collapse.DEFAULTS = {
1210    toggle: true
1211  }
1212
1213  Collapse.prototype.dimension = function () {
1214    var hasWidth = this.$element.hasClass('width')
1215    return hasWidth ? 'width' : 'height'
1216  }
1217
1218  Collapse.prototype.show = function () {
1219    if (this.transitioning || this.$element.hasClass('in')) return
1220
1221    var activesData
1222    var actives = this.$parent && this.$parent.children('.panel').children('.in, .collapsing')
1223
1224    if (actives && actives.length) {
1225      activesData = actives.data('bs.collapse')
1226      if (activesData && activesData.transitioning) return
1227    }
1228
1229    var startEvent = $.Event('show.bs.collapse')
1230    this.$element.trigger(startEvent)
1231    if (startEvent.isDefaultPrevented()) return
1232
1233    if (actives && actives.length) {
1234      Plugin.call(actives, 'hide')
1235      activesData || actives.data('bs.collapse', null)
1236    }
1237
1238    var dimension = this.dimension()
1239
1240    this.$element
1241      .removeClass('collapse')
1242      .addClass('collapsing')[dimension](0)
1243      .attr('aria-expanded', true)
1244
1245    this.$trigger
1246      .removeClass('collapsed')
1247      .attr('aria-expanded', true)
1248
1249    this.transitioning = 1
1250
1251    var complete = function () {
1252      this.$element
1253        .removeClass('collapsing')
1254        .addClass('collapse in')[dimension]('')
1255      this.transitioning = 0
1256      this.$element
1257        .trigger('shown.bs.collapse')
1258    }
1259
1260    if (!$.support.transition) return complete.call(this)
1261
1262    var scrollSize = $.camelCase(['scroll', dimension].join('-'))
1263
1264    this.$element
1265      .one('bsTransitionEnd', $.proxy(complete, this))
1266      .emulateTransitionEnd(Collapse.TRANSITION_DURATION)[dimension](this.$element[0][scrollSize])
1267  }
1268
1269  Collapse.prototype.hide = function () {
1270    if (this.transitioning || !this.$element.hasClass('in')) return
1271
1272    var startEvent = $.Event('hide.bs.collapse')
1273    this.$element.trigger(startEvent)
1274    if (startEvent.isDefaultPrevented()) return
1275
1276    var dimension = this.dimension()
1277
1278    this.$element[dimension](this.$element[dimension]())[0].offsetHeight
1279
1280    this.$element
1281      .addClass('collapsing')
1282      .removeClass('collapse in')
1283      .attr('aria-expanded', false)
1284
1285    this.$trigger
1286      .addClass('collapsed')
1287      .attr('aria-expanded', false)
1288
1289    this.transitioning = 1
1290
1291    var complete = function () {
1292      this.transitioning = 0
1293      this.$element
1294        .removeClass('collapsing')
1295        .addClass('collapse')
1296        .trigger('hidden.bs.collapse')
1297    }
1298
1299    if (!$.support.transition) return complete.call(this)
1300
1301    this.$element
1302      [dimension](0)
1303      .one('bsTransitionEnd', $.proxy(complete, this))
1304      .emulateTransitionEnd(Collapse.TRANSITION_DURATION)
1305  }
1306
1307  Collapse.prototype.toggle = function () {
1308    this[this.$element.hasClass('in') ? 'hide' : 'show']()
1309  }
1310
1311  Collapse.prototype.getParent = function () {
1312    return $(this.options.parent)
1313      .find('[data-toggle="collapse"][data-parent="' + this.options.parent + '"]')
1314      .each($.proxy(function (i, element) {
1315        var $element = $(element)
1316        this.addAriaAndCollapsedClass(getTargetFromTrigger($element), $element)
1317      }, this))
1318      .end()
1319  }
1320
1321  Collapse.prototype.addAriaAndCollapsedClass = function ($element, $trigger) {
1322    var isOpen = $element.hasClass('in')
1323
1324    $element.attr('aria-expanded', isOpen)
1325    $trigger
1326      .toggleClass('collapsed', !isOpen)
1327      .attr('aria-expanded', isOpen)
1328  }
1329
1330  function getTargetFromTrigger($trigger) {
1331    var href
1332    var target = $trigger.attr('data-target')
1333      || (href = $trigger.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '') // strip for ie7
1334
1335    return $(target)
1336  }
1337
1338
1339  // COLLAPSE PLUGIN DEFINITION
1340  // ==========================
1341
1342  function Plugin(option) {
1343    return this.each(function () {
1344      var $this   = $(this)
1345      var data    = $this.data('bs.collapse')
1346      var options = $.extend({}, Collapse.DEFAULTS, $this.data(), typeof option == 'object' && option)
1347
1348      if (!data && options.toggle && /show|hide/.test(option)) options.toggle = false
1349      if (!data) $this.data('bs.collapse', (data = new Collapse(this, options)))
1350      if (typeof option == 'string') data[option]()
1351    })
1352  }
1353
1354  var old = $.fn.collapse
1355
1356  $.fn.collapse             = Plugin
1357  $.fn.collapse.Constructor = Collapse
1358
1359
1360  // COLLAPSE NO CONFLICT
1361  // ====================
1362
1363  $.fn.collapse.noConflict = function () {
1364    $.fn.collapse = old
1365    return this
1366  }
1367
1368
1369  // COLLAPSE DATA-API
1370  // =================
1371
1372  $(document).on('click.bs.collapse.data-api', '[data-toggle="collapse"]', function (e) {
1373    var $this   = $(this)
1374
1375    if (!$this.attr('data-target')) e.preventDefault()
1376
1377    var $target = getTargetFromTrigger($this)
1378    var data    = $target.data('bs.collapse')
1379    var option  = data ? 'toggle' : $this.data()
1380
1381    Plugin.call($target, option)
1382  })
1383
1384}(jQuery);
1385
1386/* ========================================================================
1387 * Bootstrap: dropdown.js v3.3.7
1388 * http://getbootstrap.com/javascript/#dropdowns
1389 * ========================================================================
1390 * Copyright 2011-2016 Twitter, Inc.
1391 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
1392 * ======================================================================== */
1393
1394
1395+function ($) {
1396  'use strict';
1397
1398  // DROPDOWN CLASS DEFINITION
1399  // =========================
1400
1401  var backdrop = '.dropdown-backdrop'
1402  var toggle   = '[data-toggle="dropdown"]'
1403  var Dropdown = function (element) {
1404    $(element).on('click.bs.dropdown', this.toggle)
1405  }
1406
1407  Dropdown.VERSION = '3.3.7'
1408
1409  function getParent($this) {
1410    var selector = $this.attr('data-target')
1411
1412    if (!selector) {
1413      selector = $this.attr('href')
1414      selector = selector && /#[A-Za-z]/.test(selector) && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
1415    }
1416
1417    var $parent = selector && $(selector)
1418
1419    return $parent && $parent.length ? $parent : $this.parent()
1420  }
1421
1422  function clearMenus(e) {
1423    if (e && e.which === 3) return
1424    $(backdrop).remove()
1425    $(toggle).each(function () {
1426      var $this         = $(this)
1427      var $parent       = getParent($this)
1428      var relatedTarget = { relatedTarget: this }
1429
1430      if (!$parent.hasClass('open')) return
1431
1432      if (e && e.type == 'click' && /input|textarea/i.test(e.target.tagName) && $.contains($parent[0], e.target)) return
1433
1434      $parent.trigger(e = $.Event('hide.bs.dropdown', relatedTarget))
1435
1436      if (e.isDefaultPrevented()) return
1437
1438      $this.attr('aria-expanded', 'false')
1439      $parent.removeClass('open').trigger($.Event('hidden.bs.dropdown', relatedTarget))
1440    })
1441  }
1442
1443  Dropdown.prototype.toggle = function (e) {
1444    var $this = $(this)
1445
1446    if ($this.is('.disabled, :disabled')) return
1447
1448    var $parent  = getParent($this)
1449    var isActive = $parent.hasClass('open')
1450
1451    clearMenus()
1452
1453    if (!isActive) {
1454      if ('ontouchstart' in document.documentElement && !$parent.closest('.navbar-nav').length) {
1455        // if mobile we use a backdrop because click events don't delegate
1456        $(document.createElement('div'))
1457          .addClass('dropdown-backdrop')
1458          .insertAfter($(this))
1459          .on('click', clearMenus)
1460      }
1461
1462      var relatedTarget = { relatedTarget: this }
1463      $parent.trigger(e = $.Event('show.bs.dropdown', relatedTarget))
1464
1465      if (e.isDefaultPrevented()) return
1466
1467      $this
1468        .trigger('focus')
1469        .attr('aria-expanded', 'true')
1470
1471      $parent
1472        .toggleClass('open')
1473        .trigger($.Event('shown.bs.dropdown', relatedTarget))
1474    }
1475
1476    return false
1477  }
1478
1479  Dropdown.prototype.keydown = function (e) {
1480    if (!/(38|40|27|32)/.test(e.which) || /input|textarea/i.test(e.target.tagName)) return
1481
1482    var $this = $(this)
1483
1484    e.preventDefault()
1485    e.stopPropagation()
1486
1487    if ($this.is('.disabled, :disabled')) return
1488
1489    var $parent  = getParent($this)
1490    var isActive = $parent.hasClass('open')
1491
1492    if (!isActive && e.which != 27 || isActive && e.which == 27) {
1493      if (e.which == 27) $parent.find(toggle).trigger('focus')
1494      return $this.trigger('click')
1495    }
1496
1497    var desc = ' li:not(.disabled):visible a'
1498    var $items = $parent.find('.dropdown-menu' + desc)
1499
1500    if (!$items.length) return
1501
1502    var index = $items.index(e.target)
1503
1504    if (e.which == 38 && index > 0)                 index--         // up
1505    if (e.which == 40 && index < $items.length - 1) index++         // down
1506    if (!~index)                                    index = 0
1507
1508    $items.eq(index).trigger('focus')
1509  }
1510
1511
1512  // DROPDOWN PLUGIN DEFINITION
1513  // ==========================
1514
1515  function Plugin(option) {
1516    return this.each(function () {
1517      var $this = $(this)
1518      var data  = $this.data('bs.dropdown')
1519
1520      if (!data) $this.data('bs.dropdown', (data = new Dropdown(this)))
1521      if (typeof option == 'string') data[option].call($this)
1522    })
1523  }
1524
1525  var old = $.fn.dropdown
1526
1527  $.fn.dropdown             = Plugin
1528  $.fn.dropdown.Constructor = Dropdown
1529
1530
1531  // DROPDOWN NO CONFLICT
1532  // ====================
1533
1534  $.fn.dropdown.noConflict = function () {
1535    $.fn.dropdown = old
1536    return this
1537  }
1538
1539
1540  // APPLY TO STANDARD DROPDOWN ELEMENTS
1541  // ===================================
1542
1543  $(document)
1544    .on('click.bs.dropdown.data-api', clearMenus)
1545    .on('click.bs.dropdown.data-api', '.dropdown form', function (e) { e.stopPropagation() })
1546    .on('click.bs.dropdown.data-api', toggle, Dropdown.prototype.toggle)
1547    .on('keydown.bs.dropdown.data-api', toggle, Dropdown.prototype.keydown)
1548    .on('keydown.bs.dropdown.data-api', '.dropdown-menu', Dropdown.prototype.keydown)
1549
1550}(jQuery);
1551
1552/* ========================================================================
1553 * Bootstrap: transition.js v3.3.7
1554 * http://getbootstrap.com/javascript/#transitions
1555 * ========================================================================
1556 * Copyright 2011-2016 Twitter, Inc.
1557 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
1558 * ======================================================================== */
1559
1560
1561+function ($) {
1562  'use strict';
1563
1564  // CSS TRANSITION SUPPORT (Shoutout: http://www.modernizr.com/)
1565  // ============================================================
1566
1567  function transitionEnd() {
1568    var el = document.createElement('bootstrap')
1569
1570    var transEndEventNames = {
1571      WebkitTransition : 'webkitTransitionEnd',
1572      MozTransition    : 'transitionend',
1573      OTransition      : 'oTransitionEnd otransitionend',
1574      transition       : 'transitionend'
1575    }
1576
1577    for (var name in transEndEventNames) {
1578      if (el.style[name] !== undefined) {
1579        return { end: transEndEventNames[name] }
1580      }
1581    }
1582
1583    return false // explicit for ie8 (  ._.)
1584  }
1585
1586  // http://blog.alexmaccaw.com/css-transitions
1587  $.fn.emulateTransitionEnd = function (duration) {
1588    var called = false
1589    var $el = this
1590    $(this).one('bsTransitionEnd', function () { called = true })
1591    var callback = function () { if (!called) $($el).trigger($.support.transition.end) }
1592    setTimeout(callback, duration)
1593    return this
1594  }
1595
1596  $(function () {
1597    $.support.transition = transitionEnd()
1598
1599    if (!$.support.transition) return
1600
1601    $.event.special.bsTransitionEnd = {
1602      bindType: $.support.transition.end,
1603      delegateType: $.support.transition.end,
1604      handle: function (e) {
1605        if ($(e.target).is(this)) return e.handleObj.handler.apply(this, arguments)
1606      }
1607    }
1608  })
1609
1610}(jQuery);
1611

1612/**
1613 * @license
1614 * Lodash <https://lodash.com/>
1615 * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
1616 * Released under MIT license <https://lodash.com/license>
1617 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
1618 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
1619 */
1620;(function() {
1621
1622  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
1623  var undefined;
1624
1625  /** Used as the semantic version number. */
1626  var VERSION = '4.17.21';
1627
1628  /** Used as the size to enable large array optimizations. */
1629  var LARGE_ARRAY_SIZE = 200;
1630
1631  /** Error message constants. */
1632  var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',
1633      FUNC_ERROR_TEXT = 'Expected a function',
1634      INVALID_TEMPL_VAR_ERROR_TEXT = 'Invalid `variable` option passed into `_.template`';
1635
1636  /** Used to stand-in for `undefined` hash values. */
1637  var HASH_UNDEFINED = '__lodash_hash_undefined__';
1638
1639  /** Used as the maximum memoize cache size. */
1640  var MAX_MEMOIZE_SIZE = 500;
1641
1642  /** Used as the internal argument placeholder. */
1643  var PLACEHOLDER = '__lodash_placeholder__';
1644
1645  /** Used to compose bitmasks for cloning. */
1646  var CLONE_DEEP_FLAG = 1,
1647      CLONE_FLAT_FLAG = 2,
1648      CLONE_SYMBOLS_FLAG = 4;
1649
1650  /** Used to compose bitmasks for value comparisons. */
1651  var COMPARE_PARTIAL_FLAG = 1,
1652      COMPARE_UNORDERED_FLAG = 2;
1653
1654  /** Used to compose bitmasks for function metadata. */
1655  var WRAP_BIND_FLAG = 1,
1656      WRAP_BIND_KEY_FLAG = 2,
1657      WRAP_CURRY_BOUND_FLAG = 4,
1658      WRAP_CURRY_FLAG = 8,
1659      WRAP_CURRY_RIGHT_FLAG = 16,
1660      WRAP_PARTIAL_FLAG = 32,
1661      WRAP_PARTIAL_RIGHT_FLAG = 64,
1662      WRAP_ARY_FLAG = 128,
1663      WRAP_REARG_FLAG = 256,
1664      WRAP_FLIP_FLAG = 512;
1665
1666  /** Used as default options for `_.truncate`. */
1667  var DEFAULT_TRUNC_LENGTH = 30,
1668      DEFAULT_TRUNC_OMISSION = '...';
1669
1670  /** Used to detect hot functions by number of calls within a span of milliseconds. */
1671  var HOT_COUNT = 800,
1672      HOT_SPAN = 16;
1673
1674  /** Used to indicate the type of lazy iteratees. */
1675  var LAZY_FILTER_FLAG = 1,
1676      LAZY_MAP_FLAG = 2,
1677      LAZY_WHILE_FLAG = 3;
1678
1679  /** Used as references for various `Number` constants. */
1680  var INFINITY = 1 / 0,
1681      MAX_SAFE_INTEGER = 9007199254740991,
1682      MAX_INTEGER = 1.7976931348623157e+308,
1683      NAN = 0 / 0;
1684
1685  /** Used as references for the maximum length and index of an array. */
1686  var MAX_ARRAY_LENGTH = 4294967295,
1687      MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,
1688      HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
1689
1690  /** Used to associate wrap methods with their bit flags. */
1691  var wrapFlags = [
1692    ['ary', WRAP_ARY_FLAG],
1693    ['bind', WRAP_BIND_FLAG],
1694    ['bindKey', WRAP_BIND_KEY_FLAG],
1695    ['curry', WRAP_CURRY_FLAG],
1696    ['curryRight', WRAP_CURRY_RIGHT_FLAG],
1697    ['flip', WRAP_FLIP_FLAG],
1698    ['partial', WRAP_PARTIAL_FLAG],
1699    ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
1700    ['rearg', WRAP_REARG_FLAG]
1701  ];
1702
1703  /** `Object#toString` result references. */
1704  var argsTag = '[object Arguments]',
1705      arrayTag = '[object Array]',
1706      asyncTag = '[object AsyncFunction]',
1707      boolTag = '[object Boolean]',
1708      dateTag = '[object Date]',
1709      domExcTag = '[object DOMException]',
1710      errorTag = '[object Error]',
1711      funcTag = '[object Function]',
1712      genTag = '[object GeneratorFunction]',
1713      mapTag = '[object Map]',
1714      numberTag = '[object Number]',
1715      nullTag = '[object Null]',
1716      objectTag = '[object Object]',
1717      promiseTag = '[object Promise]',
1718      proxyTag = '[object Proxy]',
1719      regexpTag = '[object RegExp]',
1720      setTag = '[object Set]',
1721      stringTag = '[object String]',
1722      symbolTag = '[object Symbol]',
1723      undefinedTag = '[object Undefined]',
1724      weakMapTag = '[object WeakMap]',
1725      weakSetTag = '[object WeakSet]';
1726
1727  var arrayBufferTag = '[object ArrayBuffer]',
1728      dataViewTag = '[object DataView]',
1729      float32Tag = '[object Float32Array]',
1730      float64Tag = '[object Float64Array]',
1731      int8Tag = '[object Int8Array]',
1732      int16Tag = '[object Int16Array]',
1733      int32Tag = '[object Int32Array]',
1734      uint8Tag = '[object Uint8Array]',
1735      uint8ClampedTag = '[object Uint8ClampedArray]',
1736      uint16Tag = '[object Uint16Array]',
1737      uint32Tag = '[object Uint32Array]';
1738
1739  /** Used to match empty string literals in compiled template source. */
1740  var reEmptyStringLeading = /\b__p \+= '';/g,
1741      reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
1742      reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
1743
1744  /** Used to match HTML entities and HTML characters. */
1745  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,
1746      reUnescapedHtml = /[&<>"']/g,
1747      reHasEscapedHtml = RegExp(reEscapedHtml.source),
1748      reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
1749
1750  /** Used to match template delimiters. */
1751  var reEscape = /<%-([\s\S]+?)%>/g,
1752      reEvaluate = /<%([\s\S]+?)%>/g,
1753      reInterpolate = /<%=([\s\S]+?)%>/g;
1754
1755  /** Used to match property names within property paths. */
1756  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
1757      reIsPlainProp = /^\w*$/,
1758      rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
1759
1760  /**
1761   * Used to match `RegExp`
1762   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
1763   */
1764  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,
1765      reHasRegExpChar = RegExp(reRegExpChar.source);
1766
1767  /** Used to match leading whitespace. */
1768  var reTrimStart = /^\s+/;
1769
1770  /** Used to match a single whitespace character. */
1771  var reWhitespace = /\s/;
1772
1773  /** Used to match wrap detail comments. */
1774  var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
1775      reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,
1776      reSplitDetails = /,? & /;
1777
1778  /** Used to match words composed of alphanumeric characters. */
1779  var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
1780
1781  /**
1782   * Used to validate the `validate` option in `_.template` variable.
1783   *
1784   * Forbids characters which could potentially change the meaning of the function argument definition:
1785   * - "()," (modification of function parameters)
1786   * - "=" (default value)
1787   * - "[]{}" (destructuring of function parameters)
1788   * - "/" (beginning of a comment)
1789   * - whitespace
1790   */
1791  var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;
1792
1793  /** Used to match backslashes in property paths. */
1794  var reEscapeChar = /\\(\\)?/g;
1795
1796  /**
1797   * Used to match
1798   * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).
1799   */
1800  var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
1801
1802  /** Used to match `RegExp` flags from their coerced string values. */
1803  var reFlags = /\w*$/;
1804
1805  /** Used to detect bad signed hexadecimal string values. */
1806  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
1807
1808  /** Used to detect binary string values. */
1809  var reIsBinary = /^0b[01]+$/i;
1810
1811  /** Used to detect host constructors (Safari). */
1812  var reIsHostCtor = /^\[object .+?Constructor\]$/;
1813
1814  /** Used to detect octal string values. */
1815  var reIsOctal = /^0o[0-7]+$/i;
1816
1817  /** Used to detect unsigned integer values. */
1818  var reIsUint = /^(?:0|[1-9]\d*)$/;
1819
1820  /** Used to match Latin Unicode letters (excluding mathematical operators). */
1821  var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
1822
1823  /** Used to ensure capturing order of template delimiters. */
1824  var reNoMatch = /($^)/;
1825
1826  /** Used to match unescaped characters in compiled string literals. */
1827  var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
1828
1829  /** Used to compose unicode character classes. */
1830  var rsAstralRange = '\\ud800-\\udfff',
1831      rsComboMarksRange = '\\u0300-\\u036f',
1832      reComboHalfMarksRange = '\\ufe20-\\ufe2f',
1833      rsComboSymbolsRange = '\\u20d0-\\u20ff',
1834      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
1835      rsDingbatRange = '\\u2700-\\u27bf',
1836      rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
1837      rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
1838      rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
1839      rsPunctuationRange = '\\u2000-\\u206f',
1840      rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',
1841      rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
1842      rsVarRange = '\\ufe0e\\ufe0f',
1843      rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
1844
1845  /** Used to compose unicode capture groups. */
1846  var rsApos = "['\u2019]",
1847      rsAstral = '[' + rsAstralRange + ']',
1848      rsBreak = '[' + rsBreakRange + ']',
1849      rsCombo = '[' + rsComboRange + ']',
1850      rsDigits = '\\d+',
1851      rsDingbat = '[' + rsDingbatRange + ']',
1852      rsLower = '[' + rsLowerRange + ']',
1853      rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
1854      rsFitz = '\\ud83c[\\udffb-\\udfff]',
1855      rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
1856      rsNonAstral = '[^' + rsAstralRange + ']',
1857      rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
1858      rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
1859      rsUpper = '[' + rsUpperRange + ']',
1860      rsZWJ = '\\u200d';
1861
1862  /** Used to compose unicode regexes. */
1863  var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',
1864      rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',
1865      rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
1866      rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
1867      reOptMod = rsModifier + '?',
1868      rsOptVar = '[' + rsVarRange + ']?',
1869      rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
1870      rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',
1871      rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',
1872      rsSeq = rsOptVar + reOptMod + rsOptJoin,
1873      rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,
1874      rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
1875
1876  /** Used to match apostrophes. */
1877  var reApos = RegExp(rsApos, 'g');
1878
1879  /**
1880   * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
1881   * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
1882   */
1883  var reComboMark = RegExp(rsCombo, 'g');
1884
1885  /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
1886  var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
1887
1888  /** Used to match complex or compound words. */
1889  var reUnicodeWord = RegExp([
1890    rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
1891    rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',
1892    rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
1893    rsUpper + '+' + rsOptContrUpper,
1894    rsOrdUpper,
1895    rsOrdLower,
1896    rsDigits,
1897    rsEmoji
1898  ].join('|'), 'g');
1899
1900  /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
1901  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');
1902
1903  /** Used to detect strings that need a more robust regexp to match words. */
1904  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
1905
1906  /** Used to assign default `context` object properties. */
1907  var contextProps = [
1908    'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',
1909    'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',
1910    'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',
1911    'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',
1912    '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'
1913  ];
1914
1915  /** Used to make template sourceURLs easier to identify. */
1916  var templateCounter = -1;
1917
1918  /** Used to identify `toStringTag` values of typed arrays. */
1919  var typedArrayTags = {};
1920  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
1921  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
1922  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
1923  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
1924  typedArrayTags[uint32Tag] = true;
1925  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
1926  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =

1927  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
1928  typedArrayTags[errorTag] = typedArrayTags[funcTag] =
1929  typedArrayTags[mapTag] = typedArrayTags[numberTag] =
1930  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
1931  typedArrayTags[setTag] = typedArrayTags[stringTag] =
1932  typedArrayTags[weakMapTag] = false;
1933
1934  /** Used to identify `toStringTag` values supported by `_.clone`. */
1935  var cloneableTags = {};
1936  cloneableTags[argsTag] = cloneableTags[arrayTag] =
1937  cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
1938  cloneableTags[boolTag] = cloneableTags[dateTag] =
1939  cloneableTags[float32Tag] = cloneableTags[float64Tag] =
1940  cloneableTags[int8Tag] = cloneableTags[int16Tag] =
1941  cloneableTags[int32Tag] = cloneableTags[mapTag] =
1942  cloneableTags[numberTag] = cloneableTags[objectTag] =
1943  cloneableTags[regexpTag] = cloneableTags[setTag] =
1944  cloneableTags[stringTag] = cloneableTags[symbolTag] =
1945  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
1946  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
1947  cloneableTags[errorTag] = cloneableTags[funcTag] =
1948  cloneableTags[weakMapTag] = false;
1949
1950  /** Used to map Latin Unicode letters to basic Latin letters. */
1951  var deburredLetters = {
1952    // Latin-1 Supplement block.
1953    '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
1954    '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
1955    '\xc7': 'C',  '\xe7': 'c',
1956    '\xd0': 'D',  '\xf0': 'd',
1957    '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
1958    '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
1959    '\xcc': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
1960    '\xec': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',
1961    '\xd1': 'N',  '\xf1': 'n',
1962    '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
1963    '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
1964    '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
1965    '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
1966    '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',
1967    '\xc6': 'Ae', '\xe6': 'ae',
1968    '\xde': 'Th', '\xfe': 'th',
1969    '\xdf': 'ss',
1970    // Latin Extended-A block.
1971    '\u0100': 'A',  '\u0102': 'A', '\u0104': 'A',
1972    '\u0101': 'a',  '\u0103': 'a', '\u0105': 'a',
1973    '\u0106': 'C',  '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
1974    '\u0107': 'c',  '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
1975    '\u010e': 'D',  '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
1976    '\u0112': 'E',  '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
1977    '\u0113': 'e',  '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
1978    '\u011c': 'G',  '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
1979    '\u011d': 'g',  '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
1980    '\u0124': 'H',  '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
1981    '\u0128': 'I',  '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
1982    '\u0129': 'i',  '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
1983    '\u0134': 'J',  '\u0135': 'j',
1984    '\u0136': 'K',  '\u0137': 'k', '\u0138': 'k',
1985    '\u0139': 'L',  '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
1986    '\u013a': 'l',  '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
1987    '\u0143': 'N',  '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
1988    '\u0144': 'n',  '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
1989    '\u014c': 'O',  '\u014e': 'O', '\u0150': 'O',
1990    '\u014d': 'o',  '\u014f': 'o', '\u0151': 'o',
1991    '\u0154': 'R',  '\u0156': 'R', '\u0158': 'R',
1992    '\u0155': 'r',  '\u0157': 'r', '\u0159': 'r',
1993    '\u015a': 'S',  '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
1994    '\u015b': 's',  '\u015d': 's', '\u015f': 's', '\u0161': 's',
1995    '\u0162': 'T',  '\u0164': 'T', '\u0166': 'T',
1996    '\u0163': 't',  '\u0165': 't', '\u0167': 't',
1997    '\u0168': 'U',  '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
1998    '\u0169': 'u',  '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
1999    '\u0174': 'W',  '\u0175': 'w',
2000    '\u0176': 'Y',  '\u0177': 'y', '\u0178': 'Y',
2001    '\u0179': 'Z',  '\u017b': 'Z', '\u017d': 'Z',
2002    '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',
2003    '\u0132': 'IJ', '\u0133': 'ij',
2004    '\u0152': 'Oe', '\u0153': 'oe',
2005    '\u0149': "'n", '\u017f': 's'
2006  };
2007
2008  /** Used to map characters to HTML entities. */
2009  var htmlEscapes = {
2010    '&': '&',
2011    '<': '&lt;',
2012    '>': '&gt;',
2013    '"': '&quot;',
2014    "'": '&#39;'
2015  };
2016
2017  /** Used to map HTML entities to characters. */
2018  var htmlUnescapes = {
2019    '&amp;': '&',
2020    '&lt;': '<',
2021    '&gt;': '>',
2022    '&quot;': '"',
2023    '&#39;': "'"
2024  };
2025
2026  /** Used to escape characters for inclusion in compiled string literals. */
2027  var stringEscapes = {
2028    '\\': '\\',
2029    "'": "'",
2030    '\n': 'n',
2031    '\r': 'r',
2032    '\u2028': 'u2028',
2033    '\u2029': 'u2029'
2034  };
2035
2036  /** Built-in method references without a dependency on `root`. */
2037  var freeParseFloat = parseFloat,
2038      freeParseInt = parseInt;
2039
2040  /** Detect free variable `global` from Node.js. */
2041  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
2042
2043  /** Detect free variable `self`. */
2044  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
2045
2046  /** Used as a reference to the global object. */
2047  var root = freeGlobal || freeSelf || Function('return this')();
2048
2049  /** Detect free variable `exports`. */
2050  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
2051
2052  /** Detect free variable `module`. */
2053  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
2054
2055  /** Detect the popular CommonJS extension `module.exports`. */
2056  var moduleExports = freeModule && freeModule.exports === freeExports;
2057
2058  /** Detect free variable `process` from Node.js. */
2059  var freeProcess = moduleExports && freeGlobal.process;
2060
2061  /** Used to access faster Node.js helpers. */

2062  var nodeUtil = (function() {
2063    try {
2064      // Use `util.types` for Node.js 10+.
2065      var types = freeModule && freeModule.require && freeModule.require('util').types;
2066
2067      if (types) {
2068        return types;
2069      }
2070
2071      // Legacy `process.binding('util')` for Node.js < 10.
2072      return freeProcess && freeProcess.binding && freeProcess.binding('util');
2073    } catch (e) {}
2074  }());
2075
2076  /* Node.js helper references. */
2077  var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,
2078      nodeIsDate = nodeUtil && nodeUtil.isDate,
2079      nodeIsMap = nodeUtil && nodeUtil.isMap,
2080      nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,
2081      nodeIsSet = nodeUtil && nodeUtil.isSet,
2082      nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
2083
2084  /*--------------------------------------------------------------------------*/
2085
2086  /**
2087   * A faster alternative to `Function#apply`, this function invokes `func`
2088   * with the `this` binding of `thisArg` and the arguments of `args`.
2089   *
2090   * @private
2091   * @param {Function} func The function to invoke.
2092   * @param {*} thisArg The `this` binding of `func`.
2093   * @param {Array} args The arguments to invoke `func` with.
2094   * @returns {*} Returns the result of `func`.
2095   */
2096  function apply(func, thisArg, args) {
2097    switch (args.length) {
2098      case 0: return func.call(thisArg);
2099      case 1: return func.call(thisArg, args[0]);
2100      case 2: return func.call(thisArg, args[0], args[1]);
2101      case 3: return func.call(thisArg, args[0], args[1], args[2]);
2102    }
2103    return func.apply(thisArg, args);
2104  }
2105
2106  /**
2107   * A specialized version of `baseAggregator` for arrays.
2108   *
2109   * @private
2110   * @param {Array} [array] The array to iterate over.
2111   * @param {Function} setter The function to set `accumulator` values.
2112   * @param {Function} iteratee The iteratee to transform keys.
2113   * @param {Object} accumulator The initial aggregated object.
2114   * @returns {Function} Returns `accumulator`.
2115   */
2116  function arrayAggregator(array, setter, iteratee, accumulator) {
2117    var index = -1,
2118        length = array == null ? 0 : array.length;
2119
2120    while (++index < length) {
2121      var value = array[index];
2122      setter(accumulator, value, iteratee(value), array);
2123    }
2124    return accumulator;
2125  }
2126
2127  /**
2128   * A specialized version of `_.forEach` for arrays without support for
2129   * iteratee shorthands.
2130   *
2131   * @private
2132   * @param {Array} [array] The array to iterate over.
2133   * @param {Function} iteratee The function invoked per iteration.
2134   * @returns {Array} Returns `array`.
2135   */
2136  function arrayEach(array, iteratee) {
2137    var index = -1,
2138        length = array == null ? 0 : array.length;
2139
2140    while (++index < length) {
2141      if (iteratee(array[index], index, array) === false) {
2142        break;
2143      }
2144    }
2145    return array;
2146  }
2147
2148  /**
2149   * A specialized version of `_.forEachRight` for arrays without support for
2150   * iteratee shorthands.
2151   *
2152   * @private
2153   * @param {Array} [array] The array to iterate over.
2154   * @param {Function} iteratee The function invoked per iteration.
2155   * @returns {Array} Returns `array`.
2156   */
2157  function arrayEachRight(array, iteratee) {
2158    var length = array == null ? 0 : array.length;
2159
2160    while (length--) {
2161      if (iteratee(array[length], length, array) === false) {
2162        break;
2163      }
2164    }
2165    return array;
2166  }
2167
2168  /**
2169   * A specialized version of `_.every` for arrays without support for
2170   * iteratee shorthands.
2171   *
2172   * @private
2173   * @param {Array} [array] The array to iterate over.
2174   * @param {Function} predicate The function invoked per iteration.
2175   * @returns {boolean} Returns `true` if all elements pass the predicate check,
2176   *  else `false`.
2177   */
2178  function arrayEvery(array, predicate) {
2179    var index = -1,
2180        length = array == null ? 0 : array.length;
2181
2182    while (++index < length) {
2183      if (!predicate(array[index], index, array)) {
2184        return false;
2185      }
2186    }
2187    return true;
2188  }
2189
2190  /**
2191   * A specialized version of `_.filter` for arrays without support for
2192   * iteratee shorthands.
2193   *
2194   * @private
2195   * @param {Array} [array] The array to iterate over.
2196   * @param {Function} predicate The function invoked per iteration.
2197   * @returns {Array} Returns the new filtered array.
2198   */
2199  function arrayFilter(array, predicate) {
2200    var index = -1,
2201        length = array == null ? 0 : array.length,
2202        resIndex = 0,
2203        result = [];
2204
2205    while (++index < length) {
2206      var value = array[index];
2207      if (predicate(value, index, array)) {
2208        result[resIndex++] = value;
2209      }
2210    }
2211    return result;
2212  }
2213
2214  /**
2215   * A specialized version of `_.includes` for arrays without support for
2216   * specifying an index to search from.
2217   *
2218   * @private
2219   * @param {Array} [array] The array to inspect.
2220   * @param {*} target The value to search for.
2221   * @returns {boolean} Returns `true` if `target` is found, else `false`.
2222   */
2223  function arrayIncludes(array, value) {
2224    var length = array == null ? 0 : array.length;
2225    return !!length && baseIndexOf(array, value, 0) > -1;
2226  }
2227
2228  /**
2229   * This function is like `arrayIncludes` except that it accepts a comparator.
2230   *
2231   * @private
2232   * @param {Array} [array] The array to inspect.
2233   * @param {*} target The value to search for.
2234   * @param {Function} comparator The comparator invoked per element.
2235   * @returns {boolean} Returns `true` if `target` is found, else `false`.
2236   */
2237  function arrayIncludesWith(array, value, comparator) {
2238    var index = -1,
2239        length = array == null ? 0 : array.length;
2240
2241    while (++index < length) {
2242      if (comparator(value, array[index])) {
2243        return true;
2244      }
2245    }
2246    return false;
2247  }
2248
2249  /**
2250   * A specialized version of `_.map` for arrays without support for iteratee
2251   * shorthands.
2252   *
2253   * @private
2254   * @param {Array} [array] The array to iterate over.
2255   * @param {Function} iteratee The function invoked per iteration.
2256   * @returns {Array} Returns the new mapped array.
2257   */
2258  function arrayMap(array, iteratee) {
2259    var index = -1,
2260        length = array == null ? 0 : array.length,
2261        result = Array(length);
2262
2263    while (++index < length) {
2264      result[index] = iteratee(array[index], index, array);
2265    }
2266    return result;
2267  }
2268
2269  /**
2270   * Appends the elements of `values` to `array`.
2271   *
2272   * @private
2273   * @param {Array} array The array to modify.
2274   * @param {Array} values The values to append.
2275   * @returns {Array} Returns `array`.
2276   */
2277  function arrayPush(array, values) {
2278    var index = -1,
2279        length = values.length,
2280        offset = array.length;
2281
2282    while (++index < length) {
2283      array[offset + index] = values[index];
2284    }
2285    return array;
2286  }
2287
2288  /**
2289   * A specialized version of `_.reduce` for arrays without support for
2290   * iteratee shorthands.
2291   *
2292   * @private
2293   * @param {Array} [array] The array to iterate over.
2294   * @param {Function} iteratee The function invoked per iteration.
2295   * @param {*} [accumulator] The initial value.
2296   * @param {boolean} [initAccum] Specify using the first element of `array` as
2297   *  the initial value.
2298   * @returns {*} Returns the accumulated value.
2299   */
2300  function arrayReduce(array, iteratee, accumulator, initAccum) {
2301    var index = -1,
2302        length = array == null ? 0 : array.length;
2303
2304    if (initAccum && length) {
2305      accumulator = array[++index];
2306    }
2307    while (++index < length) {
2308      accumulator = iteratee(accumulator, array[index], index, array);
2309    }
2310    return accumulator;
2311  }
2312
2313  /**
2314   * A specialized version of `_.reduceRight` for arrays without support for
2315   * iteratee shorthands.
2316   *
2317   * @private
2318   * @param {Array} [array] The array to iterate over.
2319   * @param {Function} iteratee The function invoked per iteration.
2320   * @param {*} [accumulator] The initial value.
2321   * @param {boolean} [initAccum] Specify using the last element of `array` as
2322   *  the initial value.
2323   * @returns {*} Returns the accumulated value.
2324   */
2325  function arrayReduceRight(array, iteratee, accumulator, initAccum) {
2326    var length = array == null ? 0 : array.length;
2327    if (initAccum && length) {
2328      accumulator = array[--length];
2329    }
2330    while (length--) {
2331      accumulator = iteratee(accumulator, array[length], length, array);
2332    }
2333    return accumulator;
2334  }
2335
2336  /**
2337   * A specialized version of `_.some` for arrays without support for iteratee
2338   * shorthands.
2339   *
2340   * @private
2341   * @param {Array} [array] The array to iterate over.
2342   * @param {Function} predicate The function invoked per iteration.
2343   * @returns {boolean} Returns `true` if any element passes the predicate check,
2344   *  else `false`.
2345   */
2346  function arraySome(array, predicate) {
2347    var index = -1,
2348        length = array == null ? 0 : array.length;
2349
2350    while (++index < length) {
2351      if (predicate(array[index], index, array)) {
2352        return true;
2353      }
2354    }
2355    return false;

2356  }
2357
2358  /**
2359   * Gets the size of an ASCII `string`.
2360   *
2361   * @private
2362   * @param {string} string The string inspect.
2363   * @returns {number} Returns the string size.
2364   */
2365  var asciiSize = baseProperty('length');
2366
2367  /**
2368   * Converts an ASCII `string` to an array.
2369   *
2370   * @private
2371   * @param {string} string The string to convert.
2372   * @returns {Array} Returns the converted array.
2373   */
2374  function asciiToArray(string) {
2375    return string.split('');
2376  }
2377
2378  /**
2379   * Splits an ASCII `string` into an array of its words.
2380   *
2381   * @private
2382   * @param {string} The string to inspect.
2383   * @returns {Array} Returns the words of `string`.
2384   */
2385  function asciiWords(string) {
2386    return string.match(reAsciiWord) || [];
2387  }
2388
2389  /**
2390   * The base implementation of methods like `_.findKey` and `_.findLastKey`,
2391   * without support for iteratee shorthands, which iterates over `collection`
2392   * using `eachFunc`.
2393   *
2394   * @private
2395   * @param {Array|Object} collection The collection to inspect.
2396   * @param {Function} predicate The function invoked per iteration.
2397   * @param {Function} eachFunc The function to iterate over `collection`.
2398   * @returns {*} Returns the found element or its key, else `undefined`.
2399   */
2400  function baseFindKey(collection, predicate, eachFunc) {
2401    var result;
2402    eachFunc(collection, function(value, key, collection) {
2403      if (predicate(value, key, collection)) {
2404        result = key;
2405        return false;
2406      }
2407    });
2408    return result;
2409  }
2410
2411  /**
2412   * The base implementation of `_.findIndex` and `_.findLastIndex` without
2413   * support for iteratee shorthands.
2414   *
2415   * @private
2416   * @param {Array} array The array to inspect.
2417   * @param {Function} predicate The function invoked per iteration.
2418   * @param {number} fromIndex The index to search from.
2419   * @param {boolean} [fromRight] Specify iterating from right to left.
2420   * @returns {number} Returns the index of the matched value, else `-1`.
2421   */
2422  function baseFindIndex(array, predicate, fromIndex, fromRight) {
2423    var length = array.length,
2424        index = fromIndex + (fromRight ? 1 : -1);
2425
2426    while ((fromRight ? index-- : ++index < length)) {
2427      if (predicate(array[index], index, array)) {
2428        return index;
2429      }
2430    }
2431    return -1;
2432  }
2433
2434  /**
2435   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
2436   *
2437   * @private
2438   * @param {Array} array The array to inspect.
2439   * @param {*} value The value to search for.
2440   * @param {number} fromIndex The index to search from.
2441   * @returns {number} Returns the index of the matched value, else `-1`.
2442   */
2443  function baseIndexOf(array, value, fromIndex) {
2444    return value === value
2445      ? strictIndexOf(array, value, fromIndex)
2446      : baseFindIndex(array, baseIsNaN, fromIndex);
2447  }
2448
2449  /**
2450   * This function is like `baseIndexOf` except that it accepts a comparator.
2451   *
2452   * @private
2453   * @param {Array} array The array to inspect.
2454   * @param {*} value The value to search for.
2455   * @param {number} fromIndex The index to search from.
2456   * @param {Function} comparator The comparator invoked per element.
2457   * @returns {number} Returns the index of the matched value, else `-1`.
2458   */
2459  function baseIndexOfWith(array, value, fromIndex, comparator) {
2460    var index = fromIndex - 1,
2461        length = array.length;
2462
2463    while (++index < length) {
2464      if (comparator(array[index], value)) {
2465        return index;
2466      }
2467    }
2468    return -1;
2469  }
2470
2471  /**
2472   * The base implementation of `_.isNaN` without support for number objects.
2473   *
2474   * @private
2475   * @param {*} value The value to check.
2476   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
2477   */
2478  function baseIsNaN(value) {
2479    return value !== value;
2480  }
2481
2482  /**
2483   * The base implementation of `_.mean` and `_.meanBy` without support for
2484   * iteratee shorthands.
2485   *
2486   * @private
2487   * @param {Array} array The array to iterate over.
2488   * @param {Function} iteratee The function invoked per iteration.
2489   * @returns {number} Returns the mean.
2490   */
2491  function baseMean(array, iteratee) {
2492    var length = array == null ? 0 : array.length;
2493    return length ? (baseSum(array, iteratee) / length) : NAN;
2494  }
2495
2496  /**
2497   * The base implementation of `_.property` without support for deep paths.
2498   *
2499   * @private
2500   * @param {string} key The key of the property to get.
2501   * @returns {Function} Returns the new accessor function.
2502   */
2503  function baseProperty(key) {
2504    return function(object) {
2505      return object == null ? undefined : object[key];
2506    };
2507  }
2508
2509  /**
2510   * The base implementation of `_.propertyOf` without support for deep paths.
2511   *
2512   * @private
2513   * @param {Object} object The object to query.
2514   * @returns {Function} Returns the new accessor function.
2515   */
2516  function basePropertyOf(object) {
2517    return function(key) {
2518      return object == null ? undefined : object[key];
2519    };
2520  }
2521
2522  /**
2523   * The base implementation of `_.reduce` and `_.reduceRight`, without support
2524   * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
2525   *
2526   * @private
2527   * @param {Array|Object} collection The collection to iterate over.
2528   * @param {Function} iteratee The function invoked per iteration.
2529   * @param {*} accumulator The initial value.
2530   * @param {boolean} initAccum Specify using the first or last element of
2531   *  `collection` as the initial value.
2532   * @param {Function} eachFunc The function to iterate over `collection`.
2533   * @returns {*} Returns the accumulated value.
2534   */
2535  function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
2536    eachFunc(collection, function(value, index, collection) {
2537      accumulator = initAccum
2538        ? (initAccum = false, value)
2539        : iteratee(accumulator, value, index, collection);
2540    });
2541    return accumulator;
2542  }
2543
2544  /**
2545   * The base implementation of `_.sortBy` which uses `comparer` to define the
2546   * sort order of `array` and replaces criteria objects with their corresponding
2547   * values.
2548   *
2549   * @private
2550   * @param {Array} array The array to sort.
2551   * @param {Function} comparer The function to define sort order.
2552   * @returns {Array} Returns `array`.
2553   */
2554  function baseSortBy(array, comparer) {
2555    var length = array.length;
2556
2557    array.sort(comparer);
2558    while (length--) {
2559      array[length] = array[length].value;
2560    }
2561    return array;
2562  }
2563
2564  /**
2565   * The base implementation of `_.sum` and `_.sumBy` without support for
2566   * iteratee shorthands.
2567   *
2568   * @private
2569   * @param {Array} array The array to iterate over.
2570   * @param {Function} iteratee The function invoked per iteration.
2571   * @returns {number} Returns the sum.
2572   */
2573  function baseSum(array, iteratee) {
2574    var result,
2575        index = -1,
2576        length = array.length;
2577
2578    while (++index < length) {
2579      var current = iteratee(array[index]);
2580      if (current !== undefined) {
2581        result = result === undefined ? current : (result + current);
2582      }
2583    }
2584    return result;
2585  }
2586
2587  /**
2588   * The base implementation of `_.times` without support for iteratee shorthands
2589   * or max array length checks.
2590   *
2591   * @private
2592   * @param {number} n The number of times to invoke `iteratee`.
2593   * @param {Function} iteratee The function invoked per iteration.
2594   * @returns {Array} Returns the array of results.
2595   */
2596  function baseTimes(n, iteratee) {
2597    var index = -1,
2598        result = Array(n);
2599
2600    while (++index < n) {
2601      result[index] = iteratee(index);
2602    }
2603    return result;
2604  }
2605
2606  /**
2607   * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array
2608   * of key-value pairs for `object` corresponding to the property names of `props`.
2609   *
2610   * @private
2611   * @param {Object} object The object to query.
2612   * @param {Array} props The property names to get values for.
2613   * @returns {Object} Returns the key-value pairs.
2614   */
2615  function baseToPairs(object, props) {
2616    return arrayMap(props, function(key) {
2617      return [key, object[key]];
2618    });
2619  }
2620
2621  /**
2622   * The base implementation of `_.trim`.
2623   *
2624   * @private
2625   * @param {string} string The string to trim.
2626   * @returns {string} Returns the trimmed string.
2627   */
2628  function baseTrim(string) {
2629    return string
2630      ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
2631      : string;
2632  }
2633
2634  /**
2635   * The base implementation of `_.unary` without support for storing metadata.
2636   *
2637   * @private
2638   * @param {Function} func The function to cap arguments for.
2639   * @returns {Function} Returns the new capped function.
2640   */
2641  function baseUnary(func) {
2642    return function(value) {
2643      return func(value);
2644    };
2645  }
2646
2647  /**
2648   * The base implementation of `_.values` and `_.valuesIn` which creates an
2649   * array of `object` property values corresponding to the property names
2650   * of `props`.
2651   *
2652   * @private
2653   * @param {Object} object The object to query.
2654   * @param {Array} props The property names to get values for.
2655   * @returns {Object} Returns the array of property values.
2656   */
2657  function baseValues(object, props) {
2658    return arrayMap(props, function(key) {
2659      return object[key];
2660    });
2661  }
2662
2663  /**
2664   * Checks if a `cache` value for `key` exists.
2665   *
2666   * @private
2667   * @param {Object} cache The cache to query.
2668   * @param {string} key The key of the entry to check.
2669   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
2670   */
2671  function cacheHas(cache, key) {
2672    return cache.has(key);
2673  }
2674
2675  /**
2676   * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol
2677   * that is not found in the character symbols.
2678   *
2679   * @private
2680   * @param {Array} strSymbols The string symbols to inspect.
2681   * @param {Array} chrSymbols The character symbols to find.
2682   * @returns {number} Returns the index of the first unmatched string symbol.
2683   */
2684  function charsStartIndex(strSymbols, chrSymbols) {
2685    var index = -1,
2686        length = strSymbols.length;
2687
2688    while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
2689    return index;
2690  }
2691
2692  /**
2693   * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol
2694   * that is not found in the character symbols.
2695   *
2696   * @private
2697   * @param {Array} strSymbols The string symbols to inspect.
2698   * @param {Array} chrSymbols The character symbols to find.
2699   * @returns {number} Returns the index of the last unmatched string symbol.
2700   */
2701  function charsEndIndex(strSymbols, chrSymbols) {
2702    var index = strSymbols.length;
2703
2704    while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
2705    return index;
2706  }
2707
2708  /**
2709   * Gets the number of `placeholder` occurrences in `array`.
2710   *
2711   * @private
2712   * @param {Array} array The array to inspect.
2713   * @param {*} placeholder The placeholder to search for.
2714   * @returns {number} Returns the placeholder count.
2715   */
2716  function countHolders(array, placeholder) {
2717    var length = array.length,
2718        result = 0;
2719
2720    while (length--) {
2721      if (array[length] === placeholder) {
2722        ++result;
2723      }
2724    }
2725    return result;
2726  }
2727
2728  /**
2729   * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
2730   * letters to basic Latin letters.
2731   *
2732   * @private
2733   * @param {string} letter The matched letter to deburr.
2734   * @returns {string} Returns the deburred letter.
2735   */
2736  var deburrLetter = basePropertyOf(deburredLetters);
2737
2738  /**
2739   * Used by `_.escape` to convert characters to HTML entities.
2740   *
2741   * @private
2742   * @param {string} chr The matched character to escape.
2743   * @returns {string} Returns the escaped character.
2744   */
2745  var escapeHtmlChar = basePropertyOf(htmlEscapes);
2746
2747  /**
2748   * Used by `_.template` to escape characters for inclusion in compiled string literals.
2749   *
2750   * @private
2751   * @param {string} chr The matched character to escape.
2752   * @returns {string} Returns the escaped character.
2753   */
2754  function escapeStringChar(chr) {
2755    return '\\' + stringEscapes[chr];
2756  }
2757
2758  /**
2759   * Gets the value at `key` of `object`.
2760   *
2761   * @private
2762   * @param {Object} [object] The object to query.
2763   * @param {string} key The key of the property to get.
2764   * @returns {*} Returns the property value.
2765   */
2766  function getValue(object, key) {
2767    return object == null ? undefined : object[key];
2768  }
2769
2770  /**
2771   * Checks if `string` contains Unicode symbols.
2772   *
2773   * @private
2774   * @param {string} string The string to inspect.
2775   * @returns {boolean} Returns `true` if a symbol is found, else `false`.
2776   */
2777  function hasUnicode(string) {
2778    return reHasUnicode.test(string);
2779  }
2780
2781  /**
2782   * Checks if `string` contains a word composed of Unicode symbols.
2783   *
2784   * @private
2785   * @param {string} string The string to inspect.
2786   * @returns {boolean} Returns `true` if a word is found, else `false`.
2787   */
2788  function hasUnicodeWord(string) {
2789    return reHasUnicodeWord.test(string);
2790  }
2791
2792  /**
2793   * Converts `iterator` to an array.