{"version":3,"file":"main.js","mappings":"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","sources":["webpack://GEO/./app/javascript/modules/admin-edit-link.js","webpack://GEO/./node_modules/backbone/backbone.js","webpack://GEO/./node_modules/jquery-unorphanize/unorphanize.jquery.js","webpack://GEO/./node_modules/jquery/dist/jquery.js","webpack://GEO/./node_modules/lodash/_Symbol.js","webpack://GEO/./node_modules/lodash/_baseGetTag.js","webpack://GEO/./node_modules/lodash/_freeGlobal.js","webpack://GEO/./node_modules/lodash/_getRawTag.js","webpack://GEO/./node_modules/lodash/_objectToString.js","webpack://GEO/./node_modules/lodash/_root.js","webpack://GEO/./node_modules/lodash/before.js","webpack://GEO/./node_modules/lodash/debounce.js","webpack://GEO/./node_modules/lodash/isObject.js","webpack://GEO/./node_modules/lodash/isObjectLike.js","webpack://GEO/./node_modules/lodash/isSymbol.js","webpack://GEO/./node_modules/lodash/lodash.js","webpack://GEO/./node_modules/lodash/now.js","webpack://GEO/./node_modules/lodash/once.js","webpack://GEO/./node_modules/lodash/toFinite.js","webpack://GEO/./node_modules/lodash/toInteger.js","webpack://GEO/./node_modules/lodash/toNumber.js","webpack://GEO/./node_modules/picturefill/dist/picturefill.js","webpack://GEO/./node_modules/slick-carousel/slick/slick.js","webpack://GEO/./node_modules/underscore/underscore.js","webpack://GEO/webpack/bootstrap","webpack://GEO/webpack/runtime/compat get default export","webpack://GEO/webpack/runtime/define property getters","webpack://GEO/webpack/runtime/global","webpack://GEO/webpack/runtime/hasOwnProperty shorthand","webpack://GEO/webpack/runtime/node module decorator","webpack://GEO/./app/javascript/lib/jquery.chosen.js","webpack://GEO/./app/javascript/modules/background-picture.js","webpack://GEO/./app/javascript/modules/custom-select.js","webpack://GEO/./app/javascript/modules/form-autosubmit.js","webpack://GEO/./app/javascript/modules/user-agent.js","webpack://GEO/./app/javascript/modules/smoothScroll.js","webpack://GEO/./app/javascript/modules/form-validation.js","webpack://GEO/./app/javascript/modules/jump-links.js","webpack://GEO/./app/javascript/modules/mailto.js","webpack://GEO/./app/javascript/modules/events.js","webpack://GEO/./app/javascript/modules/megamenu.js","webpack://GEO/./app/javascript/modules/freeze-scroll.js","webpack://GEO/./app/javascript/modules/modals.js","webpack://GEO/./app/javascript/modules/keycodes.js","webpack://GEO/./app/javascript/modules/modal-toggles.js","webpack://GEO/./app/javascript/modules/multi-select.js","webpack://GEO/./app/javascript/modules/orphans.js","webpack://GEO/./app/javascript/modules/poll.js","webpack://GEO/./app/javascript/modules/publication-drawer.js","webpack://GEO/./app/javascript/modules/question-carousel.js","webpack://GEO/./app/javascript/modules/quiz.js","webpack://GEO/./app/javascript/modules/video-promo.js","webpack://GEO/./app/javascript/modules/vimeo.js","webpack://GEO/./app/javascript/modules/youtube.js","webpack://GEO/./app/javascript/modules/mobile-header.js","webpack://GEO/./app/javascript/modules/desktop-header.js","webpack://GEO/./app/javascript/modules/content-carousel.js","webpack://GEO/./app/javascript/main.js","webpack://GEO/./app/javascript/modules/read-cookie.js"],"sourcesContent":["function AdminEditLink(config) {\n  var self = this;\n  function initialize(config) {\n    try {\n      self.config = config;\n      self.el = config.el;\n      // console.log(config.el);\n    } catch (e) {\n      console.warn(\n        'A DOM nodes was not passed as config of the AdminEditLink instance.',\n        e\n      );\n      return false;\n    }\n\n    self.render();\n  }\n\n  this.createAnchor = function(config) {\n    try {\n      var settings = {\n        class: !!config.class ? config.class : 'EditLink',\n        href: !!config.href ? config.href : '',\n        text: !!config.text ? config.text : 'Edit',\n        target: !!config.target ? config.target : '_blank'\n      };\n    } catch (e) {\n      console.warn('Anchor config did not include an href value');\n      return false;\n    }\n    self.el.style.position = 'relative';\n    var anchor = document.createElement('a');\n    var anchorText = document.createTextNode(settings.text);\n    anchor.append(anchorText);\n    anchor.setAttribute('href', settings.href);\n    anchor.setAttribute('class', settings.class);\n    anchor.setAttribute('target', settings.target);\n    return anchor;\n  };\n\n  this.render = function() {\n    try {\n      var editableAttribute = this.el.getAttribute('data-editable');\n    } catch (e) {\n      console.warn(\n        'Element does not have a data-editable attribute. Cancelling render'\n      );\n      return false;\n    }\n\n    if (editableAttribute.length) {\n      var editableInfo = editableAttribute.split('-');\n      if (editableInfo[0] === 'people') {\n        var href = '/admin/people/' + editableInfo[1] + '/edit';\n      } else {\n        var href =\n          '/admin/' + editableInfo[0] + 's/' + editableInfo[1] + '/edit';\n      }\n\n      var anchor = self.createAnchor({\n        class: 'ts-button -primary -save-and-review',\n        href: href\n      });\n\n      self.el.prepend(anchor);\n    }\n  };\n\n  initialize(config);\n}\n\nmodule.exports = AdminEditLink;\n","//     Backbone.js 1.3.3\n\n//     (c) 2010-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Backbone may be freely distributed under the MIT license.\n//     For all details and documentation:\n//     http://backbonejs.org\n\n(function(factory) {\n\n  // Establish the root object, `window` (`self`) in the browser, or `global` on the server.\n  // We use `self` instead of `window` for `WebWorker` support.\n  var root = (typeof self == 'object' && self.self === self && self) ||\n            (typeof global == 'object' && global.global === global && global);\n\n  // Set up Backbone appropriately for the environment. Start with AMD.\n  if (typeof define === 'function' && define.amd) {\n    define(['underscore', 'jquery', 'exports'], function(_, $, exports) {\n      // Export global even in AMD case in case this script is loaded with\n      // others that may still expect a global Backbone.\n      root.Backbone = factory(root, exports, _, $);\n    });\n\n  // Next for Node.js or CommonJS. jQuery may not be needed as a module.\n  } else if (typeof exports !== 'undefined') {\n    var _ = require('underscore'), $;\n    try { $ = require('jquery'); } catch (e) {}\n    factory(root, exports, _, $);\n\n  // Finally, as a browser global.\n  } else {\n    root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root.ender || root.$));\n  }\n\n})(function(root, Backbone, _, $) {\n\n  // Initial Setup\n  // -------------\n\n  // Save the previous value of the `Backbone` variable, so that it can be\n  // restored later on, if `noConflict` is used.\n  var previousBackbone = root.Backbone;\n\n  // Create a local reference to a common array method we'll want to use later.\n  var slice = Array.prototype.slice;\n\n  // Current version of the library. Keep in sync with `package.json`.\n  Backbone.VERSION = '1.3.3';\n\n  // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns\n  // the `$` variable.\n  Backbone.$ = $;\n\n  // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable\n  // to its previous owner. Returns a reference to this Backbone object.\n  Backbone.noConflict = function() {\n    root.Backbone = previousBackbone;\n    return this;\n  };\n\n  // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option\n  // will fake `\"PATCH\"`, `\"PUT\"` and `\"DELETE\"` requests via the `_method` parameter and\n  // set a `X-Http-Method-Override` header.\n  Backbone.emulateHTTP = false;\n\n  // Turn on `emulateJSON` to support legacy servers that can't deal with direct\n  // `application/json` requests ... this will encode the body as\n  // `application/x-www-form-urlencoded` instead and will send the model in a\n  // form param named `model`.\n  Backbone.emulateJSON = false;\n\n  // Proxy Backbone class methods to Underscore functions, wrapping the model's\n  // `attributes` object or collection's `models` array behind the scenes.\n  //\n  // collection.filter(function(model) { return model.get('age') > 10 });\n  // collection.each(this.addView);\n  //\n  // `Function#apply` can be slow so we use the method's arg count, if we know it.\n  var addMethod = function(length, method, attribute) {\n    switch (length) {\n      case 1: return function() {\n        return _[method](this[attribute]);\n      };\n      case 2: return function(value) {\n        return _[method](this[attribute], value);\n      };\n      case 3: return function(iteratee, context) {\n        return _[method](this[attribute], cb(iteratee, this), context);\n      };\n      case 4: return function(iteratee, defaultVal, context) {\n        return _[method](this[attribute], cb(iteratee, this), defaultVal, context);\n      };\n      default: return function() {\n        var args = slice.call(arguments);\n        args.unshift(this[attribute]);\n        return _[method].apply(_, args);\n      };\n    }\n  };\n  var addUnderscoreMethods = function(Class, methods, attribute) {\n    _.each(methods, function(length, method) {\n      if (_[method]) Class.prototype[method] = addMethod(length, method, attribute);\n    });\n  };\n\n  // Support `collection.sortBy('attr')` and `collection.findWhere({id: 1})`.\n  var cb = function(iteratee, instance) {\n    if (_.isFunction(iteratee)) return iteratee;\n    if (_.isObject(iteratee) && !instance._isModel(iteratee)) return modelMatcher(iteratee);\n    if (_.isString(iteratee)) return function(model) { return model.get(iteratee); };\n    return iteratee;\n  };\n  var modelMatcher = function(attrs) {\n    var matcher = _.matches(attrs);\n    return function(model) {\n      return matcher(model.attributes);\n    };\n  };\n\n  // Backbone.Events\n  // ---------------\n\n  // A module that can be mixed in to *any object* in order to provide it with\n  // a custom event channel. You may bind a callback to an event with `on` or\n  // remove with `off`; `trigger`-ing an event fires all callbacks in\n  // succession.\n  //\n  //     var object = {};\n  //     _.extend(object, Backbone.Events);\n  //     object.on('expand', function(){ alert('expanded'); });\n  //     object.trigger('expand');\n  //\n  var Events = Backbone.Events = {};\n\n  // Regular expression used to split event strings.\n  var eventSplitter = /\\s+/;\n\n  // Iterates over the standard `event, callback` (as well as the fancy multiple\n  // space-separated events `\"change blur\", callback` and jQuery-style event\n  // maps `{event: callback}`).\n  var eventsApi = function(iteratee, events, name, callback, opts) {\n    var i = 0, names;\n    if (name && typeof name === 'object') {\n      // Handle event maps.\n      if (callback !== void 0 && 'context' in opts && opts.context === void 0) opts.context = callback;\n      for (names = _.keys(name); i < names.length ; i++) {\n        events = eventsApi(iteratee, events, names[i], name[names[i]], opts);\n      }\n    } else if (name && eventSplitter.test(name)) {\n      // Handle space-separated event names by delegating them individually.\n      for (names = name.split(eventSplitter); i < names.length; i++) {\n        events = iteratee(events, names[i], callback, opts);\n      }\n    } else {\n      // Finally, standard events.\n      events = iteratee(events, name, callback, opts);\n    }\n    return events;\n  };\n\n  // Bind an event to a `callback` function. Passing `\"all\"` will bind\n  // the callback to all events fired.\n  Events.on = function(name, callback, context) {\n    return internalOn(this, name, callback, context);\n  };\n\n  // Guard the `listening` argument from the public API.\n  var internalOn = function(obj, name, callback, context, listening) {\n    obj._events = eventsApi(onApi, obj._events || {}, name, callback, {\n      context: context,\n      ctx: obj,\n      listening: listening\n    });\n\n    if (listening) {\n      var listeners = obj._listeners || (obj._listeners = {});\n      listeners[listening.id] = listening;\n    }\n\n    return obj;\n  };\n\n  // Inversion-of-control versions of `on`. Tell *this* object to listen to\n  // an event in another object... keeping track of what it's listening to\n  // for easier unbinding later.\n  Events.listenTo = function(obj, name, callback) {\n    if (!obj) return this;\n    var id = obj._listenId || (obj._listenId = _.uniqueId('l'));\n    var listeningTo = this._listeningTo || (this._listeningTo = {});\n    var listening = listeningTo[id];\n\n    // This object is not listening to any other events on `obj` yet.\n    // Setup the necessary references to track the listening callbacks.\n    if (!listening) {\n      var thisId = this._listenId || (this._listenId = _.uniqueId('l'));\n      listening = listeningTo[id] = {obj: obj, objId: id, id: thisId, listeningTo: listeningTo, count: 0};\n    }\n\n    // Bind callbacks on obj, and keep track of them on listening.\n    internalOn(obj, name, callback, this, listening);\n    return this;\n  };\n\n  // The reducing API that adds a callback to the `events` object.\n  var onApi = function(events, name, callback, options) {\n    if (callback) {\n      var handlers = events[name] || (events[name] = []);\n      var context = options.context, ctx = options.ctx, listening = options.listening;\n      if (listening) listening.count++;\n\n      handlers.push({callback: callback, context: context, ctx: context || ctx, listening: listening});\n    }\n    return events;\n  };\n\n  // Remove one or many callbacks. If `context` is null, removes all\n  // callbacks with that function. If `callback` is null, removes all\n  // callbacks for the event. If `name` is null, removes all bound\n  // callbacks for all events.\n  Events.off = function(name, callback, context) {\n    if (!this._events) return this;\n    this._events = eventsApi(offApi, this._events, name, callback, {\n      context: context,\n      listeners: this._listeners\n    });\n    return this;\n  };\n\n  // Tell this object to stop listening to either specific events ... or\n  // to every object it's currently listening to.\n  Events.stopListening = function(obj, name, callback) {\n    var listeningTo = this._listeningTo;\n    if (!listeningTo) return this;\n\n    var ids = obj ? [obj._listenId] : _.keys(listeningTo);\n\n    for (var i = 0; i < ids.length; i++) {\n      var listening = listeningTo[ids[i]];\n\n      // If listening doesn't exist, this object is not currently\n      // listening to obj. Break out early.\n      if (!listening) break;\n\n      listening.obj.off(name, callback, this);\n    }\n\n    return this;\n  };\n\n  // The reducing API that removes a callback from the `events` object.\n  var offApi = function(events, name, callback, options) {\n    if (!events) return;\n\n    var i = 0, listening;\n    var context = options.context, listeners = options.listeners;\n\n    // Delete all events listeners and \"drop\" events.\n    if (!name && !callback && !context) {\n      var ids = _.keys(listeners);\n      for (; i < ids.length; i++) {\n        listening = listeners[ids[i]];\n        delete listeners[listening.id];\n        delete listening.listeningTo[listening.objId];\n      }\n      return;\n    }\n\n    var names = name ? [name] : _.keys(events);\n    for (; i < names.length; i++) {\n      name = names[i];\n      var handlers = events[name];\n\n      // Bail out if there are no events stored.\n      if (!handlers) break;\n\n      // Replace events if there are any remaining.  Otherwise, clean up.\n      var remaining = [];\n      for (var j = 0; j < handlers.length; j++) {\n        var handler = handlers[j];\n        if (\n          callback && callback !== handler.callback &&\n            callback !== handler.callback._callback ||\n              context && context !== handler.context\n        ) {\n          remaining.push(handler);\n        } else {\n          listening = handler.listening;\n          if (listening && --listening.count === 0) {\n            delete listeners[listening.id];\n            delete listening.listeningTo[listening.objId];\n          }\n        }\n      }\n\n      // Update tail event if the list has any events.  Otherwise, clean up.\n      if (remaining.length) {\n        events[name] = remaining;\n      } else {\n        delete events[name];\n      }\n    }\n    return events;\n  };\n\n  // Bind an event to only be triggered a single time. After the first time\n  // the callback is invoked, its listener will be removed. If multiple events\n  // are passed in using the space-separated syntax, the handler will fire\n  // once for each event, not once for a combination of all events.\n  Events.once = function(name, callback, context) {\n    // Map the event into a `{event: once}` object.\n    var events = eventsApi(onceMap, {}, name, callback, _.bind(this.off, this));\n    if (typeof name === 'string' && context == null) callback = void 0;\n    return this.on(events, callback, context);\n  };\n\n  // Inversion-of-control versions of `once`.\n  Events.listenToOnce = function(obj, name, callback) {\n    // Map the event into a `{event: once}` object.\n    var events = eventsApi(onceMap, {}, name, callback, _.bind(this.stopListening, this, obj));\n    return this.listenTo(obj, events);\n  };\n\n  // Reduces the event callbacks into a map of `{event: onceWrapper}`.\n  // `offer` unbinds the `onceWrapper` after it has been called.\n  var onceMap = function(map, name, callback, offer) {\n    if (callback) {\n      var once = map[name] = _.once(function() {\n        offer(name, once);\n        callback.apply(this, arguments);\n      });\n      once._callback = callback;\n    }\n    return map;\n  };\n\n  // Trigger one or many events, firing all bound callbacks. Callbacks are\n  // passed the same arguments as `trigger` is, apart from the event name\n  // (unless you're listening on `\"all\"`, which will cause your callback to\n  // receive the true name of the event as the first argument).\n  Events.trigger = function(name) {\n    if (!this._events) return this;\n\n    var length = Math.max(0, arguments.length - 1);\n    var args = Array(length);\n    for (var i = 0; i < length; i++) args[i] = arguments[i + 1];\n\n    eventsApi(triggerApi, this._events, name, void 0, args);\n    return this;\n  };\n\n  // Handles triggering the appropriate event callbacks.\n  var triggerApi = function(objEvents, name, callback, args) {\n    if (objEvents) {\n      var events = objEvents[name];\n      var allEvents = objEvents.all;\n      if (events && allEvents) allEvents = allEvents.slice();\n      if (events) triggerEvents(events, args);\n      if (allEvents) triggerEvents(allEvents, [name].concat(args));\n    }\n    return objEvents;\n  };\n\n  // A difficult-to-believe, but optimized internal dispatch function for\n  // triggering events. Tries to keep the usual cases speedy (most internal\n  // Backbone events have 3 arguments).\n  var triggerEvents = function(events, args) {\n    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];\n    switch (args.length) {\n      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;\n      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;\n      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;\n      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;\n      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;\n    }\n  };\n\n  // Aliases for backwards compatibility.\n  Events.bind   = Events.on;\n  Events.unbind = Events.off;\n\n  // Allow the `Backbone` object to serve as a global event bus, for folks who\n  // want global \"pubsub\" in a convenient place.\n  _.extend(Backbone, Events);\n\n  // Backbone.Model\n  // --------------\n\n  // Backbone **Models** are the basic data object in the framework --\n  // frequently representing a row in a table in a database on your server.\n  // A discrete chunk of data and a bunch of useful, related methods for\n  // performing computations and transformations on that data.\n\n  // Create a new model with the specified attributes. A client id (`cid`)\n  // is automatically generated and assigned for you.\n  var Model = Backbone.Model = function(attributes, options) {\n    var attrs = attributes || {};\n    options || (options = {});\n    this.cid = _.uniqueId(this.cidPrefix);\n    this.attributes = {};\n    if (options.collection) this.collection = options.collection;\n    if (options.parse) attrs = this.parse(attrs, options) || {};\n    var defaults = _.result(this, 'defaults');\n    attrs = _.defaults(_.extend({}, defaults, attrs), defaults);\n    this.set(attrs, options);\n    this.changed = {};\n    this.initialize.apply(this, arguments);\n  };\n\n  // Attach all inheritable methods to the Model prototype.\n  _.extend(Model.prototype, Events, {\n\n    // A hash of attributes whose current and previous value differ.\n    changed: null,\n\n    // The value returned during the last failed validation.\n    validationError: null,\n\n    // The default name for the JSON `id` attribute is `\"id\"`. MongoDB and\n    // CouchDB users may want to set this to `\"_id\"`.\n    idAttribute: 'id',\n\n    // The prefix is used to create the client id which is used to identify models locally.\n    // You may want to override this if you're experiencing name clashes with model ids.\n    cidPrefix: 'c',\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // Return a copy of the model's `attributes` object.\n    toJSON: function(options) {\n      return _.clone(this.attributes);\n    },\n\n    // Proxy `Backbone.sync` by default -- but override this if you need\n    // custom syncing semantics for *this* particular model.\n    sync: function() {\n      return Backbone.sync.apply(this, arguments);\n    },\n\n    // Get the value of an attribute.\n    get: function(attr) {\n      return this.attributes[attr];\n    },\n\n    // Get the HTML-escaped value of an attribute.\n    escape: function(attr) {\n      return _.escape(this.get(attr));\n    },\n\n    // Returns `true` if the attribute contains a value that is not null\n    // or undefined.\n    has: function(attr) {\n      return this.get(attr) != null;\n    },\n\n    // Special-cased proxy to underscore's `_.matches` method.\n    matches: function(attrs) {\n      return !!_.iteratee(attrs, this)(this.attributes);\n    },\n\n    // Set a hash of model attributes on the object, firing `\"change\"`. This is\n    // the core primitive operation of a model, updating the data and notifying\n    // anyone who needs to know about the change in state. The heart of the beast.\n    set: function(key, val, options) {\n      if (key == null) return this;\n\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\n      var attrs;\n      if (typeof key === 'object') {\n        attrs = key;\n        options = val;\n      } else {\n        (attrs = {})[key] = val;\n      }\n\n      options || (options = {});\n\n      // Run validation.\n      if (!this._validate(attrs, options)) return false;\n\n      // Extract attributes and options.\n      var unset      = options.unset;\n      var silent     = options.silent;\n      var changes    = [];\n      var changing   = this._changing;\n      this._changing = true;\n\n      if (!changing) {\n        this._previousAttributes = _.clone(this.attributes);\n        this.changed = {};\n      }\n\n      var current = this.attributes;\n      var changed = this.changed;\n      var prev    = this._previousAttributes;\n\n      // For each `set` attribute, update or delete the current value.\n      for (var attr in attrs) {\n        val = attrs[attr];\n        if (!_.isEqual(current[attr], val)) changes.push(attr);\n        if (!_.isEqual(prev[attr], val)) {\n          changed[attr] = val;\n        } else {\n          delete changed[attr];\n        }\n        unset ? delete current[attr] : current[attr] = val;\n      }\n\n      // Update the `id`.\n      if (this.idAttribute in attrs) this.id = this.get(this.idAttribute);\n\n      // Trigger all relevant attribute changes.\n      if (!silent) {\n        if (changes.length) this._pending = options;\n        for (var i = 0; i < changes.length; i++) {\n          this.trigger('change:' + changes[i], this, current[changes[i]], options);\n        }\n      }\n\n      // You might be wondering why there's a `while` loop here. Changes can\n      // be recursively nested within `\"change\"` events.\n      if (changing) return this;\n      if (!silent) {\n        while (this._pending) {\n          options = this._pending;\n          this._pending = false;\n          this.trigger('change', this, options);\n        }\n      }\n      this._pending = false;\n      this._changing = false;\n      return this;\n    },\n\n    // Remove an attribute from the model, firing `\"change\"`. `unset` is a noop\n    // if the attribute doesn't exist.\n    unset: function(attr, options) {\n      return this.set(attr, void 0, _.extend({}, options, {unset: true}));\n    },\n\n    // Clear all attributes on the model, firing `\"change\"`.\n    clear: function(options) {\n      var attrs = {};\n      for (var key in this.attributes) attrs[key] = void 0;\n      return this.set(attrs, _.extend({}, options, {unset: true}));\n    },\n\n    // Determine if the model has changed since the last `\"change\"` event.\n    // If you specify an attribute name, determine if that attribute has changed.\n    hasChanged: function(attr) {\n      if (attr == null) return !_.isEmpty(this.changed);\n      return _.has(this.changed, attr);\n    },\n\n    // Return an object containing all the attributes that have changed, or\n    // false if there are no changed attributes. Useful for determining what\n    // parts of a view need to be updated and/or what attributes need to be\n    // persisted to the server. Unset attributes will be set to undefined.\n    // You can also pass an attributes object to diff against the model,\n    // determining if there *would be* a change.\n    changedAttributes: function(diff) {\n      if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;\n      var old = this._changing ? this._previousAttributes : this.attributes;\n      var changed = {};\n      for (var attr in diff) {\n        var val = diff[attr];\n        if (_.isEqual(old[attr], val)) continue;\n        changed[attr] = val;\n      }\n      return _.size(changed) ? changed : false;\n    },\n\n    // Get the previous value of an attribute, recorded at the time the last\n    // `\"change\"` event was fired.\n    previous: function(attr) {\n      if (attr == null || !this._previousAttributes) return null;\n      return this._previousAttributes[attr];\n    },\n\n    // Get all of the attributes of the model at the time of the previous\n    // `\"change\"` event.\n    previousAttributes: function() {\n      return _.clone(this._previousAttributes);\n    },\n\n    // Fetch the model from the server, merging the response with the model's\n    // local attributes. Any changed attributes will trigger a \"change\" event.\n    fetch: function(options) {\n      options = _.extend({parse: true}, options);\n      var model = this;\n      var success = options.success;\n      options.success = function(resp) {\n        var serverAttrs = options.parse ? model.parse(resp, options) : resp;\n        if (!model.set(serverAttrs, options)) return false;\n        if (success) success.call(options.context, model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n      return this.sync('read', this, options);\n    },\n\n    // Set a hash of model attributes, and sync the model to the server.\n    // If the server returns an attributes hash that differs, the model's\n    // state will be `set` again.\n    save: function(key, val, options) {\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\n      var attrs;\n      if (key == null || typeof key === 'object') {\n        attrs = key;\n        options = val;\n      } else {\n        (attrs = {})[key] = val;\n      }\n\n      options = _.extend({validate: true, parse: true}, options);\n      var wait = options.wait;\n\n      // If we're not waiting and attributes exist, save acts as\n      // `set(attr).save(null, opts)` with validation. Otherwise, check if\n      // the model will be valid when the attributes, if any, are set.\n      if (attrs && !wait) {\n        if (!this.set(attrs, options)) return false;\n      } else if (!this._validate(attrs, options)) {\n        return false;\n      }\n\n      // After a successful server-side save, the client is (optionally)\n      // updated with the server-side state.\n      var model = this;\n      var success = options.success;\n      var attributes = this.attributes;\n      options.success = function(resp) {\n        // Ensure attributes are restored during synchronous saves.\n        model.attributes = attributes;\n        var serverAttrs = options.parse ? model.parse(resp, options) : resp;\n        if (wait) serverAttrs = _.extend({}, attrs, serverAttrs);\n        if (serverAttrs && !model.set(serverAttrs, options)) return false;\n        if (success) success.call(options.context, model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n\n      // Set temporary attributes if `{wait: true}` to properly find new ids.\n      if (attrs && wait) this.attributes = _.extend({}, attributes, attrs);\n\n      var method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');\n      if (method === 'patch' && !options.attrs) options.attrs = attrs;\n      var xhr = this.sync(method, this, options);\n\n      // Restore attributes.\n      this.attributes = attributes;\n\n      return xhr;\n    },\n\n    // Destroy this model on the server if it was already persisted.\n    // Optimistically removes the model from its collection, if it has one.\n    // If `wait: true` is passed, waits for the server to respond before removal.\n    destroy: function(options) {\n      options = options ? _.clone(options) : {};\n      var model = this;\n      var success = options.success;\n      var wait = options.wait;\n\n      var destroy = function() {\n        model.stopListening();\n        model.trigger('destroy', model, model.collection, options);\n      };\n\n      options.success = function(resp) {\n        if (wait) destroy();\n        if (success) success.call(options.context, model, resp, options);\n        if (!model.isNew()) model.trigger('sync', model, resp, options);\n      };\n\n      var xhr = false;\n      if (this.isNew()) {\n        _.defer(options.success);\n      } else {\n        wrapError(this, options);\n        xhr = this.sync('delete', this, options);\n      }\n      if (!wait) destroy();\n      return xhr;\n    },\n\n    // Default URL for the model's representation on the server -- if you're\n    // using Backbone's restful methods, override this to change the endpoint\n    // that will be called.\n    url: function() {\n      var base =\n        _.result(this, 'urlRoot') ||\n        _.result(this.collection, 'url') ||\n        urlError();\n      if (this.isNew()) return base;\n      var id = this.get(this.idAttribute);\n      return base.replace(/[^\\/]$/, '$&/') + encodeURIComponent(id);\n    },\n\n    // **parse** converts a response into the hash of attributes to be `set` on\n    // the model. The default implementation is just to pass the response along.\n    parse: function(resp, options) {\n      return resp;\n    },\n\n    // Create a new model with identical attributes to this one.\n    clone: function() {\n      return new this.constructor(this.attributes);\n    },\n\n    // A model is new if it has never been saved to the server, and lacks an id.\n    isNew: function() {\n      return !this.has(this.idAttribute);\n    },\n\n    // Check if the model is currently in a valid state.\n    isValid: function(options) {\n      return this._validate({}, _.extend({}, options, {validate: true}));\n    },\n\n    // Run validation against the next complete set of model attributes,\n    // returning `true` if all is well. Otherwise, fire an `\"invalid\"` event.\n    _validate: function(attrs, options) {\n      if (!options.validate || !this.validate) return true;\n      attrs = _.extend({}, this.attributes, attrs);\n      var error = this.validationError = this.validate(attrs, options) || null;\n      if (!error) return true;\n      this.trigger('invalid', this, error, _.extend(options, {validationError: error}));\n      return false;\n    }\n\n  });\n\n  // Underscore methods that we want to implement on the Model, mapped to the\n  // number of arguments they take.\n  var modelMethods = {keys: 1, values: 1, pairs: 1, invert: 1, pick: 0,\n      omit: 0, chain: 1, isEmpty: 1};\n\n  // Mix in each Underscore method as a proxy to `Model#attributes`.\n  addUnderscoreMethods(Model, modelMethods, 'attributes');\n\n  // Backbone.Collection\n  // -------------------\n\n  // If models tend to represent a single row of data, a Backbone Collection is\n  // more analogous to a table full of data ... or a small slice or page of that\n  // table, or a collection of rows that belong together for a particular reason\n  // -- all of the messages in this particular folder, all of the documents\n  // belonging to this particular author, and so on. Collections maintain\n  // indexes of their models, both in order, and for lookup by `id`.\n\n  // Create a new **Collection**, perhaps to contain a specific type of `model`.\n  // If a `comparator` is specified, the Collection will maintain\n  // its models in sort order, as they're added and removed.\n  var Collection = Backbone.Collection = function(models, options) {\n    options || (options = {});\n    if (options.model) this.model = options.model;\n    if (options.comparator !== void 0) this.comparator = options.comparator;\n    this._reset();\n    this.initialize.apply(this, arguments);\n    if (models) this.reset(models, _.extend({silent: true}, options));\n  };\n\n  // Default options for `Collection#set`.\n  var setOptions = {add: true, remove: true, merge: true};\n  var addOptions = {add: true, remove: false};\n\n  // Splices `insert` into `array` at index `at`.\n  var splice = function(array, insert, at) {\n    at = Math.min(Math.max(at, 0), array.length);\n    var tail = Array(array.length - at);\n    var length = insert.length;\n    var i;\n    for (i = 0; i < tail.length; i++) tail[i] = array[i + at];\n    for (i = 0; i < length; i++) array[i + at] = insert[i];\n    for (i = 0; i < tail.length; i++) array[i + length + at] = tail[i];\n  };\n\n  // Define the Collection's inheritable methods.\n  _.extend(Collection.prototype, Events, {\n\n    // The default model for a collection is just a **Backbone.Model**.\n    // This should be overridden in most cases.\n    model: Model,\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // The JSON representation of a Collection is an array of the\n    // models' attributes.\n    toJSON: function(options) {\n      return this.map(function(model) { return model.toJSON(options); });\n    },\n\n    // Proxy `Backbone.sync` by default.\n    sync: function() {\n      return Backbone.sync.apply(this, arguments);\n    },\n\n    // Add a model, or list of models to the set. `models` may be Backbone\n    // Models or raw JavaScript objects to be converted to Models, or any\n    // combination of the two.\n    add: function(models, options) {\n      return this.set(models, _.extend({merge: false}, options, addOptions));\n    },\n\n    // Remove a model, or a list of models from the set.\n    remove: function(models, options) {\n      options = _.extend({}, options);\n      var singular = !_.isArray(models);\n      models = singular ? [models] : models.slice();\n      var removed = this._removeModels(models, options);\n      if (!options.silent && removed.length) {\n        options.changes = {added: [], merged: [], removed: removed};\n        this.trigger('update', this, options);\n      }\n      return singular ? removed[0] : removed;\n    },\n\n    // Update a collection by `set`-ing a new list of models, adding new ones,\n    // removing models that are no longer present, and merging models that\n    // already exist in the collection, as necessary. Similar to **Model#set**,\n    // the core operation for updating the data contained by the collection.\n    set: function(models, options) {\n      if (models == null) return;\n\n      options = _.extend({}, setOptions, options);\n      if (options.parse && !this._isModel(models)) {\n        models = this.parse(models, options) || [];\n      }\n\n      var singular = !_.isArray(models);\n      models = singular ? [models] : models.slice();\n\n      var at = options.at;\n      if (at != null) at = +at;\n      if (at > this.length) at = this.length;\n      if (at < 0) at += this.length + 1;\n\n      var set = [];\n      var toAdd = [];\n      var toMerge = [];\n      var toRemove = [];\n      var modelMap = {};\n\n      var add = options.add;\n      var merge = options.merge;\n      var remove = options.remove;\n\n      var sort = false;\n      var sortable = this.comparator && at == null && options.sort !== false;\n      var sortAttr = _.isString(this.comparator) ? this.comparator : null;\n\n      // Turn bare objects into model references, and prevent invalid models\n      // from being added.\n      var model, i;\n      for (i = 0; i < models.length; i++) {\n        model = models[i];\n\n        // If a duplicate is found, prevent it from being added and\n        // optionally merge it into the existing model.\n        var existing = this.get(model);\n        if (existing) {\n          if (merge && model !== existing) {\n            var attrs = this._isModel(model) ? model.attributes : model;\n            if (options.parse) attrs = existing.parse(attrs, options);\n            existing.set(attrs, options);\n            toMerge.push(existing);\n            if (sortable && !sort) sort = existing.hasChanged(sortAttr);\n          }\n          if (!modelMap[existing.cid]) {\n            modelMap[existing.cid] = true;\n            set.push(existing);\n          }\n          models[i] = existing;\n\n        // If this is a new, valid model, push it to the `toAdd` list.\n        } else if (add) {\n          model = models[i] = this._prepareModel(model, options);\n          if (model) {\n            toAdd.push(model);\n            this._addReference(model, options);\n            modelMap[model.cid] = true;\n            set.push(model);\n          }\n        }\n      }\n\n      // Remove stale models.\n      if (remove) {\n        for (i = 0; i < this.length; i++) {\n          model = this.models[i];\n          if (!modelMap[model.cid]) toRemove.push(model);\n        }\n        if (toRemove.length) this._removeModels(toRemove, options);\n      }\n\n      // See if sorting is needed, update `length` and splice in new models.\n      var orderChanged = false;\n      var replace = !sortable && add && remove;\n      if (set.length && replace) {\n        orderChanged = this.length !== set.length || _.some(this.models, function(m, index) {\n          return m !== set[index];\n        });\n        this.models.length = 0;\n        splice(this.models, set, 0);\n        this.length = this.models.length;\n      } else if (toAdd.length) {\n        if (sortable) sort = true;\n        splice(this.models, toAdd, at == null ? this.length : at);\n        this.length = this.models.length;\n      }\n\n      // Silently sort the collection if appropriate.\n      if (sort) this.sort({silent: true});\n\n      // Unless silenced, it's time to fire all appropriate add/sort/update events.\n      if (!options.silent) {\n        for (i = 0; i < toAdd.length; i++) {\n          if (at != null) options.index = at + i;\n          model = toAdd[i];\n          model.trigger('add', model, this, options);\n        }\n        if (sort || orderChanged) this.trigger('sort', this, options);\n        if (toAdd.length || toRemove.length || toMerge.length) {\n          options.changes = {\n            added: toAdd,\n            removed: toRemove,\n            merged: toMerge\n          };\n          this.trigger('update', this, options);\n        }\n      }\n\n      // Return the added (or merged) model (or models).\n      return singular ? models[0] : models;\n    },\n\n    // When you have more items than you want to add or remove individually,\n    // you can reset the entire set with a new list of models, without firing\n    // any granular `add` or `remove` events. Fires `reset` when finished.\n    // Useful for bulk operations and optimizations.\n    reset: function(models, options) {\n      options = options ? _.clone(options) : {};\n      for (var i = 0; i < this.models.length; i++) {\n        this._removeReference(this.models[i], options);\n      }\n      options.previousModels = this.models;\n      this._reset();\n      models = this.add(models, _.extend({silent: true}, options));\n      if (!options.silent) this.trigger('reset', this, options);\n      return models;\n    },\n\n    // Add a model to the end of the collection.\n    push: function(model, options) {\n      return this.add(model, _.extend({at: this.length}, options));\n    },\n\n    // Remove a model from the end of the collection.\n    pop: function(options) {\n      var model = this.at(this.length - 1);\n      return this.remove(model, options);\n    },\n\n    // Add a model to the beginning of the collection.\n    unshift: function(model, options) {\n      return this.add(model, _.extend({at: 0}, options));\n    },\n\n    // Remove a model from the beginning of the collection.\n    shift: function(options) {\n      var model = this.at(0);\n      return this.remove(model, options);\n    },\n\n    // Slice out a sub-array of models from the collection.\n    slice: function() {\n      return slice.apply(this.models, arguments);\n    },\n\n    // Get a model from the set by id, cid, model object with id or cid\n    // properties, or an attributes object that is transformed through modelId.\n    get: function(obj) {\n      if (obj == null) return void 0;\n      return this._byId[obj] ||\n        this._byId[this.modelId(obj.attributes || obj)] ||\n        obj.cid && this._byId[obj.cid];\n    },\n\n    // Returns `true` if the model is in the collection.\n    has: function(obj) {\n      return this.get(obj) != null;\n    },\n\n    // Get the model at the given index.\n    at: function(index) {\n      if (index < 0) index += this.length;\n      return this.models[index];\n    },\n\n    // Return models with matching attributes. Useful for simple cases of\n    // `filter`.\n    where: function(attrs, first) {\n      return this[first ? 'find' : 'filter'](attrs);\n    },\n\n    // Return the first model with matching attributes. Useful for simple cases\n    // of `find`.\n    findWhere: function(attrs) {\n      return this.where(attrs, true);\n    },\n\n    // Force the collection to re-sort itself. You don't need to call this under\n    // normal circumstances, as the set will maintain sort order as each item\n    // is added.\n    sort: function(options) {\n      var comparator = this.comparator;\n      if (!comparator) throw new Error('Cannot sort a set without a comparator');\n      options || (options = {});\n\n      var length = comparator.length;\n      if (_.isFunction(comparator)) comparator = _.bind(comparator, this);\n\n      // Run sort based on type of `comparator`.\n      if (length === 1 || _.isString(comparator)) {\n        this.models = this.sortBy(comparator);\n      } else {\n        this.models.sort(comparator);\n      }\n      if (!options.silent) this.trigger('sort', this, options);\n      return this;\n    },\n\n    // Pluck an attribute from each model in the collection.\n    pluck: function(attr) {\n      return this.map(attr + '');\n    },\n\n    // Fetch the default set of models for this collection, resetting the\n    // collection when they arrive. If `reset: true` is passed, the response\n    // data will be passed through the `reset` method instead of `set`.\n    fetch: function(options) {\n      options = _.extend({parse: true}, options);\n      var success = options.success;\n      var collection = this;\n      options.success = function(resp) {\n        var method = options.reset ? 'reset' : 'set';\n        collection[method](resp, options);\n        if (success) success.call(options.context, collection, resp, options);\n        collection.trigger('sync', collection, resp, options);\n      };\n      wrapError(this, options);\n      return this.sync('read', this, options);\n    },\n\n    // Create a new instance of a model in this collection. Add the model to the\n    // collection immediately, unless `wait: true` is passed, in which case we\n    // wait for the server to agree.\n    create: function(model, options) {\n      options = options ? _.clone(options) : {};\n      var wait = options.wait;\n      model = this._prepareModel(model, options);\n      if (!model) return false;\n      if (!wait) this.add(model, options);\n      var collection = this;\n      var success = options.success;\n      options.success = function(m, resp, callbackOpts) {\n        if (wait) collection.add(m, callbackOpts);\n        if (success) success.call(callbackOpts.context, m, resp, callbackOpts);\n      };\n      model.save(null, options);\n      return model;\n    },\n\n    // **parse** converts a response into a list of models to be added to the\n    // collection. The default implementation is just to pass it through.\n    parse: function(resp, options) {\n      return resp;\n    },\n\n    // Create a new collection with an identical list of models as this one.\n    clone: function() {\n      return new this.constructor(this.models, {\n        model: this.model,\n        comparator: this.comparator\n      });\n    },\n\n    // Define how to uniquely identify models in the collection.\n    modelId: function(attrs) {\n      return attrs[this.model.prototype.idAttribute || 'id'];\n    },\n\n    // Private method to reset all internal state. Called when the collection\n    // is first initialized or reset.\n    _reset: function() {\n      this.length = 0;\n      this.models = [];\n      this._byId  = {};\n    },\n\n    // Prepare a hash of attributes (or other model) to be added to this\n    // collection.\n    _prepareModel: function(attrs, options) {\n      if (this._isModel(attrs)) {\n        if (!attrs.collection) attrs.collection = this;\n        return attrs;\n      }\n      options = options ? _.clone(options) : {};\n      options.collection = this;\n      var model = new this.model(attrs, options);\n      if (!model.validationError) return model;\n      this.trigger('invalid', this, model.validationError, options);\n      return false;\n    },\n\n    // Internal method called by both remove and set.\n    _removeModels: function(models, options) {\n      var removed = [];\n      for (var i = 0; i < models.length; i++) {\n        var model = this.get(models[i]);\n        if (!model) continue;\n\n        var index = this.indexOf(model);\n        this.models.splice(index, 1);\n        this.length--;\n\n        // Remove references before triggering 'remove' event to prevent an\n        // infinite loop. #3693\n        delete this._byId[model.cid];\n        var id = this.modelId(model.attributes);\n        if (id != null) delete this._byId[id];\n\n        if (!options.silent) {\n          options.index = index;\n          model.trigger('remove', model, this, options);\n        }\n\n        removed.push(model);\n        this._removeReference(model, options);\n      }\n      return removed;\n    },\n\n    // Method for checking whether an object should be considered a model for\n    // the purposes of adding to the collection.\n    _isModel: function(model) {\n      return model instanceof Model;\n    },\n\n    // Internal method to create a model's ties to a collection.\n    _addReference: function(model, options) {\n      this._byId[model.cid] = model;\n      var id = this.modelId(model.attributes);\n      if (id != null) this._byId[id] = model;\n      model.on('all', this._onModelEvent, this);\n    },\n\n    // Internal method to sever a model's ties to a collection.\n    _removeReference: function(model, options) {\n      delete this._byId[model.cid];\n      var id = this.modelId(model.attributes);\n      if (id != null) delete this._byId[id];\n      if (this === model.collection) delete model.collection;\n      model.off('all', this._onModelEvent, this);\n    },\n\n    // Internal method called every time a model in the set fires an event.\n    // Sets need to update their indexes when models change ids. All other\n    // events simply proxy through. \"add\" and \"remove\" events that originate\n    // in other collections are ignored.\n    _onModelEvent: function(event, model, collection, options) {\n      if (model) {\n        if ((event === 'add' || event === 'remove') && collection !== this) return;\n        if (event === 'destroy') this.remove(model, options);\n        if (event === 'change') {\n          var prevId = this.modelId(model.previousAttributes());\n          var id = this.modelId(model.attributes);\n          if (prevId !== id) {\n            if (prevId != null) delete this._byId[prevId];\n            if (id != null) this._byId[id] = model;\n          }\n        }\n      }\n      this.trigger.apply(this, arguments);\n    }\n\n  });\n\n  // Underscore methods that we want to implement on the Collection.\n  // 90% of the core usefulness of Backbone Collections is actually implemented\n  // right here:\n  var collectionMethods = {forEach: 3, each: 3, map: 3, collect: 3, reduce: 0,\n      foldl: 0, inject: 0, reduceRight: 0, foldr: 0, find: 3, detect: 3, filter: 3,\n      select: 3, reject: 3, every: 3, all: 3, some: 3, any: 3, include: 3, includes: 3,\n      contains: 3, invoke: 0, max: 3, min: 3, toArray: 1, size: 1, first: 3,\n      head: 3, take: 3, initial: 3, rest: 3, tail: 3, drop: 3, last: 3,\n      without: 0, difference: 0, indexOf: 3, shuffle: 1, lastIndexOf: 3,\n      isEmpty: 1, chain: 1, sample: 3, partition: 3, groupBy: 3, countBy: 3,\n      sortBy: 3, indexBy: 3, findIndex: 3, findLastIndex: 3};\n\n  // Mix in each Underscore method as a proxy to `Collection#models`.\n  addUnderscoreMethods(Collection, collectionMethods, 'models');\n\n  // Backbone.View\n  // -------------\n\n  // Backbone Views are almost more convention than they are actual code. A View\n  // is simply a JavaScript object that represents a logical chunk of UI in the\n  // DOM. This might be a single item, an entire list, a sidebar or panel, or\n  // even the surrounding frame which wraps your whole app. Defining a chunk of\n  // UI as a **View** allows you to define your DOM events declaratively, without\n  // having to worry about render order ... and makes it easy for the view to\n  // react to specific changes in the state of your models.\n\n  // Creating a Backbone.View creates its initial element outside of the DOM,\n  // if an existing element is not provided...\n  var View = Backbone.View = function(options) {\n    this.cid = _.uniqueId('view');\n    _.extend(this, _.pick(options, viewOptions));\n    this._ensureElement();\n    this.initialize.apply(this, arguments);\n  };\n\n  // Cached regex to split keys for `delegate`.\n  var delegateEventSplitter = /^(\\S+)\\s*(.*)$/;\n\n  // List of view options to be set as properties.\n  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];\n\n  // Set up all inheritable **Backbone.View** properties and methods.\n  _.extend(View.prototype, Events, {\n\n    // The default `tagName` of a View's element is `\"div\"`.\n    tagName: 'div',\n\n    // jQuery delegate for element lookup, scoped to DOM elements within the\n    // current view. This should be preferred to global lookups where possible.\n    $: function(selector) {\n      return this.$el.find(selector);\n    },\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // **render** is the core function that your view should override, in order\n    // to populate its element (`this.el`), with the appropriate HTML. The\n    // convention is for **render** to always return `this`.\n    render: function() {\n      return this;\n    },\n\n    // Remove this view by taking the element out of the DOM, and removing any\n    // applicable Backbone.Events listeners.\n    remove: function() {\n      this._removeElement();\n      this.stopListening();\n      return this;\n    },\n\n    // Remove this view's element from the document and all event listeners\n    // attached to it. Exposed for subclasses using an alternative DOM\n    // manipulation API.\n    _removeElement: function() {\n      this.$el.remove();\n    },\n\n    // Change the view's element (`this.el` property) and re-delegate the\n    // view's events on the new element.\n    setElement: function(element) {\n      this.undelegateEvents();\n      this._setElement(element);\n      this.delegateEvents();\n      return this;\n    },\n\n    // Creates the `this.el` and `this.$el` references for this view using the\n    // given `el`. `el` can be a CSS selector or an HTML string, a jQuery\n    // context or an element. Subclasses can override this to utilize an\n    // alternative DOM manipulation API and are only required to set the\n    // `this.el` property.\n    _setElement: function(el) {\n      this.$el = el instanceof Backbone.$ ? el : Backbone.$(el);\n      this.el = this.$el[0];\n    },\n\n    // Set callbacks, where `this.events` is a hash of\n    //\n    // *{\"event selector\": \"callback\"}*\n    //\n    //     {\n    //       'mousedown .title':  'edit',\n    //       'click .button':     'save',\n    //       'click .open':       function(e) { ... }\n    //     }\n    //\n    // pairs. Callbacks will be bound to the view, with `this` set properly.\n    // Uses event delegation for efficiency.\n    // Omitting the selector binds the event to `this.el`.\n    delegateEvents: function(events) {\n      events || (events = _.result(this, 'events'));\n      if (!events) return this;\n      this.undelegateEvents();\n      for (var key in events) {\n        var method = events[key];\n        if (!_.isFunction(method)) method = this[method];\n        if (!method) continue;\n        var match = key.match(delegateEventSplitter);\n        this.delegate(match[1], match[2], _.bind(method, this));\n      }\n      return this;\n    },\n\n    // Add a single event listener to the view's element (or a child element\n    // using `selector`). This only works for delegate-able events: not `focus`,\n    // `blur`, and not `change`, `submit`, and `reset` in Internet Explorer.\n    delegate: function(eventName, selector, listener) {\n      this.$el.on(eventName + '.delegateEvents' + this.cid, selector, listener);\n      return this;\n    },\n\n    // Clears all callbacks previously bound to the view by `delegateEvents`.\n    // You usually don't need to use this, but may wish to if you have multiple\n    // Backbone views attached to the same DOM element.\n    undelegateEvents: function() {\n      if (this.$el) this.$el.off('.delegateEvents' + this.cid);\n      return this;\n    },\n\n    // A finer-grained `undelegateEvents` for removing a single delegated event.\n    // `selector` and `listener` are both optional.\n    undelegate: function(eventName, selector, listener) {\n      this.$el.off(eventName + '.delegateEvents' + this.cid, selector, listener);\n      return this;\n    },\n\n    // Produces a DOM element to be assigned to your view. Exposed for\n    // subclasses using an alternative DOM manipulation API.\n    _createElement: function(tagName) {\n      return document.createElement(tagName);\n    },\n\n    // Ensure that the View has a DOM element to render into.\n    // If `this.el` is a string, pass it through `$()`, take the first\n    // matching element, and re-assign it to `el`. Otherwise, create\n    // an element from the `id`, `className` and `tagName` properties.\n    _ensureElement: function() {\n      if (!this.el) {\n        var attrs = _.extend({}, _.result(this, 'attributes'));\n        if (this.id) attrs.id = _.result(this, 'id');\n        if (this.className) attrs['class'] = _.result(this, 'className');\n        this.setElement(this._createElement(_.result(this, 'tagName')));\n        this._setAttributes(attrs);\n      } else {\n        this.setElement(_.result(this, 'el'));\n      }\n    },\n\n    // Set attributes from a hash on this view's element.  Exposed for\n    // subclasses using an alternative DOM manipulation API.\n    _setAttributes: function(attributes) {\n      this.$el.attr(attributes);\n    }\n\n  });\n\n  // Backbone.sync\n  // -------------\n\n  // Override this function to change the manner in which Backbone persists\n  // models to the server. You will be passed the type of request, and the\n  // model in question. By default, makes a RESTful Ajax request\n  // to the model's `url()`. Some possible customizations could be:\n  //\n  // * Use `setTimeout` to batch rapid-fire updates into a single request.\n  // * Send up the models as XML instead of JSON.\n  // * Persist models via WebSockets instead of Ajax.\n  //\n  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests\n  // as `POST`, with a `_method` parameter containing the true HTTP method,\n  // as well as all requests with the body as `application/x-www-form-urlencoded`\n  // instead of `application/json` with the model in a param named `model`.\n  // Useful when interfacing with server-side languages like **PHP** that make\n  // it difficult to read the body of `PUT` requests.\n  Backbone.sync = function(method, model, options) {\n    var type = methodMap[method];\n\n    // Default options, unless specified.\n    _.defaults(options || (options = {}), {\n      emulateHTTP: Backbone.emulateHTTP,\n      emulateJSON: Backbone.emulateJSON\n    });\n\n    // Default JSON-request options.\n    var params = {type: type, dataType: 'json'};\n\n    // Ensure that we have a URL.\n    if (!options.url) {\n      params.url = _.result(model, 'url') || urlError();\n    }\n\n    // Ensure that we have the appropriate request data.\n    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {\n      params.contentType = 'application/json';\n      params.data = JSON.stringify(options.attrs || model.toJSON(options));\n    }\n\n    // For older servers, emulate JSON by encoding the request into an HTML-form.\n    if (options.emulateJSON) {\n      params.contentType = 'application/x-www-form-urlencoded';\n      params.data = params.data ? {model: params.data} : {};\n    }\n\n    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`\n    // And an `X-HTTP-Method-Override` header.\n    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {\n      params.type = 'POST';\n      if (options.emulateJSON) params.data._method = type;\n      var beforeSend = options.beforeSend;\n      options.beforeSend = function(xhr) {\n        xhr.setRequestHeader('X-HTTP-Method-Override', type);\n        if (beforeSend) return beforeSend.apply(this, arguments);\n      };\n    }\n\n    // Don't process data on a non-GET request.\n    if (params.type !== 'GET' && !options.emulateJSON) {\n      params.processData = false;\n    }\n\n    // Pass along `textStatus` and `errorThrown` from jQuery.\n    var error = options.error;\n    options.error = function(xhr, textStatus, errorThrown) {\n      options.textStatus = textStatus;\n      options.errorThrown = errorThrown;\n      if (error) error.call(options.context, xhr, textStatus, errorThrown);\n    };\n\n    // Make the request, allowing the user to override any Ajax options.\n    var xhr = options.xhr = Backbone.ajax(_.extend(params, options));\n    model.trigger('request', model, xhr, options);\n    return xhr;\n  };\n\n  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.\n  var methodMap = {\n    'create': 'POST',\n    'update': 'PUT',\n    'patch': 'PATCH',\n    'delete': 'DELETE',\n    'read': 'GET'\n  };\n\n  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.\n  // Override this if you'd like to use a different library.\n  Backbone.ajax = function() {\n    return Backbone.$.ajax.apply(Backbone.$, arguments);\n  };\n\n  // Backbone.Router\n  // ---------------\n\n  // Routers map faux-URLs to actions, and fire events when routes are\n  // matched. Creating a new one sets its `routes` hash, if not set statically.\n  var Router = Backbone.Router = function(options) {\n    options || (options = {});\n    if (options.routes) this.routes = options.routes;\n    this._bindRoutes();\n    this.initialize.apply(this, arguments);\n  };\n\n  // Cached regular expressions for matching named param parts and splatted\n  // parts of route strings.\n  var optionalParam = /\\((.*?)\\)/g;\n  var namedParam    = /(\\(\\?)?:\\w+/g;\n  var splatParam    = /\\*\\w+/g;\n  var escapeRegExp  = /[\\-{}\\[\\]+?.,\\\\\\^$|#\\s]/g;\n\n  // Set up all inheritable **Backbone.Router** properties and methods.\n  _.extend(Router.prototype, Events, {\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // Manually bind a single named route to a callback. For example:\n    //\n    //     this.route('search/:query/p:num', 'search', function(query, num) {\n    //       ...\n    //     });\n    //\n    route: function(route, name, callback) {\n      if (!_.isRegExp(route)) route = this._routeToRegExp(route);\n      if (_.isFunction(name)) {\n        callback = name;\n        name = '';\n      }\n      if (!callback) callback = this[name];\n      var router = this;\n      Backbone.history.route(route, function(fragment) {\n        var args = router._extractParameters(route, fragment);\n        if (router.execute(callback, args, name) !== false) {\n          router.trigger.apply(router, ['route:' + name].concat(args));\n          router.trigger('route', name, args);\n          Backbone.history.trigger('route', router, name, args);\n        }\n      });\n      return this;\n    },\n\n    // Execute a route handler with the provided parameters.  This is an\n    // excellent place to do pre-route setup or post-route cleanup.\n    execute: function(callback, args, name) {\n      if (callback) callback.apply(this, args);\n    },\n\n    // Simple proxy to `Backbone.history` to save a fragment into the history.\n    navigate: function(fragment, options) {\n      Backbone.history.navigate(fragment, options);\n      return this;\n    },\n\n    // Bind all defined routes to `Backbone.history`. We have to reverse the\n    // order of the routes here to support behavior where the most general\n    // routes can be defined at the bottom of the route map.\n    _bindRoutes: function() {\n      if (!this.routes) return;\n      this.routes = _.result(this, 'routes');\n      var route, routes = _.keys(this.routes);\n      while ((route = routes.pop()) != null) {\n        this.route(route, this.routes[route]);\n      }\n    },\n\n    // Convert a route string into a regular expression, suitable for matching\n    // against the current location hash.\n    _routeToRegExp: function(route) {\n      route = route.replace(escapeRegExp, '\\\\$&')\n                   .replace(optionalParam, '(?:$1)?')\n                   .replace(namedParam, function(match, optional) {\n                     return optional ? match : '([^/?]+)';\n                   })\n                   .replace(splatParam, '([^?]*?)');\n      return new RegExp('^' + route + '(?:\\\\?([\\\\s\\\\S]*))?$');\n    },\n\n    // Given a route, and a URL fragment that it matches, return the array of\n    // extracted decoded parameters. Empty or unmatched parameters will be\n    // treated as `null` to normalize cross-browser behavior.\n    _extractParameters: function(route, fragment) {\n      var params = route.exec(fragment).slice(1);\n      return _.map(params, function(param, i) {\n        // Don't decode the search params.\n        if (i === params.length - 1) return param || null;\n        return param ? decodeURIComponent(param) : null;\n      });\n    }\n\n  });\n\n  // Backbone.History\n  // ----------------\n\n  // Handles cross-browser history management, based on either\n  // [pushState](http://diveintohtml5.info/history.html) and real URLs, or\n  // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)\n  // and URL fragments. If the browser supports neither (old IE, natch),\n  // falls back to polling.\n  var History = Backbone.History = function() {\n    this.handlers = [];\n    this.checkUrl = _.bind(this.checkUrl, this);\n\n    // Ensure that `History` can be used outside of the browser.\n    if (typeof window !== 'undefined') {\n      this.location = window.location;\n      this.history = window.history;\n    }\n  };\n\n  // Cached regex for stripping a leading hash/slash and trailing space.\n  var routeStripper = /^[#\\/]|\\s+$/g;\n\n  // Cached regex for stripping leading and trailing slashes.\n  var rootStripper = /^\\/+|\\/+$/g;\n\n  // Cached regex for stripping urls of hash.\n  var pathStripper = /#.*$/;\n\n  // Has the history handling already been started?\n  History.started = false;\n\n  // Set up all inheritable **Backbone.History** properties and methods.\n  _.extend(History.prototype, Events, {\n\n    // The default interval to poll for hash changes, if necessary, is\n    // twenty times a second.\n    interval: 50,\n\n    // Are we at the app root?\n    atRoot: function() {\n      var path = this.location.pathname.replace(/[^\\/]$/, '$&/');\n      return path === this.root && !this.getSearch();\n    },\n\n    // Does the pathname match the root?\n    matchRoot: function() {\n      var path = this.decodeFragment(this.location.pathname);\n      var rootPath = path.slice(0, this.root.length - 1) + '/';\n      return rootPath === this.root;\n    },\n\n    // Unicode characters in `location.pathname` are percent encoded so they're\n    // decoded for comparison. `%25` should not be decoded since it may be part\n    // of an encoded parameter.\n    decodeFragment: function(fragment) {\n      return decodeURI(fragment.replace(/%25/g, '%2525'));\n    },\n\n    // In IE6, the hash fragment and search params are incorrect if the\n    // fragment contains `?`.\n    getSearch: function() {\n      var match = this.location.href.replace(/#.*/, '').match(/\\?.+/);\n      return match ? match[0] : '';\n    },\n\n    // Gets the true hash value. Cannot use location.hash directly due to bug\n    // in Firefox where location.hash will always be decoded.\n    getHash: function(window) {\n      var match = (window || this).location.href.match(/#(.*)$/);\n      return match ? match[1] : '';\n    },\n\n    // Get the pathname and search params, without the root.\n    getPath: function() {\n      var path = this.decodeFragment(\n        this.location.pathname + this.getSearch()\n      ).slice(this.root.length - 1);\n      return path.charAt(0) === '/' ? path.slice(1) : path;\n    },\n\n    // Get the cross-browser normalized URL fragment from the path or hash.\n    getFragment: function(fragment) {\n      if (fragment == null) {\n        if (this._usePushState || !this._wantsHashChange) {\n          fragment = this.getPath();\n        } else {\n          fragment = this.getHash();\n        }\n      }\n      return fragment.replace(routeStripper, '');\n    },\n\n    // Start the hash change handling, returning `true` if the current URL matches\n    // an existing route, and `false` otherwise.\n    start: function(options) {\n      if (History.started) throw new Error('Backbone.history has already been started');\n      History.started = true;\n\n      // Figure out the initial configuration. Do we need an iframe?\n      // Is pushState desired ... is it available?\n      this.options          = _.extend({root: '/'}, this.options, options);\n      this.root             = this.options.root;\n      this._wantsHashChange = this.options.hashChange !== false;\n      this._hasHashChange   = 'onhashchange' in window && (document.documentMode === void 0 || document.documentMode > 7);\n      this._useHashChange   = this._wantsHashChange && this._hasHashChange;\n      this._wantsPushState  = !!this.options.pushState;\n      this._hasPushState    = !!(this.history && this.history.pushState);\n      this._usePushState    = this._wantsPushState && this._hasPushState;\n      this.fragment         = this.getFragment();\n\n      // Normalize root to always include a leading and trailing slash.\n      this.root = ('/' + this.root + '/').replace(rootStripper, '/');\n\n      // Transition from hashChange to pushState or vice versa if both are\n      // requested.\n      if (this._wantsHashChange && this._wantsPushState) {\n\n        // If we've started off with a route from a `pushState`-enabled\n        // browser, but we're currently in a browser that doesn't support it...\n        if (!this._hasPushState && !this.atRoot()) {\n          var rootPath = this.root.slice(0, -1) || '/';\n          this.location.replace(rootPath + '#' + this.getPath());\n          // Return immediately as browser will do redirect to new url\n          return true;\n\n        // Or if we've started out with a hash-based route, but we're currently\n        // in a browser where it could be `pushState`-based instead...\n        } else if (this._hasPushState && this.atRoot()) {\n          this.navigate(this.getHash(), {replace: true});\n        }\n\n      }\n\n      // Proxy an iframe to handle location events if the browser doesn't\n      // support the `hashchange` event, HTML5 history, or the user wants\n      // `hashChange` but not `pushState`.\n      if (!this._hasHashChange && this._wantsHashChange && !this._usePushState) {\n        this.iframe = document.createElement('iframe');\n        this.iframe.src = 'javascript:0';\n        this.iframe.style.display = 'none';\n        this.iframe.tabIndex = -1;\n        var body = document.body;\n        // Using `appendChild` will throw on IE < 9 if the document is not ready.\n        var iWindow = body.insertBefore(this.iframe, body.firstChild).contentWindow;\n        iWindow.document.open();\n        iWindow.document.close();\n        iWindow.location.hash = '#' + this.fragment;\n      }\n\n      // Add a cross-platform `addEventListener` shim for older browsers.\n      var addEventListener = window.addEventListener || function(eventName, listener) {\n        return attachEvent('on' + eventName, listener);\n      };\n\n      // Depending on whether we're using pushState or hashes, and whether\n      // 'onhashchange' is supported, determine how we check the URL state.\n      if (this._usePushState) {\n        addEventListener('popstate', this.checkUrl, false);\n      } else if (this._useHashChange && !this.iframe) {\n        addEventListener('hashchange', this.checkUrl, false);\n      } else if (this._wantsHashChange) {\n        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);\n      }\n\n      if (!this.options.silent) return this.loadUrl();\n    },\n\n    // Disable Backbone.history, perhaps temporarily. Not useful in a real app,\n    // but possibly useful for unit testing Routers.\n    stop: function() {\n      // Add a cross-platform `removeEventListener` shim for older browsers.\n      var removeEventListener = window.removeEventListener || function(eventName, listener) {\n        return detachEvent('on' + eventName, listener);\n      };\n\n      // Remove window listeners.\n      if (this._usePushState) {\n        removeEventListener('popstate', this.checkUrl, false);\n      } else if (this._useHashChange && !this.iframe) {\n        removeEventListener('hashchange', this.checkUrl, false);\n      }\n\n      // Clean up the iframe if necessary.\n      if (this.iframe) {\n        document.body.removeChild(this.iframe);\n        this.iframe = null;\n      }\n\n      // Some environments will throw when clearing an undefined interval.\n      if (this._checkUrlInterval) clearInterval(this._checkUrlInterval);\n      History.started = false;\n    },\n\n    // Add a route to be tested when the fragment changes. Routes added later\n    // may override previous routes.\n    route: function(route, callback) {\n      this.handlers.unshift({route: route, callback: callback});\n    },\n\n    // Checks the current URL to see if it has changed, and if it has,\n    // calls `loadUrl`, normalizing across the hidden iframe.\n    checkUrl: function(e) {\n      var current = this.getFragment();\n\n      // If the user pressed the back button, the iframe's hash will have\n      // changed and we should use that for comparison.\n      if (current === this.fragment && this.iframe) {\n        current = this.getHash(this.iframe.contentWindow);\n      }\n\n      if (current === this.fragment) return false;\n      if (this.iframe) this.navigate(current);\n      this.loadUrl();\n    },\n\n    // Attempt to load the current URL fragment. If a route succeeds with a\n    // match, returns `true`. If no defined routes matches the fragment,\n    // returns `false`.\n    loadUrl: function(fragment) {\n      // If the root doesn't match, no routes can match either.\n      if (!this.matchRoot()) return false;\n      fragment = this.fragment = this.getFragment(fragment);\n      return _.some(this.handlers, function(handler) {\n        if (handler.route.test(fragment)) {\n          handler.callback(fragment);\n          return true;\n        }\n      });\n    },\n\n    // Save a fragment into the hash history, or replace the URL state if the\n    // 'replace' option is passed. You are responsible for properly URL-encoding\n    // the fragment in advance.\n    //\n    // The options object can contain `trigger: true` if you wish to have the\n    // route callback be fired (not usually desirable), or `replace: true`, if\n    // you wish to modify the current URL without adding an entry to the history.\n    navigate: function(fragment, options) {\n      if (!History.started) return false;\n      if (!options || options === true) options = {trigger: !!options};\n\n      // Normalize the fragment.\n      fragment = this.getFragment(fragment || '');\n\n      // Don't include a trailing slash on the root.\n      var rootPath = this.root;\n      if (fragment === '' || fragment.charAt(0) === '?') {\n        rootPath = rootPath.slice(0, -1) || '/';\n      }\n      var url = rootPath + fragment;\n\n      // Strip the hash and decode for matching.\n      fragment = this.decodeFragment(fragment.replace(pathStripper, ''));\n\n      if (this.fragment === fragment) return;\n      this.fragment = fragment;\n\n      // If pushState is available, we use it to set the fragment as a real URL.\n      if (this._usePushState) {\n        this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);\n\n      // If hash changes haven't been explicitly disabled, update the hash\n      // fragment to store history.\n      } else if (this._wantsHashChange) {\n        this._updateHash(this.location, fragment, options.replace);\n        if (this.iframe && fragment !== this.getHash(this.iframe.contentWindow)) {\n          var iWindow = this.iframe.contentWindow;\n\n          // Opening and closing the iframe tricks IE7 and earlier to push a\n          // history entry on hash-tag change.  When replace is true, we don't\n          // want this.\n          if (!options.replace) {\n            iWindow.document.open();\n            iWindow.document.close();\n          }\n\n          this._updateHash(iWindow.location, fragment, options.replace);\n        }\n\n      // If you've told us that you explicitly don't want fallback hashchange-\n      // based history, then `navigate` becomes a page refresh.\n      } else {\n        return this.location.assign(url);\n      }\n      if (options.trigger) return this.loadUrl(fragment);\n    },\n\n    // Update the hash location, either replacing the current entry, or adding\n    // a new one to the browser history.\n    _updateHash: function(location, fragment, replace) {\n      if (replace) {\n        var href = location.href.replace(/(javascript:|#).*$/, '');\n        location.replace(href + '#' + fragment);\n      } else {\n        // Some browsers require that `hash` contains a leading #.\n        location.hash = '#' + fragment;\n      }\n    }\n\n  });\n\n  // Create the default Backbone.history.\n  Backbone.history = new History;\n\n  // Helpers\n  // -------\n\n  // Helper function to correctly set up the prototype chain for subclasses.\n  // Similar to `goog.inherits`, but uses a hash of prototype properties and\n  // class properties to be extended.\n  var extend = function(protoProps, staticProps) {\n    var parent = this;\n    var child;\n\n    // The constructor function for the new subclass is either defined by you\n    // (the \"constructor\" property in your `extend` definition), or defaulted\n    // by us to simply call the parent constructor.\n    if (protoProps && _.has(protoProps, 'constructor')) {\n      child = protoProps.constructor;\n    } else {\n      child = function(){ return parent.apply(this, arguments); };\n    }\n\n    // Add static properties to the constructor function, if supplied.\n    _.extend(child, parent, staticProps);\n\n    // Set the prototype chain to inherit from `parent`, without calling\n    // `parent`'s constructor function and add the prototype properties.\n    child.prototype = _.create(parent.prototype, protoProps);\n    child.prototype.constructor = child;\n\n    // Set a convenience property in case the parent's prototype is needed\n    // later.\n    child.__super__ = parent.prototype;\n\n    return child;\n  };\n\n  // Set up inheritance for the model, collection, router, view and history.\n  Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;\n\n  // Throw an error when a URL is needed, and none is supplied.\n  var urlError = function() {\n    throw new Error('A \"url\" property or function must be specified');\n  };\n\n  // Wrap an optional error callback with a fallback error event.\n  var wrapError = function(model, options) {\n    var error = options.error;\n    options.error = function(resp) {\n      if (error) error.call(options.context, model, resp, options);\n      model.trigger('error', model, resp, options);\n    };\n  };\n\n  return Backbone;\n});\n","//------------------------------------------------------------------------\n// jQuery Unorphanize Plugin\n//\n// Based on https://github.com/simeydotme/jquery-unorphanize\n// Plugin boilerplate from https://github.com/jquery-boilerplate/jquery-boilerplate\n// CommonJS module wrapper from http://blog.npmjs.org/post/112712169830/making-your-jquery-plugin-work-better-with-npm\n//------------------------------------------------------------------------\n//jshint shadow:true\n\n// This function is called immediately. The second function is passed in\n// as the factory parameter to this function.\n\n// the semi-colon before function invocation is a safety net against concatenated\n// scripts and/or other plugins which may not be closed properly.\n;(function (factory) {\n  // If there is a variable named module and it has an exports property,\n  // then we're working in a Node-like environment. Use require to load\n  // the jQuery object that the module system is using and pass it in.\n  if ( typeof module === 'object' && typeof module.exports === 'object' ) {\n    factory(require('jquery'), window, document);\n  }\n  // Otherwise, we're working in a browser, so just pass in the global\n  // jQuery object.\n  else {\n    factory(jQuery, window, document);\n  }\n}(function($, window, document, undefined) {\n\n  // undefined is used here as the undefined global variable in ECMAScript 3 is\n  // mutable (ie. it can be changed by someone else). undefined isn't really being\n  // passed in so we can ensure the value of it is truly undefined. In ES5, undefined\n  // can no longer be modified.\n\n  // window and document are passed through as local variable rather than global\n  // as this (slightly) quickens the resolution process and can be more efficiently\n  // minified (especially when both are regularly referenced in your plugin).\n\n  // Array.prototype.filter polyfill for old browsers\n  // Source: https://github.com/Financial-Times/polyfill-service/blob/master/polyfills/Array.prototype.filter/polyfill.js\n  if ( !Array.prototype.filter ) {\n    Array.prototype.filter = function filter(callback) {\n      if (this === undefined || this === null) {\n        throw new TypeError(this + 'is not an object');\n      }\n\n      if (!(callback instanceof Function)) {\n        throw new TypeError(callback + ' is not a function');\n      }\n\n      var\n      object = Object(this),\n        scope = arguments[1],\n        arraylike = object instanceof String ? object.split('') : object,\n        length = Math.max(Math.min(arraylike.length, 9007199254740991), 0) || 0,\n        index = -1,\n        result = [],\n        element;\n\n      while (++index < length) {\n        element = arraylike[index];\n\n        if (index in arraylike && callback.call(scope, element, index, object)) {\n          result.push(element);\n        }\n      }\n\n      return result;\n    };\n  }\n\n\n  // Array.prototype.indexOf polyfill\n  // Source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf#Polyfill\n  if ( !Array.prototype.indexOf ) {\n    Array.prototype.indexOf = function(searchElement, fromIndex) {\n\n      var k;\n\n      // 1. Let O be the result of calling ToObject passing\n      //    the this value as the argument.\n      if (this === null) {\n        throw new TypeError('“this” is null or not defined');\n      }\n\n      var O = Object(this);\n\n      // 2. Let lenValue be the result of calling the Get\n      //    internal method of O with the argument \"length\".\n      // 3. Let len be ToUint32(lenValue).\n      var len = O.length >>> 0;\n\n      // 4. If len is 0, return -1.\n      if (len === 0) {\n        return -1;\n      }\n\n      // 5. If argument fromIndex was passed let n be\n      //    ToInteger(fromIndex); else let n be 0.\n      var n = +fromIndex || 0;\n\n      if (Math.abs(n) === Infinity) {\n        n = 0;\n      }\n\n      // 6. If n >= len, return -1.\n      if (n >= len) {\n        return -1;\n      }\n\n      // 7. If n >= 0, then Let k be n.\n      // 8. Else, n<0, Let k be len - abs(n).\n      //    If k is less than 0, then let k be 0.\n      k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);\n\n      // 9. Repeat, while k < len\n      while (k < len) {\n        // a. Let Pk be ToString(k).\n        //   This is implicit for LHS operands of the in operator\n        // b. Let kPresent be the result of calling the\n        //    HasProperty internal method of O with argument Pk.\n        //   This step can be combined with c\n        // c. If kPresent is true, then\n        //    i.  Let elementK be the result of calling the Get\n        //        internal method of O with the argument ToString(k).\n        //   ii.  Let same be the result of applying the\n        //        Strict Equality Comparison Algorithm to\n        //        searchElement and elementK.\n        //  iii.  If same is true, return k.\n        if (k in O && O[k] === searchElement) {\n          return k;\n        }\n        k++;\n      }\n      return -1;\n    };\n  }\n\n\n  // Create the defaults once\n  var pluginName = 'unorphanize',\n    defaults = {\n      words: 2,\n      wrapEl: '',\n      className: '',\n      append: ''\n    };\n\n  // The actual plugin constructor\n\n  function Plugin(element, options) {\n    this.element = element;\n    // jQuery has an extend method which merges the contents of two or\n    // more objects, storing the result in the first object. The first object\n    // is generally empty as we don't want to alter the default options for\n    // future instances of the plugin\n    this.settings = $.extend({}, defaults, options);\n    this._defaults = defaults;\n    this._name = pluginName;\n    this.init();\n  }\n\n  // Avoid Plugin.prototype conflicts\n  $.extend(Plugin.prototype, {\n    init: function() {\n      // Place initialization logic here\n      // You already have access to the DOM element and\n      // the options via the instance, e.g. this.element\n      // and this.settings\n      // you can add more functions like the one below and\n      // call them like so: this.yourOtherFunction(this.element, this.settings).\n      var self = this;\n\n      var $el = $(this.element);\n\n      // Exit if no text\n      if ( $.trim( $el.text() ).length === 0 ) {\n        return false;\n      }\n\n      // Save html of element\n      this.text = $.trim( $el.html() );\n\n      // Find any STARTING html tags\n      this.startTags = this.text.match(/<([A-Z][A-Z0-9]*)\\b[^>]*>/gi);\n      this.startTagsCount = ( this.startTags !== null ? this.startTags.length : 0 );\n\n      // Replace STARTING tags with placeholder (e.g. __0__)\n      this.startPlaceholders = [];\n      for ( var i = 0; i < this.startTagsCount; i++ ) {\n        // Push placeholder to array so we can replace it later\n        this.startPlaceholders.push('__' + i + '__');\n        // Replace tag with placeholder text\n        this.text = this.text.replace( self.startTags[i], self.startPlaceholders[i] );\n      }\n\n      // Find any ENDING html tags\n      this.endTags = this.text.match(/<\\/[A-Z][A-Z0-9]*>/gi);\n      this.endTagsCount = ( this.endTags !== null ? this.endTags.length : 0 );\n\n      // Replace ENDING tags with different placeholder (e.g. ~~0~~)\n      this.endPlaceholders = [];\n      for ( var i = 0; i < this.endTagsCount; i++ ) {\n        // Push placeholder to array so we can replace it later\n        this.endPlaceholders.push('~~' + i + '~~');\n        // Replace tag with placeholder text\n        this.text = this.text.replace( self.endTags[i], self.endPlaceholders[i] );\n      }\n\n      // Create array of words from string\n      this.wordArray = this.text.split(/\\s+/);\n\n      // Save the _word_ positions in the original array\n      var wordId = 1;\n      this.wordPositions = [];\n\n      // Create new array without any placeholder tags, which would throw off word count\n      this.cleanWordArray = this.wordArray.map( function(item, i) {\n        // Check for a single HTML tag replacement (e.g. <br> tag --> __1__)\n        if ( !!item.match(/__[0-9]+__\\b/gi) || !!item.match(/~~[0-9]+~~\\b/gi) ) {\n          // Increment wordID to help us track the word positions between the two arrays\n          wordId++;\n          return false;\n        }\n        else {\n          // Save word position\n          self.wordPositions.push(i);\n          return item;\n        }\n      });\n\n      // Remove false values from array\n      this.cleanWordArray = this.cleanWordArray.filter( function(value) { return value; } );\n\n      // Make sure word count is valid\n      if ( typeof this.settings.words !== 'number' || this.settings.words < 1 ) {\n        this.settings.words = this._defaults.words;\n      }\n      // If only 1 orphan is specified, default to wrapping word, not using &nbsp;\n      else if ( this.settings.words === 1 ) {\n        this.settings.wrapEl = ( this.settings.wrapEl.length ? this.settings.wrapEl : 'span' );\n        this.settings.className = ( this.settings.className.length ? this.settings.className : 'u-nowrap' );\n      }\n      // Don't allow orphan count to exceed the number of words\n      else if ( this.settings.words >= this.cleanWordArray.length ) {\n        this.settings.words = this.cleanWordArray.length;\n      }\n\n      // Find word where plugin should start\n      this.lastWordPos = this.cleanWordArray.length - this.settings.words;\n      // console.log('this.lastWordPos', this.lastWordPos, this.cleanWordArray[this.lastWordPos]);\n\n      // Find word position in original array\n      this.lastWordIndex = this.wordPositions[ this.lastWordPos ];\n      // console.log('this.lastWordIndex', this.lastWordIndex, this.wordArray[ this.lastWordPos ]);\n\n      // Split the original word array into two parts\n      this.firstPart = self.wordArray.slice( 0, self.lastWordIndex ).join(' ');\n      this.lastPart = self.wordArray.slice( self.lastWordIndex ).join(' ');\n\n      // Validate settings variables\n      if ( typeof this.settings.wrapEl !== 'string' ) {\n        this.settings.wrapEl = this._defaults.wrapEl;\n      }\n      if ( typeof this.settings.className !== 'string' ) {\n        this.settings.className = this._defaults.className;\n      }\n      if ( typeof this.settings.append !== 'string' ) {\n        this.settings.append = this._defaults.append;\n      }\n\n      // Add wrapper element\n      if ( !!this.settings.wrapEl ) {\n        this.text = this.firstPart + ' <' + this.settings.wrapEl + ' class=\"' + this.settings.className + '\">' + this.lastPart + this.settings.append + '</' + this.settings.wrapEl + '>';\n      }\n      // Add &nbsp; entities\n      else {\n        this.lastPart = this.lastPart.split(' ').join('&nbsp;');\n        this.text = this.firstPart + ' ' + this.lastPart;\n      }\n\n      // Replace the STARTING tag placeholders with the original tag code\n      for( var i = 0; i < this.startTagsCount; i++ ) {\n        var replaceRegex = new RegExp( this.startPlaceholders[i] );\n        this.text = this.text.replace( replaceRegex , this.startTags[i] );\n      }\n      // Replace the ENDING tag placeholders with the original tag code\n      for( var i = 0; i < this.endTagsCount; i++ ) {\n        var replaceRegex = new RegExp( this.endPlaceholders[i] );\n        this.text = this.text.replace( replaceRegex , this.endTags[i] );\n      }\n\n      // Update the element's html\n      $el.html( this.text );\n    }\n  });\n\n  // A really lightweight plugin wrapper around the constructor,\n  // preventing against multiple instantiations\n  $.fn[pluginName] = function(options) {\n    return this.each(function() {\n      if (!$.data(this, 'plugin_' + pluginName)) {\n        $.data(this, 'plugin_' + pluginName, new Plugin(this, options));\n      }\n    });\n  };\n\n}));\n","/*!\n * jQuery JavaScript Library v3.2.1\n * https://jquery.com/\n *\n * Includes Sizzle.js\n * https://sizzlejs.com/\n *\n * Copyright JS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2017-03-20T18:59Z\n */\n( function( global, factory ) {\n\n\t\"use strict\";\n\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\n\t\t// For CommonJS and CommonJS-like environments where a proper `window`\n\t\t// is present, execute the factory and get jQuery.\n\t\t// For environments that do not have a `window` with a `document`\n\t\t// (such as Node.js), expose a factory as module.exports.\n\t\t// This accentuates the need for the creation of a real `window`.\n\t\t// e.g. var jQuery = require(\"jquery\")(window);\n\t\t// See ticket #14549 for more info.\n\t\tmodule.exports = global.document ?\n\t\t\tfactory( global, true ) :\n\t\t\tfunction( w ) {\n\t\t\t\tif ( !w.document ) {\n\t\t\t\t\tthrow new Error( \"jQuery requires a window with a document\" );\n\t\t\t\t}\n\t\t\t\treturn factory( w );\n\t\t\t};\n\t} else {\n\t\tfactory( global );\n\t}\n\n// Pass this if window is not defined yet\n} )( typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\n\n// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1\n// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode\n// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common\n// enough that all such attempts are guarded in a try block.\n\"use strict\";\n\nvar arr = [];\n\nvar document = window.document;\n\nvar getProto = Object.getPrototypeOf;\n\nvar slice = arr.slice;\n\nvar concat = arr.concat;\n\nvar push = arr.push;\n\nvar indexOf = arr.indexOf;\n\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar fnToString = hasOwn.toString;\n\nvar ObjectFunctionString = fnToString.call( Object );\n\nvar support = {};\n\n\n\n\tfunction DOMEval( code, doc ) {\n\t\tdoc = doc || document;\n\n\t\tvar script = doc.createElement( \"script\" );\n\n\t\tscript.text = code;\n\t\tdoc.head.appendChild( script ).parentNode.removeChild( script );\n\t}\n/* global Symbol */\n// Defining this global in .eslintrc.json would create a danger of using the global\n// unguarded in another place, it seems safer to define global only for this module\n\n\n\nvar\n\tversion = \"3.2.1\",\n\n\t// Define a local copy of jQuery\n\tjQuery = function( selector, context ) {\n\n\t\t// The jQuery object is actually just the init constructor 'enhanced'\n\t\t// Need init if jQuery is called (just allow error to be thrown if not included)\n\t\treturn new jQuery.fn.init( selector, context );\n\t},\n\n\t// Support: Android <=4.0 only\n\t// Make sure we trim BOM and NBSP\n\trtrim = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g,\n\n\t// Matches dashed string for camelizing\n\trmsPrefix = /^-ms-/,\n\trdashAlpha = /-([a-z])/g,\n\n\t// Used by jQuery.camelCase as callback to replace()\n\tfcamelCase = function( all, letter ) {\n\t\treturn letter.toUpperCase();\n\t};\n\njQuery.fn = jQuery.prototype = {\n\n\t// The current version of jQuery being used\n\tjquery: version,\n\n\tconstructor: jQuery,\n\n\t// The default length of a jQuery object is 0\n\tlength: 0,\n\n\ttoArray: function() {\n\t\treturn slice.call( this );\n\t},\n\n\t// Get the Nth element in the matched element set OR\n\t// Get the whole matched element set as a clean array\n\tget: function( num ) {\n\n\t\t// Return all the elements in a clean array\n\t\tif ( num == null ) {\n\t\t\treturn slice.call( this );\n\t\t}\n\n\t\t// Return just the one element from the set\n\t\treturn num < 0 ? this[ num + this.length ] : this[ num ];\n\t},\n\n\t// Take an array of elements and push it onto the stack\n\t// (returning the new matched element set)\n\tpushStack: function( elems ) {\n\n\t\t// Build a new jQuery matched element set\n\t\tvar ret = jQuery.merge( this.constructor(), elems );\n\n\t\t// Add the old object onto the stack (as a reference)\n\t\tret.prevObject = this;\n\n\t\t// Return the newly-formed element set\n\t\treturn ret;\n\t},\n\n\t// Execute a callback for every element in the matched set.\n\teach: function( callback ) {\n\t\treturn jQuery.each( this, callback );\n\t},\n\n\tmap: function( callback ) {\n\t\treturn this.pushStack( jQuery.map( this, function( elem, i ) {\n\t\t\treturn callback.call( elem, i, elem );\n\t\t} ) );\n\t},\n\n\tslice: function() {\n\t\treturn this.pushStack( slice.apply( this, arguments ) );\n\t},\n\n\tfirst: function() {\n\t\treturn this.eq( 0 );\n\t},\n\n\tlast: function() {\n\t\treturn this.eq( -1 );\n\t},\n\n\teq: function( i ) {\n\t\tvar len = this.length,\n\t\t\tj = +i + ( i < 0 ? len : 0 );\n\t\treturn this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );\n\t},\n\n\tend: function() {\n\t\treturn this.prevObject || this.constructor();\n\t},\n\n\t// For internal use only.\n\t// Behaves like an Array's method, not like a jQuery method.\n\tpush: push,\n\tsort: arr.sort,\n\tsplice: arr.splice\n};\n\njQuery.extend = jQuery.fn.extend = function() {\n\tvar options, name, src, copy, copyIsArray, clone,\n\t\ttarget = arguments[ 0 ] || {},\n\t\ti = 1,\n\t\tlength = arguments.length,\n\t\tdeep = false;\n\n\t// Handle a deep copy situation\n\tif ( typeof target === \"boolean\" ) {\n\t\tdeep = target;\n\n\t\t// Skip the boolean and the target\n\t\ttarget = arguments[ i ] || {};\n\t\ti++;\n\t}\n\n\t// Handle case when target is a string or something (possible in deep copy)\n\tif ( typeof target !== \"object\" && !jQuery.isFunction( target ) ) {\n\t\ttarget = {};\n\t}\n\n\t// Extend jQuery itself if only one argument is passed\n\tif ( i === length ) {\n\t\ttarget = this;\n\t\ti--;\n\t}\n\n\tfor ( ; i < length; i++ ) {\n\n\t\t// Only deal with non-null/undefined values\n\t\tif ( ( options = arguments[ i ] ) != null ) {\n\n\t\t\t// Extend the base object\n\t\t\tfor ( name in options ) {\n\t\t\t\tsrc = target[ name ];\n\t\t\t\tcopy = options[ name ];\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif ( target === copy ) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\tif ( deep && copy && ( jQuery.isPlainObject( copy ) ||\n\t\t\t\t\t( copyIsArray = Array.isArray( copy ) ) ) ) {\n\n\t\t\t\t\tif ( copyIsArray ) {\n\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\tclone = src && Array.isArray( src ) ? src : [];\n\n\t\t\t\t\t} else {\n\t\t\t\t\t\tclone = src && jQuery.isPlainObject( src ) ? src : {};\n\t\t\t\t\t}\n\n\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\ttarget[ name ] = jQuery.extend( deep, clone, copy );\n\n\t\t\t\t// Don't bring in undefined values\n\t\t\t\t} else if ( copy !== undefined ) {\n\t\t\t\t\ttarget[ name ] = copy;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n\njQuery.extend( {\n\n\t// Unique for each copy of jQuery on the page\n\texpando: \"jQuery\" + ( version + Math.random() ).replace( /\\D/g, \"\" ),\n\n\t// Assume jQuery is ready without the ready module\n\tisReady: true,\n\n\terror: function( msg ) {\n\t\tthrow new Error( msg );\n\t},\n\n\tnoop: function() {},\n\n\tisFunction: function( obj ) {\n\t\treturn jQuery.type( obj ) === \"function\";\n\t},\n\n\tisWindow: function( obj ) {\n\t\treturn obj != null && obj === obj.window;\n\t},\n\n\tisNumeric: function( obj ) {\n\n\t\t// As of jQuery 3.0, isNumeric is limited to\n\t\t// strings and numbers (primitives or objects)\n\t\t// that can be coerced to finite numbers (gh-2662)\n\t\tvar type = jQuery.type( obj );\n\t\treturn ( type === \"number\" || type === \"string\" ) &&\n\n\t\t\t// parseFloat NaNs numeric-cast false positives (\"\")\n\t\t\t// ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n\t\t\t// subtraction forces infinities to NaN\n\t\t\t!isNaN( obj - parseFloat( obj ) );\n\t},\n\n\tisPlainObject: function( obj ) {\n\t\tvar proto, Ctor;\n\n\t\t// Detect obvious negatives\n\t\t// Use toString instead of jQuery.type to catch host objects\n\t\tif ( !obj || toString.call( obj ) !== \"[object Object]\" ) {\n\t\t\treturn false;\n\t\t}\n\n\t\tproto = getProto( obj );\n\n\t\t// Objects with no prototype (e.g., `Object.create( null )`) are plain\n\t\tif ( !proto ) {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Objects with prototype are plain iff they were constructed by a global Object function\n\t\tCtor = hasOwn.call( proto, \"constructor\" ) && proto.constructor;\n\t\treturn typeof Ctor === \"function\" && fnToString.call( Ctor ) === ObjectFunctionString;\n\t},\n\n\tisEmptyObject: function( obj ) {\n\n\t\t/* eslint-disable no-unused-vars */\n\t\t// See https://github.com/eslint/eslint/issues/6125\n\t\tvar name;\n\n\t\tfor ( name in obj ) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t},\n\n\ttype: function( obj ) {\n\t\tif ( obj == null ) {\n\t\t\treturn obj + \"\";\n\t\t}\n\n\t\t// Support: Android <=2.3 only (functionish RegExp)\n\t\treturn typeof obj === \"object\" || typeof obj === \"function\" ?\n\t\t\tclass2type[ toString.call( obj ) ] || \"object\" :\n\t\t\ttypeof obj;\n\t},\n\n\t// Evaluates a script in a global context\n\tglobalEval: function( code ) {\n\t\tDOMEval( code );\n\t},\n\n\t// Convert dashed to camelCase; used by the css and data modules\n\t// Support: IE <=9 - 11, Edge 12 - 13\n\t// Microsoft forgot to hump their vendor prefix (#9572)\n\tcamelCase: function( string ) {\n\t\treturn string.replace( rmsPrefix, \"ms-\" ).replace( rdashAlpha, fcamelCase );\n\t},\n\n\teach: function( obj, callback ) {\n\t\tvar length, i = 0;\n\n\t\tif ( isArrayLike( obj ) ) {\n\t\t\tlength = obj.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor ( i in obj ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn obj;\n\t},\n\n\t// Support: Android <=4.0 only\n\ttrim: function( text ) {\n\t\treturn text == null ?\n\t\t\t\"\" :\n\t\t\t( text + \"\" ).replace( rtrim, \"\" );\n\t},\n\n\t// results is for internal usage only\n\tmakeArray: function( arr, results ) {\n\t\tvar ret = results || [];\n\n\t\tif ( arr != null ) {\n\t\t\tif ( isArrayLike( Object( arr ) ) ) {\n\t\t\t\tjQuery.merge( ret,\n\t\t\t\t\ttypeof arr === \"string\" ?\n\t\t\t\t\t[ arr ] : arr\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tpush.call( ret, arr );\n\t\t\t}\n\t\t}\n\n\t\treturn ret;\n\t},\n\n\tinArray: function( elem, arr, i ) {\n\t\treturn arr == null ? -1 : indexOf.call( arr, elem, i );\n\t},\n\n\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t// push.apply(_, arraylike) throws on ancient WebKit\n\tmerge: function( first, second ) {\n\t\tvar len = +second.length,\n\t\t\tj = 0,\n\t\t\ti = first.length;\n\n\t\tfor ( ; j < len; j++ ) {\n\t\t\tfirst[ i++ ] = second[ j ];\n\t\t}\n\n\t\tfirst.length = i;\n\n\t\treturn first;\n\t},\n\n\tgrep: function( elems, callback, invert ) {\n\t\tvar callbackInverse,\n\t\t\tmatches = [],\n\t\t\ti = 0,\n\t\t\tlength = elems.length,\n\t\t\tcallbackExpect = !invert;\n\n\t\t// Go through the array, only saving the items\n\t\t// that pass the validator function\n\t\tfor ( ; i < length; i++ ) {\n\t\t\tcallbackInverse = !callback( elems[ i ], i );\n\t\t\tif ( callbackInverse !== callbackExpect ) {\n\t\t\t\tmatches.push( elems[ i ] );\n\t\t\t}\n\t\t}\n\n\t\treturn matches;\n\t},\n\n\t// arg is for internal usage only\n\tmap: function( elems, callback, arg ) {\n\t\tvar length, value,\n\t\t\ti = 0,\n\t\t\tret = [];\n\n\t\t// Go through the array, translating each of the items to their new values\n\t\tif ( isArrayLike( elems ) ) {\n\t\t\tlength = elems.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Go through every key on the object,\n\t\t} else {\n\t\t\tfor ( i in elems ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Flatten any nested arrays\n\t\treturn concat.apply( [], ret );\n\t},\n\n\t// A global GUID counter for objects\n\tguid: 1,\n\n\t// Bind a function to a context, optionally partially applying any\n\t// arguments.\n\tproxy: function( fn, context ) {\n\t\tvar tmp, args, proxy;\n\n\t\tif ( typeof context === \"string\" ) {\n\t\t\ttmp = fn[ context ];\n\t\t\tcontext = fn;\n\t\t\tfn = tmp;\n\t\t}\n\n\t\t// Quick check to determine if target is callable, in the spec\n\t\t// this throws a TypeError, but we will just return undefined.\n\t\tif ( !jQuery.isFunction( fn ) ) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Simulated bind\n\t\targs = slice.call( arguments, 2 );\n\t\tproxy = function() {\n\t\t\treturn fn.apply( context || this, args.concat( slice.call( arguments ) ) );\n\t\t};\n\n\t\t// Set the guid of unique handler to the same of original handler, so it can be removed\n\t\tproxy.guid = fn.guid = fn.guid || jQuery.guid++;\n\n\t\treturn proxy;\n\t},\n\n\tnow: Date.now,\n\n\t// jQuery.support is not used in Core but other projects attach their\n\t// properties to it so it needs to exist.\n\tsupport: support\n} );\n\nif ( typeof Symbol === \"function\" ) {\n\tjQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];\n}\n\n// Populate the class2type map\njQuery.each( \"Boolean Number String Function Array Date RegExp Object Error Symbol\".split( \" \" ),\nfunction( i, name ) {\n\tclass2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\n} );\n\nfunction isArrayLike( obj ) {\n\n\t// Support: real iOS 8.2 only (not reproducible in simulator)\n\t// `in` check used to prevent JIT error (gh-2145)\n\t// hasOwn isn't used here due to false negatives\n\t// regarding Nodelist length in IE\n\tvar length = !!obj && \"length\" in obj && obj.length,\n\t\ttype = jQuery.type( obj );\n\n\tif ( type === \"function\" || jQuery.isWindow( obj ) ) {\n\t\treturn false;\n\t}\n\n\treturn type === \"array\" || length === 0 ||\n\t\ttypeof length === \"number\" && length > 0 && ( length - 1 ) in obj;\n}\nvar Sizzle =\n/*!\n * Sizzle CSS Selector Engine v2.3.3\n * https://sizzlejs.com/\n *\n * Copyright jQuery Foundation and other contributors\n * Released under the MIT license\n * http://jquery.org/license\n *\n * Date: 2016-08-08\n */\n(function( window ) {\n\nvar i,\n\tsupport,\n\tExpr,\n\tgetText,\n\tisXML,\n\ttokenize,\n\tcompile,\n\tselect,\n\toutermostContext,\n\tsortInput,\n\thasDuplicate,\n\n\t// Local document vars\n\tsetDocument,\n\tdocument,\n\tdocElem,\n\tdocumentIsHTML,\n\trbuggyQSA,\n\trbuggyMatches,\n\tmatches,\n\tcontains,\n\n\t// Instance-specific data\n\texpando = \"sizzle\" + 1 * new Date(),\n\tpreferredDoc = window.document,\n\tdirruns = 0,\n\tdone = 0,\n\tclassCache = createCache(),\n\ttokenCache = createCache(),\n\tcompilerCache = createCache(),\n\tsortOrder = function( a, b ) {\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t}\n\t\treturn 0;\n\t},\n\n\t// Instance methods\n\thasOwn = ({}).hasOwnProperty,\n\tarr = [],\n\tpop = arr.pop,\n\tpush_native = arr.push,\n\tpush = arr.push,\n\tslice = arr.slice,\n\t// Use a stripped-down indexOf as it's faster than native\n\t// https://jsperf.com/thor-indexof-vs-for/5\n\tindexOf = function( list, elem ) {\n\t\tvar i = 0,\n\t\t\tlen = list.length;\n\t\tfor ( ; i < len; i++ ) {\n\t\t\tif ( list[i] === elem ) {\n\t\t\t\treturn i;\n\t\t\t}\n\t\t}\n\t\treturn -1;\n\t},\n\n\tbooleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped\",\n\n\t// Regular expressions\n\n\t// http://www.w3.org/TR/css3-selectors/#whitespace\n\twhitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\",\n\n\t// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier\n\tidentifier = \"(?:\\\\\\\\.|[\\\\w-]|[^\\0-\\\\xa0])+\",\n\n\t// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors\n\tattributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\n\t\t// Operator (capture 2)\n\t\t\"*([*^$|!~]?=)\" + whitespace +\n\t\t// \"Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]\"\n\t\t\"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" + whitespace +\n\t\t\"*\\\\]\",\n\n\tpseudos = \":(\" + identifier + \")(?:\\\\((\" +\n\t\t// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n\t\t// 1. quoted (capture 3; capture 4 or capture 5)\n\t\t\"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\n\t\t// 2. simple (capture 6)\n\t\t\"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\t\t// 3. anything else (capture 2)\n\t\t\".*\" +\n\t\t\")\\\\)|)\",\n\n\t// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n\trwhitespace = new RegExp( whitespace + \"+\", \"g\" ),\n\trtrim = new RegExp( \"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\", \"g\" ),\n\n\trcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" ),\n\trcombinators = new RegExp( \"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" + whitespace + \"*\" ),\n\n\trattributeQuotes = new RegExp( \"=\" + whitespace + \"*([^\\\\]'\\\"]*?)\" + whitespace + \"*\\\\]\", \"g\" ),\n\n\trpseudo = new RegExp( pseudos ),\n\tridentifier = new RegExp( \"^\" + identifier + \"$\" ),\n\n\tmatchExpr = {\n\t\t\"ID\": new RegExp( \"^#(\" + identifier + \")\" ),\n\t\t\"CLASS\": new RegExp( \"^\\\\.(\" + identifier + \")\" ),\n\t\t\"TAG\": new RegExp( \"^(\" + identifier + \"|[*])\" ),\n\t\t\"ATTR\": new RegExp( \"^\" + attributes ),\n\t\t\"PSEUDO\": new RegExp( \"^\" + pseudos ),\n\t\t\"CHILD\": new RegExp( \"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" + whitespace +\n\t\t\t\"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" + whitespace +\n\t\t\t\"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" ),\n\t\t\"bool\": new RegExp( \"^(?:\" + booleans + \")$\", \"i\" ),\n\t\t// For use in libraries implementing .is()\n\t\t// We use this for POS matching in `select`\n\t\t\"needsContext\": new RegExp( \"^\" + whitespace + \"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" +\n\t\t\twhitespace + \"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\n\t},\n\n\trinputs = /^(?:input|select|textarea|button)$/i,\n\trheader = /^h\\d$/i,\n\n\trnative = /^[^{]+\\{\\s*\\[native \\w/,\n\n\t// Easily-parseable/retrievable ID or TAG or CLASS selectors\n\trquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n\n\trsibling = /[+~]/,\n\n\t// CSS escapes\n\t// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n\trunescape = new RegExp( \"\\\\\\\\([\\\\da-f]{1,6}\" + whitespace + \"?|(\" + whitespace + \")|.)\", \"ig\" ),\n\tfunescape = function( _, escaped, escapedWhitespace ) {\n\t\tvar high = \"0x\" + escaped - 0x10000;\n\t\t// NaN means non-codepoint\n\t\t// Support: Firefox<24\n\t\t// Workaround erroneous numeric interpretation of +\"0x\"\n\t\treturn high !== high || escapedWhitespace ?\n\t\t\tescaped :\n\t\t\thigh < 0 ?\n\t\t\t\t// BMP codepoint\n\t\t\t\tString.fromCharCode( high + 0x10000 ) :\n\t\t\t\t// Supplemental Plane codepoint (surrogate pair)\n\t\t\t\tString.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\n\t},\n\n\t// CSS string/identifier serialization\n\t// https://drafts.csswg.org/cssom/#common-serializing-idioms\n\trcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\0-\\x1f\\x7f-\\uFFFF\\w-]/g,\n\tfcssescape = function( ch, asCodePoint ) {\n\t\tif ( asCodePoint ) {\n\n\t\t\t// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n\t\t\tif ( ch === \"\\0\" ) {\n\t\t\t\treturn \"\\uFFFD\";\n\t\t\t}\n\n\t\t\t// Control characters and (dependent upon position) numbers get escaped as code points\n\t\t\treturn ch.slice( 0, -1 ) + \"\\\\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + \" \";\n\t\t}\n\n\t\t// Other potentially-special ASCII characters get backslash-escaped\n\t\treturn \"\\\\\" + ch;\n\t},\n\n\t// Used for iframes\n\t// See setDocument()\n\t// Removing the function wrapper causes a \"Permission Denied\"\n\t// error in IE\n\tunloadHandler = function() {\n\t\tsetDocument();\n\t},\n\n\tdisabledAncestor = addCombinator(\n\t\tfunction( elem ) {\n\t\t\treturn elem.disabled === true && (\"form\" in elem || \"label\" in elem);\n\t\t},\n\t\t{ dir: \"parentNode\", next: \"legend\" }\n\t);\n\n// Optimize for push.apply( _, NodeList )\ntry {\n\tpush.apply(\n\t\t(arr = slice.call( preferredDoc.childNodes )),\n\t\tpreferredDoc.childNodes\n\t);\n\t// Support: Android<4.0\n\t// Detect silently failing push.apply\n\tarr[ preferredDoc.childNodes.length ].nodeType;\n} catch ( e ) {\n\tpush = { apply: arr.length ?\n\n\t\t// Leverage slice if possible\n\t\tfunction( target, els ) {\n\t\t\tpush_native.apply( target, slice.call(els) );\n\t\t} :\n\n\t\t// Support: IE<9\n\t\t// Otherwise append directly\n\t\tfunction( target, els ) {\n\t\t\tvar j = target.length,\n\t\t\t\ti = 0;\n\t\t\t// Can't trust NodeList.length\n\t\t\twhile ( (target[j++] = els[i++]) ) {}\n\t\t\ttarget.length = j - 1;\n\t\t}\n\t};\n}\n\nfunction Sizzle( selector, context, results, seed ) {\n\tvar m, i, elem, nid, match, groups, newSelector,\n\t\tnewContext = context && context.ownerDocument,\n\n\t\t// nodeType defaults to 9, since context defaults to document\n\t\tnodeType = context ? context.nodeType : 9;\n\n\tresults = results || [];\n\n\t// Return early from calls with invalid selector or context\n\tif ( typeof selector !== \"string\" || !selector ||\n\t\tnodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {\n\n\t\treturn results;\n\t}\n\n\t// Try to shortcut find operations (as opposed to filters) in HTML documents\n\tif ( !seed ) {\n\n\t\tif ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {\n\t\t\tsetDocument( context );\n\t\t}\n\t\tcontext = context || document;\n\n\t\tif ( documentIsHTML ) {\n\n\t\t\t// If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n\t\t\t// (excepting DocumentFragment context, where the methods don't exist)\n\t\t\tif ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {\n\n\t\t\t\t// ID selector\n\t\t\t\tif ( (m = match[1]) ) {\n\n\t\t\t\t\t// Document context\n\t\t\t\t\tif ( nodeType === 9 ) {\n\t\t\t\t\t\tif ( (elem = context.getElementById( m )) ) {\n\n\t\t\t\t\t\t\t// Support: IE, Opera, Webkit\n\t\t\t\t\t\t\t// TODO: identify versions\n\t\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\t\tif ( elem.id === m ) {\n\t\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// Element context\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// Support: IE, Opera, Webkit\n\t\t\t\t\t\t// TODO: identify versions\n\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\tif ( newContext && (elem = newContext.getElementById( m )) &&\n\t\t\t\t\t\t\tcontains( context, elem ) &&\n\t\t\t\t\t\t\telem.id === m ) {\n\n\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t// Type selector\n\t\t\t\t} else if ( match[2] ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByTagName( selector ) );\n\t\t\t\t\treturn results;\n\n\t\t\t\t// Class selector\n\t\t\t\t} else if ( (m = match[3]) && support.getElementsByClassName &&\n\t\t\t\t\tcontext.getElementsByClassName ) {\n\n\t\t\t\t\tpush.apply( results, context.getElementsByClassName( m ) );\n\t\t\t\t\treturn results;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Take advantage of querySelectorAll\n\t\t\tif ( support.qsa &&\n\t\t\t\t!compilerCache[ selector + \" \" ] &&\n\t\t\t\t(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {\n\n\t\t\t\tif ( nodeType !== 1 ) {\n\t\t\t\t\tnewContext = context;\n\t\t\t\t\tnewSelector = selector;\n\n\t\t\t\t// qSA looks outside Element context, which is not what we want\n\t\t\t\t// Thanks to Andrew Dupont for this workaround technique\n\t\t\t\t// Support: IE <=8\n\t\t\t\t// Exclude object elements\n\t\t\t\t} else if ( context.nodeName.toLowerCase() !== \"object\" ) {\n\n\t\t\t\t\t// Capture the context ID, setting it first if necessary\n\t\t\t\t\tif ( (nid = context.getAttribute( \"id\" )) ) {\n\t\t\t\t\t\tnid = nid.replace( rcssescape, fcssescape );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcontext.setAttribute( \"id\", (nid = expando) );\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prefix every selector in the list\n\t\t\t\t\tgroups = tokenize( selector );\n\t\t\t\t\ti = groups.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tgroups[i] = \"#\" + nid + \" \" + toSelector( groups[i] );\n\t\t\t\t\t}\n\t\t\t\t\tnewSelector = groups.join( \",\" );\n\n\t\t\t\t\t// Expand context for sibling selectors\n\t\t\t\t\tnewContext = rsibling.test( selector ) && testContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext;\n\t\t\t\t}\n\n\t\t\t\tif ( newSelector ) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tpush.apply( results,\n\t\t\t\t\t\t\tnewContext.querySelectorAll( newSelector )\n\t\t\t\t\t\t);\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t} catch ( qsaError ) {\n\t\t\t\t\t} finally {\n\t\t\t\t\t\tif ( nid === expando ) {\n\t\t\t\t\t\t\tcontext.removeAttribute( \"id\" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// All others\n\treturn select( selector.replace( rtrim, \"$1\" ), context, results, seed );\n}\n\n/**\n * Create key-value caches of limited size\n * @returns {function(string, object)} Returns the Object data after storing it on itself with\n *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\n *\tdeleting the oldest entry\n */\nfunction createCache() {\n\tvar keys = [];\n\n\tfunction cache( key, value ) {\n\t\t// Use (key + \" \") to avoid collision with native prototype properties (see Issue #157)\n\t\tif ( keys.push( key + \" \" ) > Expr.cacheLength ) {\n\t\t\t// Only keep the most recent entries\n\t\t\tdelete cache[ keys.shift() ];\n\t\t}\n\t\treturn (cache[ key + \" \" ] = value);\n\t}\n\treturn cache;\n}\n\n/**\n * Mark a function for special use by Sizzle\n * @param {Function} fn The function to mark\n */\nfunction markFunction( fn ) {\n\tfn[ expando ] = true;\n\treturn fn;\n}\n\n/**\n * Support testing using an element\n * @param {Function} fn Passed the created element and returns a boolean result\n */\nfunction assert( fn ) {\n\tvar el = document.createElement(\"fieldset\");\n\n\ttry {\n\t\treturn !!fn( el );\n\t} catch (e) {\n\t\treturn false;\n\t} finally {\n\t\t// Remove from its parent by default\n\t\tif ( el.parentNode ) {\n\t\t\tel.parentNode.removeChild( el );\n\t\t}\n\t\t// release memory in IE\n\t\tel = null;\n\t}\n}\n\n/**\n * Adds the same handler for all of the specified attrs\n * @param {String} attrs Pipe-separated list of attributes\n * @param {Function} handler The method that will be applied\n */\nfunction addHandle( attrs, handler ) {\n\tvar arr = attrs.split(\"|\"),\n\t\ti = arr.length;\n\n\twhile ( i-- ) {\n\t\tExpr.attrHandle[ arr[i] ] = handler;\n\t}\n}\n\n/**\n * Checks document order of two siblings\n * @param {Element} a\n * @param {Element} b\n * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b\n */\nfunction siblingCheck( a, b ) {\n\tvar cur = b && a,\n\t\tdiff = cur && a.nodeType === 1 && b.nodeType === 1 &&\n\t\t\ta.sourceIndex - b.sourceIndex;\n\n\t// Use IE sourceIndex if available on both nodes\n\tif ( diff ) {\n\t\treturn diff;\n\t}\n\n\t// Check if b follows a\n\tif ( cur ) {\n\t\twhile ( (cur = cur.nextSibling) ) {\n\t\t\tif ( cur === b ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn a ? 1 : -1;\n}\n\n/**\n * Returns a function to use in pseudos for input types\n * @param {String} type\n */\nfunction createInputPseudo( type ) {\n\treturn function( elem ) {\n\t\tvar name = elem.nodeName.toLowerCase();\n\t\treturn name === \"input\" && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for buttons\n * @param {String} type\n */\nfunction createButtonPseudo( type ) {\n\treturn function( elem ) {\n\t\tvar name = elem.nodeName.toLowerCase();\n\t\treturn (name === \"input\" || name === \"button\") && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for :enabled/:disabled\n * @param {Boolean} disabled true for :disabled; false for :enabled\n */\nfunction createDisabledPseudo( disabled ) {\n\n\t// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable\n\treturn function( elem ) {\n\n\t\t// Only certain elements can match :enabled or :disabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled\n\t\tif ( \"form\" in elem ) {\n\n\t\t\t// Check for inherited disabledness on relevant non-disabled elements:\n\t\t\t// * listed form-associated elements in a disabled fieldset\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#category-listed\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled\n\t\t\t// * option elements in a disabled optgroup\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled\n\t\t\t// All such elements have a \"form\" property.\n\t\t\tif ( elem.parentNode && elem.disabled === false ) {\n\n\t\t\t\t// Option elements defer to a parent optgroup if present\n\t\t\t\tif ( \"label\" in elem ) {\n\t\t\t\t\tif ( \"label\" in elem.parentNode ) {\n\t\t\t\t\t\treturn elem.parentNode.disabled === disabled;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn elem.disabled === disabled;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Support: IE 6 - 11\n\t\t\t\t// Use the isDisabled shortcut property to check for disabled fieldset ancestors\n\t\t\t\treturn elem.isDisabled === disabled ||\n\n\t\t\t\t\t// Where there is no isDisabled, check manually\n\t\t\t\t\t/* jshint -W018 */\n\t\t\t\t\telem.isDisabled !== !disabled &&\n\t\t\t\t\t\tdisabledAncestor( elem ) === disabled;\n\t\t\t}\n\n\t\t\treturn elem.disabled === disabled;\n\n\t\t// Try to winnow out elements that can't be disabled before trusting the disabled property.\n\t\t// Some victims get caught in our net (label, legend, menu, track), but it shouldn't\n\t\t// even exist on them, let alone have a boolean value.\n\t\t} else if ( \"label\" in elem ) {\n\t\t\treturn elem.disabled === disabled;\n\t\t}\n\n\t\t// Remaining elements are neither :enabled nor :disabled\n\t\treturn false;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for positionals\n * @param {Function} fn\n */\nfunction createPositionalPseudo( fn ) {\n\treturn markFunction(function( argument ) {\n\t\targument = +argument;\n\t\treturn markFunction(function( seed, matches ) {\n\t\t\tvar j,\n\t\t\t\tmatchIndexes = fn( [], seed.length, argument ),\n\t\t\t\ti = matchIndexes.length;\n\n\t\t\t// Match elements found at the specified indexes\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( seed[ (j = matchIndexes[i]) ] ) {\n\t\t\t\t\tseed[j] = !(matches[j] = seed[j]);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t});\n}\n\n/**\n * Checks a node for validity as a Sizzle context\n * @param {Element|Object=} context\n * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n */\nfunction testContext( context ) {\n\treturn context && typeof context.getElementsByTagName !== \"undefined\" && context;\n}\n\n// Expose support vars for convenience\nsupport = Sizzle.support = {};\n\n/**\n * Detects XML nodes\n * @param {Element|Object} elem An element or a document\n * @returns {Boolean} True iff elem is a non-HTML XML node\n */\nisXML = Sizzle.isXML = function( elem ) {\n\t// documentElement is verified for cases where it doesn't yet exist\n\t// (such as loading iframes in IE - #4833)\n\tvar documentElement = elem && (elem.ownerDocument || elem).documentElement;\n\treturn documentElement ? documentElement.nodeName !== \"HTML\" : false;\n};\n\n/**\n * Sets document-related variables once based on the current document\n * @param {Element|Object} [doc] An element or document object to use to set the document\n * @returns {Object} Returns the current document\n */\nsetDocument = Sizzle.setDocument = function( node ) {\n\tvar hasCompare, subWindow,\n\t\tdoc = node ? node.ownerDocument || node : preferredDoc;\n\n\t// Return early if doc is invalid or already selected\n\tif ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {\n\t\treturn document;\n\t}\n\n\t// Update global variables\n\tdocument = doc;\n\tdocElem = document.documentElement;\n\tdocumentIsHTML = !isXML( document );\n\n\t// Support: IE 9-11, Edge\n\t// Accessing iframe documents after unload throws \"permission denied\" errors (jQuery #13936)\n\tif ( preferredDoc !== document &&\n\t\t(subWindow = document.defaultView) && subWindow.top !== subWindow ) {\n\n\t\t// Support: IE 11, Edge\n\t\tif ( subWindow.addEventListener ) {\n\t\t\tsubWindow.addEventListener( \"unload\", unloadHandler, false );\n\n\t\t// Support: IE 9 - 10 only\n\t\t} else if ( subWindow.attachEvent ) {\n\t\t\tsubWindow.attachEvent( \"onunload\", unloadHandler );\n\t\t}\n\t}\n\n\t/* Attributes\n\t---------------------------------------------------------------------- */\n\n\t// Support: IE<8\n\t// Verify that getAttribute really returns attributes and not properties\n\t// (excepting IE8 booleans)\n\tsupport.attributes = assert(function( el ) {\n\t\tel.className = \"i\";\n\t\treturn !el.getAttribute(\"className\");\n\t});\n\n\t/* getElement(s)By*\n\t---------------------------------------------------------------------- */\n\n\t// Check if getElementsByTagName(\"*\") returns only elements\n\tsupport.getElementsByTagName = assert(function( el ) {\n\t\tel.appendChild( document.createComment(\"\") );\n\t\treturn !el.getElementsByTagName(\"*\").length;\n\t});\n\n\t// Support: IE<9\n\tsupport.getElementsByClassName = rnative.test( document.getElementsByClassName );\n\n\t// Support: IE<10\n\t// Check if getElementById returns elements by name\n\t// The broken getElementById methods don't pick up programmatically-set names,\n\t// so use a roundabout getElementsByName test\n\tsupport.getById = assert(function( el ) {\n\t\tdocElem.appendChild( el ).id = expando;\n\t\treturn !document.getElementsByName || !document.getElementsByName( expando ).length;\n\t});\n\n\t// ID filter and find\n\tif ( support.getById ) {\n\t\tExpr.filter[\"ID\"] = function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn elem.getAttribute(\"id\") === attrId;\n\t\t\t};\n\t\t};\n\t\tExpr.find[\"ID\"] = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar elem = context.getElementById( id );\n\t\t\t\treturn elem ? [ elem ] : [];\n\t\t\t}\n\t\t};\n\t} else {\n\t\tExpr.filter[\"ID\"] =  function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\tvar node = typeof elem.getAttributeNode !== \"undefined\" &&\n\t\t\t\t\telem.getAttributeNode(\"id\");\n\t\t\t\treturn node && node.value === attrId;\n\t\t\t};\n\t\t};\n\n\t\t// Support: IE 6 - 7 only\n\t\t// getElementById is not reliable as a find shortcut\n\t\tExpr.find[\"ID\"] = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar node, i, elems,\n\t\t\t\t\telem = context.getElementById( id );\n\n\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t// Verify the id attribute\n\t\t\t\t\tnode = elem.getAttributeNode(\"id\");\n\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t}\n\n\t\t\t\t\t// Fall back on getElementsByName\n\t\t\t\t\telems = context.getElementsByName( id );\n\t\t\t\t\ti = 0;\n\t\t\t\t\twhile ( (elem = elems[i++]) ) {\n\t\t\t\t\t\tnode = elem.getAttributeNode(\"id\");\n\t\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn [];\n\t\t\t}\n\t\t};\n\t}\n\n\t// Tag\n\tExpr.find[\"TAG\"] = support.getElementsByTagName ?\n\t\tfunction( tag, context ) {\n\t\t\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\t\t\treturn context.getElementsByTagName( tag );\n\n\t\t\t// DocumentFragment nodes don't have gEBTN\n\t\t\t} else if ( support.qsa ) {\n\t\t\t\treturn context.querySelectorAll( tag );\n\t\t\t}\n\t\t} :\n\n\t\tfunction( tag, context ) {\n\t\t\tvar elem,\n\t\t\t\ttmp = [],\n\t\t\t\ti = 0,\n\t\t\t\t// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too\n\t\t\t\tresults = context.getElementsByTagName( tag );\n\n\t\t\t// Filter out possible comments\n\t\t\tif ( tag === \"*\" ) {\n\t\t\t\twhile ( (elem = results[i++]) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\ttmp.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn tmp;\n\t\t\t}\n\t\t\treturn results;\n\t\t};\n\n\t// Class\n\tExpr.find[\"CLASS\"] = support.getElementsByClassName && function( className, context ) {\n\t\tif ( typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML ) {\n\t\t\treturn context.getElementsByClassName( className );\n\t\t}\n\t};\n\n\t/* QSA/matchesSelector\n\t---------------------------------------------------------------------- */\n\n\t// QSA and matchesSelector support\n\n\t// matchesSelector(:active) reports false when true (IE9/Opera 11.5)\n\trbuggyMatches = [];\n\n\t// qSa(:focus) reports false when true (Chrome 21)\n\t// We allow this because of a bug in IE8/9 that throws an error\n\t// whenever `document.activeElement` is accessed on an iframe\n\t// So, we allow :focus to pass through QSA all the time to avoid the IE error\n\t// See https://bugs.jquery.com/ticket/13378\n\trbuggyQSA = [];\n\n\tif ( (support.qsa = rnative.test( document.querySelectorAll )) ) {\n\t\t// Build QSA regex\n\t\t// Regex strategy adopted from Diego Perini\n\t\tassert(function( el ) {\n\t\t\t// Select is set to empty string on purpose\n\t\t\t// This is to test IE's treatment of not explicitly\n\t\t\t// setting a boolean content attribute,\n\t\t\t// since its presence should be enough\n\t\t\t// https://bugs.jquery.com/ticket/12359\n\t\t\tdocElem.appendChild( el ).innerHTML = \"<a id='\" + expando + \"'></a>\" +\n\t\t\t\t\"<select id='\" + expando + \"-\\r\\\\' msallowcapture=''>\" +\n\t\t\t\t\"<option selected=''></option></select>\";\n\n\t\t\t// Support: IE8, Opera 11-12.16\n\t\t\t// Nothing should be selected when empty strings follow ^= or $= or *=\n\t\t\t// The test attribute must be unknown in Opera but \"safe\" for WinRT\n\t\t\t// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section\n\t\t\tif ( el.querySelectorAll(\"[msallowcapture^='']\").length ) {\n\t\t\t\trbuggyQSA.push( \"[*^$]=\" + whitespace + \"*(?:''|\\\"\\\")\" );\n\t\t\t}\n\n\t\t\t// Support: IE8\n\t\t\t// Boolean attributes and \"value\" are not treated correctly\n\t\t\tif ( !el.querySelectorAll(\"[selected]\").length ) {\n\t\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\" );\n\t\t\t}\n\n\t\t\t// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+\n\t\t\tif ( !el.querySelectorAll( \"[id~=\" + expando + \"-]\" ).length ) {\n\t\t\t\trbuggyQSA.push(\"~=\");\n\t\t\t}\n\n\t\t\t// Webkit/Opera - :checked should return selected option elements\n\t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\t// IE8 throws error here and will not see later tests\n\t\t\tif ( !el.querySelectorAll(\":checked\").length ) {\n\t\t\t\trbuggyQSA.push(\":checked\");\n\t\t\t}\n\n\t\t\t// Support: Safari 8+, iOS 8+\n\t\t\t// https://bugs.webkit.org/show_bug.cgi?id=136851\n\t\t\t// In-page `selector#id sibling-combinator selector` fails\n\t\t\tif ( !el.querySelectorAll( \"a#\" + expando + \"+*\" ).length ) {\n\t\t\t\trbuggyQSA.push(\".#.+[+~]\");\n\t\t\t}\n\t\t});\n\n\t\tassert(function( el ) {\n\t\t\tel.innerHTML = \"<a href='' disabled='disabled'></a>\" +\n\t\t\t\t\"<select disabled='disabled'><option/></select>\";\n\n\t\t\t// Support: Windows 8 Native Apps\n\t\t\t// The type and name attributes are restricted during .innerHTML assignment\n\t\t\tvar input = document.createElement(\"input\");\n\t\t\tinput.setAttribute( \"type\", \"hidden\" );\n\t\t\tel.appendChild( input ).setAttribute( \"name\", \"D\" );\n\n\t\t\t// Support: IE8\n\t\t\t// Enforce case-sensitivity of name attribute\n\t\t\tif ( el.querySelectorAll(\"[name=d]\").length ) {\n\t\t\t\trbuggyQSA.push( \"name\" + whitespace + \"*[*^$|!~]?=\" );\n\t\t\t}\n\n\t\t\t// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)\n\t\t\t// IE8 throws error here and will not see later tests\n\t\t\tif ( el.querySelectorAll(\":enabled\").length !== 2 ) {\n\t\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t\t}\n\n\t\t\t// Support: IE9-11+\n\t\t\t// IE's :disabled selector does not pick up the children of disabled fieldsets\n\t\t\tdocElem.appendChild( el ).disabled = true;\n\t\t\tif ( el.querySelectorAll(\":disabled\").length !== 2 ) {\n\t\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t\t}\n\n\t\t\t// Opera 10-11 does not throw on post-comma invalid pseudos\n\t\t\tel.querySelectorAll(\"*,:x\");\n\t\t\trbuggyQSA.push(\",.*:\");\n\t\t});\n\t}\n\n\tif ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||\n\t\tdocElem.webkitMatchesSelector ||\n\t\tdocElem.mozMatchesSelector ||\n\t\tdocElem.oMatchesSelector ||\n\t\tdocElem.msMatchesSelector) )) ) {\n\n\t\tassert(function( el ) {\n\t\t\t// Check to see if it's possible to do matchesSelector\n\t\t\t// on a disconnected node (IE 9)\n\t\t\tsupport.disconnectedMatch = matches.call( el, \"*\" );\n\n\t\t\t// This should fail with an exception\n\t\t\t// Gecko does not error, returns false instead\n\t\t\tmatches.call( el, \"[s!='']:x\" );\n\t\t\trbuggyMatches.push( \"!=\", pseudos );\n\t\t});\n\t}\n\n\trbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join(\"|\") );\n\trbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join(\"|\") );\n\n\t/* Contains\n\t---------------------------------------------------------------------- */\n\thasCompare = rnative.test( docElem.compareDocumentPosition );\n\n\t// Element contains another\n\t// Purposefully self-exclusive\n\t// As in, an element does not contain itself\n\tcontains = hasCompare || rnative.test( docElem.contains ) ?\n\t\tfunction( a, b ) {\n\t\t\tvar adown = a.nodeType === 9 ? a.documentElement : a,\n\t\t\t\tbup = b && b.parentNode;\n\t\t\treturn a === bup || !!( bup && bup.nodeType === 1 && (\n\t\t\t\tadown.contains ?\n\t\t\t\t\tadown.contains( bup ) :\n\t\t\t\t\ta.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\n\t\t\t));\n\t\t} :\n\t\tfunction( a, b ) {\n\t\t\tif ( b ) {\n\t\t\t\twhile ( (b = b.parentNode) ) {\n\t\t\t\t\tif ( b === a ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n\n\t/* Sorting\n\t---------------------------------------------------------------------- */\n\n\t// Document order sorting\n\tsortOrder = hasCompare ?\n\tfunction( a, b ) {\n\n\t\t// Flag for duplicate removal\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\t// Sort on method existence if only one input has compareDocumentPosition\n\t\tvar compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\t\tif ( compare ) {\n\t\t\treturn compare;\n\t\t}\n\n\t\t// Calculate position if both inputs belong to the same document\n\t\tcompare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?\n\t\t\ta.compareDocumentPosition( b ) :\n\n\t\t\t// Otherwise we know they are disconnected\n\t\t\t1;\n\n\t\t// Disconnected nodes\n\t\tif ( compare & 1 ||\n\t\t\t(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {\n\n\t\t\t// Choose the first element that is related to our preferred document\n\t\t\tif ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t\tif ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {\n\t\t\t\treturn 1;\n\t\t\t}\n\n\t\t\t// Maintain original order\n\t\t\treturn sortInput ?\n\t\t\t\t( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\n\t\t\t\t0;\n\t\t}\n\n\t\treturn compare & 4 ? -1 : 1;\n\t} :\n\tfunction( a, b ) {\n\t\t// Exit early if the nodes are identical\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\taup = a.parentNode,\n\t\t\tbup = b.parentNode,\n\t\t\tap = [ a ],\n\t\t\tbp = [ b ];\n\n\t\t// Parentless nodes are either documents or disconnected\n\t\tif ( !aup || !bup ) {\n\t\t\treturn a === document ? -1 :\n\t\t\t\tb === document ? 1 :\n\t\t\t\taup ? -1 :\n\t\t\t\tbup ? 1 :\n\t\t\t\tsortInput ?\n\t\t\t\t( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\n\t\t\t\t0;\n\n\t\t// If the nodes are siblings, we can do a quick check\n\t\t} else if ( aup === bup ) {\n\t\t\treturn siblingCheck( a, b );\n\t\t}\n\n\t\t// Otherwise we need full lists of their ancestors for comparison\n\t\tcur = a;\n\t\twhile ( (cur = cur.parentNode) ) {\n\t\t\tap.unshift( cur );\n\t\t}\n\t\tcur = b;\n\t\twhile ( (cur = cur.parentNode) ) {\n\t\t\tbp.unshift( cur );\n\t\t}\n\n\t\t// Walk down the tree looking for a discrepancy\n\t\twhile ( ap[i] === bp[i] ) {\n\t\t\ti++;\n\t\t}\n\n\t\treturn i ?\n\t\t\t// Do a sibling check if the nodes have a common ancestor\n\t\t\tsiblingCheck( ap[i], bp[i] ) :\n\n\t\t\t// Otherwise nodes in our document sort first\n\t\t\tap[i] === preferredDoc ? -1 :\n\t\t\tbp[i] === preferredDoc ? 1 :\n\t\t\t0;\n\t};\n\n\treturn document;\n};\n\nSizzle.matches = function( expr, elements ) {\n\treturn Sizzle( expr, null, null, elements );\n};\n\nSizzle.matchesSelector = function( elem, expr ) {\n\t// Set document vars if needed\n\tif ( ( elem.ownerDocument || elem ) !== document ) {\n\t\tsetDocument( elem );\n\t}\n\n\t// Make sure that attribute selectors are quoted\n\texpr = expr.replace( rattributeQuotes, \"='$1']\" );\n\n\tif ( support.matchesSelector && documentIsHTML &&\n\t\t!compilerCache[ expr + \" \" ] &&\n\t\t( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&\n\t\t( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {\n\n\t\ttry {\n\t\t\tvar ret = matches.call( elem, expr );\n\n\t\t\t// IE 9's matchesSelector returns false on disconnected nodes\n\t\t\tif ( ret || support.disconnectedMatch ||\n\t\t\t\t\t// As well, disconnected nodes are said to be in a document\n\t\t\t\t\t// fragment in IE 9\n\t\t\t\t\telem.document && elem.document.nodeType !== 11 ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\t\t} catch (e) {}\n\t}\n\n\treturn Sizzle( expr, document, null, [ elem ] ).length > 0;\n};\n\nSizzle.contains = function( context, elem ) {\n\t// Set document vars if needed\n\tif ( ( context.ownerDocument || context ) !== document ) {\n\t\tsetDocument( context );\n\t}\n\treturn contains( context, elem );\n};\n\nSizzle.attr = function( elem, name ) {\n\t// Set document vars if needed\n\tif ( ( elem.ownerDocument || elem ) !== document ) {\n\t\tsetDocument( elem );\n\t}\n\n\tvar fn = Expr.attrHandle[ name.toLowerCase() ],\n\t\t// Don't get fooled by Object.prototype properties (jQuery #13807)\n\t\tval = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?\n\t\t\tfn( elem, name, !documentIsHTML ) :\n\t\t\tundefined;\n\n\treturn val !== undefined ?\n\t\tval :\n\t\tsupport.attributes || !documentIsHTML ?\n\t\t\telem.getAttribute( name ) :\n\t\t\t(val = elem.getAttributeNode(name)) && val.specified ?\n\t\t\t\tval.value :\n\t\t\t\tnull;\n};\n\nSizzle.escape = function( sel ) {\n\treturn (sel + \"\").replace( rcssescape, fcssescape );\n};\n\nSizzle.error = function( msg ) {\n\tthrow new Error( \"Syntax error, unrecognized expression: \" + msg );\n};\n\n/**\n * Document sorting and removing duplicates\n * @param {ArrayLike} results\n */\nSizzle.uniqueSort = function( results ) {\n\tvar elem,\n\t\tduplicates = [],\n\t\tj = 0,\n\t\ti = 0;\n\n\t// Unless we *know* we can detect duplicates, assume their presence\n\thasDuplicate = !support.detectDuplicates;\n\tsortInput = !support.sortStable && results.slice( 0 );\n\tresults.sort( sortOrder );\n\n\tif ( hasDuplicate ) {\n\t\twhile ( (elem = results[i++]) ) {\n\t\t\tif ( elem === results[ i ] ) {\n\t\t\t\tj = duplicates.push( i );\n\t\t\t}\n\t\t}\n\t\twhile ( j-- ) {\n\t\t\tresults.splice( duplicates[ j ], 1 );\n\t\t}\n\t}\n\n\t// Clear input after sorting to release objects\n\t// See https://github.com/jquery/sizzle/pull/225\n\tsortInput = null;\n\n\treturn results;\n};\n\n/**\n * Utility function for retrieving the text value of an array of DOM nodes\n * @param {Array|Element} elem\n */\ngetText = Sizzle.getText = function( elem ) {\n\tvar node,\n\t\tret = \"\",\n\t\ti = 0,\n\t\tnodeType = elem.nodeType;\n\n\tif ( !nodeType ) {\n\t\t// If no nodeType, this is expected to be an array\n\t\twhile ( (node = elem[i++]) ) {\n\t\t\t// Do not traverse comment nodes\n\t\t\tret += getText( node );\n\t\t}\n\t} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {\n\t\t// Use textContent for elements\n\t\t// innerText usage removed for consistency of new lines (jQuery #11153)\n\t\tif ( typeof elem.textContent === \"string\" ) {\n\t\t\treturn elem.textContent;\n\t\t} else {\n\t\t\t// Traverse its children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tret += getText( elem );\n\t\t\t}\n\t\t}\n\t} else if ( nodeType === 3 || nodeType === 4 ) {\n\t\treturn elem.nodeValue;\n\t}\n\t// Do not include comment or processing instruction nodes\n\n\treturn ret;\n};\n\nExpr = Sizzle.selectors = {\n\n\t// Can be adjusted by the user\n\tcacheLength: 50,\n\n\tcreatePseudo: markFunction,\n\n\tmatch: matchExpr,\n\n\tattrHandle: {},\n\n\tfind: {},\n\n\trelative: {\n\t\t\">\": { dir: \"parentNode\", first: true },\n\t\t\" \": { dir: \"parentNode\" },\n\t\t\"+\": { dir: \"previousSibling\", first: true },\n\t\t\"~\": { dir: \"previousSibling\" }\n\t},\n\n\tpreFilter: {\n\t\t\"ATTR\": function( match ) {\n\t\t\tmatch[1] = match[1].replace( runescape, funescape );\n\n\t\t\t// Move the given value to match[3] whether quoted or unquoted\n\t\t\tmatch[3] = ( match[3] || match[4] || match[5] || \"\" ).replace( runescape, funescape );\n\n\t\t\tif ( match[2] === \"~=\" ) {\n\t\t\t\tmatch[3] = \" \" + match[3] + \" \";\n\t\t\t}\n\n\t\t\treturn match.slice( 0, 4 );\n\t\t},\n\n\t\t\"CHILD\": function( match ) {\n\t\t\t/* matches from matchExpr[\"CHILD\"]\n\t\t\t\t1 type (only|nth|...)\n\t\t\t\t2 what (child|of-type)\n\t\t\t\t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n\t\t\t\t4 xn-component of xn+y argument ([+-]?\\d*n|)\n\t\t\t\t5 sign of xn-component\n\t\t\t\t6 x of xn-component\n\t\t\t\t7 sign of y-component\n\t\t\t\t8 y of y-component\n\t\t\t*/\n\t\t\tmatch[1] = match[1].toLowerCase();\n\n\t\t\tif ( match[1].slice( 0, 3 ) === \"nth\" ) {\n\t\t\t\t// nth-* requires argument\n\t\t\t\tif ( !match[3] ) {\n\t\t\t\t\tSizzle.error( match[0] );\n\t\t\t\t}\n\n\t\t\t\t// numeric x and y parameters for Expr.filter.CHILD\n\t\t\t\t// remember that false/true cast respectively to 0/1\n\t\t\t\tmatch[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === \"even\" || match[3] === \"odd\" ) );\n\t\t\t\tmatch[5] = +( ( match[7] + match[8] ) || match[3] === \"odd\" );\n\n\t\t\t// other types prohibit arguments\n\t\t\t} else if ( match[3] ) {\n\t\t\t\tSizzle.error( match[0] );\n\t\t\t}\n\n\t\t\treturn match;\n\t\t},\n\n\t\t\"PSEUDO\": function( match ) {\n\t\t\tvar excess,\n\t\t\t\tunquoted = !match[6] && match[2];\n\n\t\t\tif ( matchExpr[\"CHILD\"].test( match[0] ) ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\t// Accept quoted arguments as-is\n\t\t\tif ( match[3] ) {\n\t\t\t\tmatch[2] = match[4] || match[5] || \"\";\n\n\t\t\t// Strip excess characters from unquoted arguments\n\t\t\t} else if ( unquoted && rpseudo.test( unquoted ) &&\n\t\t\t\t// Get excess from tokenize (recursively)\n\t\t\t\t(excess = tokenize( unquoted, true )) &&\n\t\t\t\t// advance to the next closing parenthesis\n\t\t\t\t(excess = unquoted.indexOf( \")\", unquoted.length - excess ) - unquoted.length) ) {\n\n\t\t\t\t// excess is a negative index\n\t\t\t\tmatch[0] = match[0].slice( 0, excess );\n\t\t\t\tmatch[2] = unquoted.slice( 0, excess );\n\t\t\t}\n\n\t\t\t// Return only captures needed by the pseudo filter method (type and argument)\n\t\t\treturn match.slice( 0, 3 );\n\t\t}\n\t},\n\n\tfilter: {\n\n\t\t\"TAG\": function( nodeNameSelector ) {\n\t\t\tvar nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn nodeNameSelector === \"*\" ?\n\t\t\t\tfunction() { return true; } :\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn elem.nodeName && elem.nodeName.toLowerCase() === nodeName;\n\t\t\t\t};\n\t\t},\n\n\t\t\"CLASS\": function( className ) {\n\t\t\tvar pattern = classCache[ className + \" \" ];\n\n\t\t\treturn pattern ||\n\t\t\t\t(pattern = new RegExp( \"(^|\" + whitespace + \")\" + className + \"(\" + whitespace + \"|$)\" )) &&\n\t\t\t\tclassCache( className, function( elem ) {\n\t\t\t\t\treturn pattern.test( typeof elem.className === \"string\" && elem.className || typeof elem.getAttribute !== \"undefined\" && elem.getAttribute(\"class\") || \"\" );\n\t\t\t\t});\n\t\t},\n\n\t\t\"ATTR\": function( name, operator, check ) {\n\t\t\treturn function( elem ) {\n\t\t\t\tvar result = Sizzle.attr( elem, name );\n\n\t\t\t\tif ( result == null ) {\n\t\t\t\t\treturn operator === \"!=\";\n\t\t\t\t}\n\t\t\t\tif ( !operator ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\n\t\t\t\tresult += \"\";\n\n\t\t\t\treturn operator === \"=\" ? result === check :\n\t\t\t\t\toperator === \"!=\" ? result !== check :\n\t\t\t\t\toperator === \"^=\" ? check && result.indexOf( check ) === 0 :\n\t\t\t\t\toperator === \"*=\" ? check && result.indexOf( check ) > -1 :\n\t\t\t\t\toperator === \"$=\" ? check && result.slice( -check.length ) === check :\n\t\t\t\t\toperator === \"~=\" ? ( \" \" + result.replace( rwhitespace, \" \" ) + \" \" ).indexOf( check ) > -1 :\n\t\t\t\t\toperator === \"|=\" ? result === check || result.slice( 0, check.length + 1 ) === check + \"-\" :\n\t\t\t\t\tfalse;\n\t\t\t};\n\t\t},\n\n\t\t\"CHILD\": function( type, what, argument, first, last ) {\n\t\t\tvar simple = type.slice( 0, 3 ) !== \"nth\",\n\t\t\t\tforward = type.slice( -4 ) !== \"last\",\n\t\t\t\tofType = what === \"of-type\";\n\n\t\t\treturn first === 1 && last === 0 ?\n\n\t\t\t\t// Shortcut for :nth-*(n)\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn !!elem.parentNode;\n\t\t\t\t} :\n\n\t\t\t\tfunction( elem, context, xml ) {\n\t\t\t\t\tvar cache, uniqueCache, outerCache, node, nodeIndex, start,\n\t\t\t\t\t\tdir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n\t\t\t\t\t\tparent = elem.parentNode,\n\t\t\t\t\t\tname = ofType && elem.nodeName.toLowerCase(),\n\t\t\t\t\t\tuseCache = !xml && !ofType,\n\t\t\t\t\t\tdiff = false;\n\n\t\t\t\t\tif ( parent ) {\n\n\t\t\t\t\t\t// :(first|last|only)-(child|of-type)\n\t\t\t\t\t\tif ( simple ) {\n\t\t\t\t\t\t\twhile ( dir ) {\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\twhile ( (node = node[ dir ]) ) {\n\t\t\t\t\t\t\t\t\tif ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnode.nodeName.toLowerCase() === name :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) {\n\n\t\t\t\t\t\t\t\t\t\treturn false;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t// Reverse direction for :only-* (if we haven't yet done so)\n\t\t\t\t\t\t\t\tstart = dir = type === \"only\" && !start && \"nextSibling\";\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tstart = [ forward ? parent.firstChild : parent.lastChild ];\n\n\t\t\t\t\t\t// non-xml :nth-child(...) stores cache data on `parent`\n\t\t\t\t\t\tif ( forward && useCache ) {\n\n\t\t\t\t\t\t\t// Seek `elem` from a previously-cached index\n\n\t\t\t\t\t\t\t// ...in a gzip-friendly way\n\t\t\t\t\t\t\tnode = parent;\n\t\t\t\t\t\t\touterCache = node[ expando ] || (node[ expando ] = {});\n\n\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t(outerCache[ node.uniqueID ] = {});\n\n\t\t\t\t\t\t\tcache = uniqueCache[ type ] || [];\n\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\tdiff = nodeIndex && cache[ 2 ];\n\t\t\t\t\t\t\tnode = nodeIndex && parent.childNodes[ nodeIndex ];\n\n\t\t\t\t\t\t\twhile ( (node = ++nodeIndex && node && node[ dir ] ||\n\n\t\t\t\t\t\t\t\t// Fallback to seeking `elem` from the start\n\t\t\t\t\t\t\t\t(diff = nodeIndex = 0) || start.pop()) ) {\n\n\t\t\t\t\t\t\t\t// When found, cache indexes on `parent` and break\n\t\t\t\t\t\t\t\tif ( node.nodeType === 1 && ++diff && node === elem ) {\n\t\t\t\t\t\t\t\t\tuniqueCache[ type ] = [ dirruns, nodeIndex, diff ];\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// Use previously-cached element index if available\n\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t// ...in a gzip-friendly way\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\touterCache = node[ expando ] || (node[ expando ] = {});\n\n\t\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t\t(outerCache[ node.uniqueID ] = {});\n\n\t\t\t\t\t\t\t\tcache = uniqueCache[ type ] || [];\n\t\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\t\tdiff = nodeIndex;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// xml :nth-child(...)\n\t\t\t\t\t\t\t// or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\t\t\t\t\t\t\tif ( diff === false ) {\n\t\t\t\t\t\t\t\t// Use the same loop as above to seek `elem` from the start\n\t\t\t\t\t\t\t\twhile ( (node = ++nodeIndex && node && node[ dir ] ||\n\t\t\t\t\t\t\t\t\t(diff = nodeIndex = 0) || start.pop()) ) {\n\n\t\t\t\t\t\t\t\t\tif ( ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnode.nodeName.toLowerCase() === name :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) &&\n\t\t\t\t\t\t\t\t\t\t++diff ) {\n\n\t\t\t\t\t\t\t\t\t\t// Cache the index of each encountered element\n\t\t\t\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t\t\t\touterCache = node[ expando ] || (node[ expando ] = {});\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t(outerCache[ node.uniqueID ] = {});\n\n\t\t\t\t\t\t\t\t\t\t\tuniqueCache[ type ] = [ dirruns, diff ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\tif ( node === elem ) {\n\t\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Incorporate the offset, then check against cycle size\n\t\t\t\t\t\tdiff -= last;\n\t\t\t\t\t\treturn diff === first || ( diff % first === 0 && diff / first >= 0 );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t},\n\n\t\t\"PSEUDO\": function( pseudo, argument ) {\n\t\t\t// pseudo-class names are case-insensitive\n\t\t\t// http://www.w3.org/TR/selectors/#pseudo-classes\n\t\t\t// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n\t\t\t// Remember that setFilters inherits from pseudos\n\t\t\tvar args,\n\t\t\t\tfn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||\n\t\t\t\t\tSizzle.error( \"unsupported pseudo: \" + pseudo );\n\n\t\t\t// The user may use createPseudo to indicate that\n\t\t\t// arguments are needed to create the filter function\n\t\t\t// just as Sizzle does\n\t\t\tif ( fn[ expando ] ) {\n\t\t\t\treturn fn( argument );\n\t\t\t}\n\n\t\t\t// But maintain support for old signatures\n\t\t\tif ( fn.length > 1 ) {\n\t\t\t\targs = [ pseudo, pseudo, \"\", argument ];\n\t\t\t\treturn Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?\n\t\t\t\t\tmarkFunction(function( seed, matches ) {\n\t\t\t\t\t\tvar idx,\n\t\t\t\t\t\t\tmatched = fn( seed, argument ),\n\t\t\t\t\t\t\ti = matched.length;\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tidx = indexOf( seed, matched[i] );\n\t\t\t\t\t\t\tseed[ idx ] = !( matches[ idx ] = matched[i] );\n\t\t\t\t\t\t}\n\t\t\t\t\t}) :\n\t\t\t\t\tfunction( elem ) {\n\t\t\t\t\t\treturn fn( elem, 0, args );\n\t\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn fn;\n\t\t}\n\t},\n\n\tpseudos: {\n\t\t// Potentially complex pseudos\n\t\t\"not\": markFunction(function( selector ) {\n\t\t\t// Trim the selector passed to compile\n\t\t\t// to avoid treating leading and trailing\n\t\t\t// spaces as combinators\n\t\t\tvar input = [],\n\t\t\t\tresults = [],\n\t\t\t\tmatcher = compile( selector.replace( rtrim, \"$1\" ) );\n\n\t\t\treturn matcher[ expando ] ?\n\t\t\t\tmarkFunction(function( seed, matches, context, xml ) {\n\t\t\t\t\tvar elem,\n\t\t\t\t\t\tunmatched = matcher( seed, null, xml, [] ),\n\t\t\t\t\t\ti = seed.length;\n\n\t\t\t\t\t// Match elements unmatched by `matcher`\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( (elem = unmatched[i]) ) {\n\t\t\t\t\t\t\tseed[i] = !(matches[i] = elem);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}) :\n\t\t\t\tfunction( elem, context, xml ) {\n\t\t\t\t\tinput[0] = elem;\n\t\t\t\t\tmatcher( input, null, xml, results );\n\t\t\t\t\t// Don't keep the element (issue #299)\n\t\t\t\t\tinput[0] = null;\n\t\t\t\t\treturn !results.pop();\n\t\t\t\t};\n\t\t}),\n\n\t\t\"has\": markFunction(function( selector ) {\n\t\t\treturn function( elem ) {\n\t\t\t\treturn Sizzle( selector, elem ).length > 0;\n\t\t\t};\n\t\t}),\n\n\t\t\"contains\": markFunction(function( text ) {\n\t\t\ttext = text.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;\n\t\t\t};\n\t\t}),\n\n\t\t// \"Whether an element is represented by a :lang() selector\n\t\t// is based solely on the element's language value\n\t\t// being equal to the identifier C,\n\t\t// or beginning with the identifier C immediately followed by \"-\".\n\t\t// The matching of C against the element's language value is performed case-insensitively.\n\t\t// The identifier C does not have to be a valid language name.\"\n\t\t// http://www.w3.org/TR/selectors/#lang-pseudo\n\t\t\"lang\": markFunction( function( lang ) {\n\t\t\t// lang value must be a valid identifier\n\t\t\tif ( !ridentifier.test(lang || \"\") ) {\n\t\t\t\tSizzle.error( \"unsupported lang: \" + lang );\n\t\t\t}\n\t\t\tlang = lang.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn function( elem ) {\n\t\t\t\tvar elemLang;\n\t\t\t\tdo {\n\t\t\t\t\tif ( (elemLang = documentIsHTML ?\n\t\t\t\t\t\telem.lang :\n\t\t\t\t\t\telem.getAttribute(\"xml:lang\") || elem.getAttribute(\"lang\")) ) {\n\n\t\t\t\t\t\telemLang = elemLang.toLowerCase();\n\t\t\t\t\t\treturn elemLang === lang || elemLang.indexOf( lang + \"-\" ) === 0;\n\t\t\t\t\t}\n\t\t\t\t} while ( (elem = elem.parentNode) && elem.nodeType === 1 );\n\t\t\t\treturn false;\n\t\t\t};\n\t\t}),\n\n\t\t// Miscellaneous\n\t\t\"target\": function( elem ) {\n\t\t\tvar hash = window.location && window.location.hash;\n\t\t\treturn hash && hash.slice( 1 ) === elem.id;\n\t\t},\n\n\t\t\"root\": function( elem ) {\n\t\t\treturn elem === docElem;\n\t\t},\n\n\t\t\"focus\": function( elem ) {\n\t\t\treturn elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);\n\t\t},\n\n\t\t// Boolean properties\n\t\t\"enabled\": createDisabledPseudo( false ),\n\t\t\"disabled\": createDisabledPseudo( true ),\n\n\t\t\"checked\": function( elem ) {\n\t\t\t// In CSS3, :checked should return both checked and selected elements\n\t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\tvar nodeName = elem.nodeName.toLowerCase();\n\t\t\treturn (nodeName === \"input\" && !!elem.checked) || (nodeName === \"option\" && !!elem.selected);\n\t\t},\n\n\t\t\"selected\": function( elem ) {\n\t\t\t// Accessing this property makes selected-by-default\n\t\t\t// options in Safari work properly\n\t\t\tif ( elem.parentNode ) {\n\t\t\t\telem.parentNode.selectedIndex;\n\t\t\t}\n\n\t\t\treturn elem.selected === true;\n\t\t},\n\n\t\t// Contents\n\t\t\"empty\": function( elem ) {\n\t\t\t// http://www.w3.org/TR/selectors/#empty-pseudo\n\t\t\t// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n\t\t\t//   but not by others (comment: 8; processing instruction: 7; etc.)\n\t\t\t// nodeType < 6 works because attributes (2) do not appear as children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tif ( elem.nodeType < 6 ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t},\n\n\t\t\"parent\": function( elem ) {\n\t\t\treturn !Expr.pseudos[\"empty\"]( elem );\n\t\t},\n\n\t\t// Element/input types\n\t\t\"header\": function( elem ) {\n\t\t\treturn rheader.test( elem.nodeName );\n\t\t},\n\n\t\t\"input\": function( elem ) {\n\t\t\treturn rinputs.test( elem.nodeName );\n\t\t},\n\n\t\t\"button\": function( elem ) {\n\t\t\tvar name = elem.nodeName.toLowerCase();\n\t\t\treturn name === \"input\" && elem.type === \"button\" || name === \"button\";\n\t\t},\n\n\t\t\"text\": function( elem ) {\n\t\t\tvar attr;\n\t\t\treturn elem.nodeName.toLowerCase() === \"input\" &&\n\t\t\t\telem.type === \"text\" &&\n\n\t\t\t\t// Support: IE<8\n\t\t\t\t// New HTML5 attribute values (e.g., \"search\") appear with elem.type === \"text\"\n\t\t\t\t( (attr = elem.getAttribute(\"type\")) == null || attr.toLowerCase() === \"text\" );\n\t\t},\n\n\t\t// Position-in-collection\n\t\t\"first\": createPositionalPseudo(function() {\n\t\t\treturn [ 0 ];\n\t\t}),\n\n\t\t\"last\": createPositionalPseudo(function( matchIndexes, length ) {\n\t\t\treturn [ length - 1 ];\n\t\t}),\n\n\t\t\"eq\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\t\t\treturn [ argument < 0 ? argument + length : argument ];\n\t\t}),\n\n\t\t\"even\": createPositionalPseudo(function( matchIndexes, length ) {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t}),\n\n\t\t\"odd\": createPositionalPseudo(function( matchIndexes, length ) {\n\t\t\tvar i = 1;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t}),\n\n\t\t\"lt\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; --i >= 0; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t}),\n\n\t\t\"gt\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; ++i < length; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t})\n\t}\n};\n\nExpr.pseudos[\"nth\"] = Expr.pseudos[\"eq\"];\n\n// Add button/input type pseudos\nfor ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {\n\tExpr.pseudos[ i ] = createInputPseudo( i );\n}\nfor ( i in { submit: true, reset: true } ) {\n\tExpr.pseudos[ i ] = createButtonPseudo( i );\n}\n\n// Easy API for creating new setFilters\nfunction setFilters() {}\nsetFilters.prototype = Expr.filters = Expr.pseudos;\nExpr.setFilters = new setFilters();\n\ntokenize = Sizzle.tokenize = function( selector, parseOnly ) {\n\tvar matched, match, tokens, type,\n\t\tsoFar, groups, preFilters,\n\t\tcached = tokenCache[ selector + \" \" ];\n\n\tif ( cached ) {\n\t\treturn parseOnly ? 0 : cached.slice( 0 );\n\t}\n\n\tsoFar = selector;\n\tgroups = [];\n\tpreFilters = Expr.preFilter;\n\n\twhile ( soFar ) {\n\n\t\t// Comma and first run\n\t\tif ( !matched || (match = rcomma.exec( soFar )) ) {\n\t\t\tif ( match ) {\n\t\t\t\t// Don't consume trailing commas as valid\n\t\t\t\tsoFar = soFar.slice( match[0].length ) || soFar;\n\t\t\t}\n\t\t\tgroups.push( (tokens = []) );\n\t\t}\n\n\t\tmatched = false;\n\n\t\t// Combinators\n\t\tif ( (match = rcombinators.exec( soFar )) ) {\n\t\t\tmatched = match.shift();\n\t\t\ttokens.push({\n\t\t\t\tvalue: matched,\n\t\t\t\t// Cast descendant combinators to space\n\t\t\t\ttype: match[0].replace( rtrim, \" \" )\n\t\t\t});\n\t\t\tsoFar = soFar.slice( matched.length );\n\t\t}\n\n\t\t// Filters\n\t\tfor ( type in Expr.filter ) {\n\t\t\tif ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||\n\t\t\t\t(match = preFilters[ type ]( match ))) ) {\n\t\t\t\tmatched = match.shift();\n\t\t\t\ttokens.push({\n\t\t\t\t\tvalue: matched,\n\t\t\t\t\ttype: type,\n\t\t\t\t\tmatches: match\n\t\t\t\t});\n\t\t\t\tsoFar = soFar.slice( matched.length );\n\t\t\t}\n\t\t}\n\n\t\tif ( !matched ) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t// Return the length of the invalid excess\n\t// if we're just parsing\n\t// Otherwise, throw an error or return tokens\n\treturn parseOnly ?\n\t\tsoFar.length :\n\t\tsoFar ?\n\t\t\tSizzle.error( selector ) :\n\t\t\t// Cache the tokens\n\t\t\ttokenCache( selector, groups ).slice( 0 );\n};\n\nfunction toSelector( tokens ) {\n\tvar i = 0,\n\t\tlen = tokens.length,\n\t\tselector = \"\";\n\tfor ( ; i < len; i++ ) {\n\t\tselector += tokens[i].value;\n\t}\n\treturn selector;\n}\n\nfunction addCombinator( matcher, combinator, base ) {\n\tvar dir = combinator.dir,\n\t\tskip = combinator.next,\n\t\tkey = skip || dir,\n\t\tcheckNonElements = base && key === \"parentNode\",\n\t\tdoneName = done++;\n\n\treturn combinator.first ?\n\t\t// Check against closest ancestor/preceding element\n\t\tfunction( elem, context, xml ) {\n\t\t\twhile ( (elem = elem[ dir ]) ) {\n\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\treturn matcher( elem, context, xml );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t} :\n\n\t\t// Check against all ancestor/preceding elements\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar oldCache, uniqueCache, outerCache,\n\t\t\t\tnewCache = [ dirruns, doneName ];\n\n\t\t\t// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n\t\t\tif ( xml ) {\n\t\t\t\twhile ( (elem = elem[ dir ]) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\tif ( matcher( elem, context, xml ) ) {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\twhile ( (elem = elem[ dir ]) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\touterCache = elem[ expando ] || (elem[ expando ] = {});\n\n\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\tuniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});\n\n\t\t\t\t\t\tif ( skip && skip === elem.nodeName.toLowerCase() ) {\n\t\t\t\t\t\t\telem = elem[ dir ] || elem;\n\t\t\t\t\t\t} else if ( (oldCache = uniqueCache[ key ]) &&\n\t\t\t\t\t\t\toldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {\n\n\t\t\t\t\t\t\t// Assign to newCache so results back-propagate to previous elements\n\t\t\t\t\t\t\treturn (newCache[ 2 ] = oldCache[ 2 ]);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// Reuse newcache so results back-propagate to previous elements\n\t\t\t\t\t\t\tuniqueCache[ key ] = newCache;\n\n\t\t\t\t\t\t\t// A match means we're done; a fail means we have to keep checking\n\t\t\t\t\t\t\tif ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n}\n\nfunction elementMatcher( matchers ) {\n\treturn matchers.length > 1 ?\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar i = matchers.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( !matchers[i]( elem, context, xml ) ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} :\n\t\tmatchers[0];\n}\n\nfunction multipleContexts( selector, contexts, results ) {\n\tvar i = 0,\n\t\tlen = contexts.length;\n\tfor ( ; i < len; i++ ) {\n\t\tSizzle( selector, contexts[i], results );\n\t}\n\treturn results;\n}\n\nfunction condense( unmatched, map, filter, context, xml ) {\n\tvar elem,\n\t\tnewUnmatched = [],\n\t\ti = 0,\n\t\tlen = unmatched.length,\n\t\tmapped = map != null;\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( (elem = unmatched[i]) ) {\n\t\t\tif ( !filter || filter( elem, context, xml ) ) {\n\t\t\t\tnewUnmatched.push( elem );\n\t\t\t\tif ( mapped ) {\n\t\t\t\t\tmap.push( i );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn newUnmatched;\n}\n\nfunction setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {\n\tif ( postFilter && !postFilter[ expando ] ) {\n\t\tpostFilter = setMatcher( postFilter );\n\t}\n\tif ( postFinder && !postFinder[ expando ] ) {\n\t\tpostFinder = setMatcher( postFinder, postSelector );\n\t}\n\treturn markFunction(function( seed, results, context, xml ) {\n\t\tvar temp, i, elem,\n\t\t\tpreMap = [],\n\t\t\tpostMap = [],\n\t\t\tpreexisting = results.length,\n\n\t\t\t// Get initial elements from seed or context\n\t\t\telems = seed || multipleContexts( selector || \"*\", context.nodeType ? [ context ] : context, [] ),\n\n\t\t\t// Prefilter to get matcher input, preserving a map for seed-results synchronization\n\t\t\tmatcherIn = preFilter && ( seed || !selector ) ?\n\t\t\t\tcondense( elems, preMap, preFilter, context, xml ) :\n\t\t\t\telems,\n\n\t\t\tmatcherOut = matcher ?\n\t\t\t\t// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,\n\t\t\t\tpostFinder || ( seed ? preFilter : preexisting || postFilter ) ?\n\n\t\t\t\t\t// ...intermediate processing is necessary\n\t\t\t\t\t[] :\n\n\t\t\t\t\t// ...otherwise use results directly\n\t\t\t\t\tresults :\n\t\t\t\tmatcherIn;\n\n\t\t// Find primary matches\n\t\tif ( matcher ) {\n\t\t\tmatcher( matcherIn, matcherOut, context, xml );\n\t\t}\n\n\t\t// Apply postFilter\n\t\tif ( postFilter ) {\n\t\t\ttemp = condense( matcherOut, postMap );\n\t\t\tpostFilter( temp, [], context, xml );\n\n\t\t\t// Un-match failing elements by moving them back to matcherIn\n\t\t\ti = temp.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( (elem = temp[i]) ) {\n\t\t\t\t\tmatcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( seed ) {\n\t\t\tif ( postFinder || preFilter ) {\n\t\t\t\tif ( postFinder ) {\n\t\t\t\t\t// Get the final matcherOut by condensing this intermediate into postFinder contexts\n\t\t\t\t\ttemp = [];\n\t\t\t\t\ti = matcherOut.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( (elem = matcherOut[i]) ) {\n\t\t\t\t\t\t\t// Restore matcherIn since elem is not yet a final match\n\t\t\t\t\t\t\ttemp.push( (matcherIn[i] = elem) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tpostFinder( null, (matcherOut = []), temp, xml );\n\t\t\t\t}\n\n\t\t\t\t// Move matched elements from seed to results to keep them synchronized\n\t\t\t\ti = matcherOut.length;\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\tif ( (elem = matcherOut[i]) &&\n\t\t\t\t\t\t(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {\n\n\t\t\t\t\t\tseed[temp] = !(results[temp] = elem);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Add elements to results, through postFinder if defined\n\t\t} else {\n\t\t\tmatcherOut = condense(\n\t\t\t\tmatcherOut === results ?\n\t\t\t\t\tmatcherOut.splice( preexisting, matcherOut.length ) :\n\t\t\t\t\tmatcherOut\n\t\t\t);\n\t\t\tif ( postFinder ) {\n\t\t\t\tpostFinder( null, results, matcherOut, xml );\n\t\t\t} else {\n\t\t\t\tpush.apply( results, matcherOut );\n\t\t\t}\n\t\t}\n\t});\n}\n\nfunction matcherFromTokens( tokens ) {\n\tvar checkContext, matcher, j,\n\t\tlen = tokens.length,\n\t\tleadingRelative = Expr.relative[ tokens[0].type ],\n\t\timplicitRelative = leadingRelative || Expr.relative[\" \"],\n\t\ti = leadingRelative ? 1 : 0,\n\n\t\t// The foundational matcher ensures that elements are reachable from top-level context(s)\n\t\tmatchContext = addCombinator( function( elem ) {\n\t\t\treturn elem === checkContext;\n\t\t}, implicitRelative, true ),\n\t\tmatchAnyContext = addCombinator( function( elem ) {\n\t\t\treturn indexOf( checkContext, elem ) > -1;\n\t\t}, implicitRelative, true ),\n\t\tmatchers = [ function( elem, context, xml ) {\n\t\t\tvar ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (\n\t\t\t\t(checkContext = context).nodeType ?\n\t\t\t\t\tmatchContext( elem, context, xml ) :\n\t\t\t\t\tmatchAnyContext( elem, context, xml ) );\n\t\t\t// Avoid hanging onto element (issue #299)\n\t\t\tcheckContext = null;\n\t\t\treturn ret;\n\t\t} ];\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( (matcher = Expr.relative[ tokens[i].type ]) ) {\n\t\t\tmatchers = [ addCombinator(elementMatcher( matchers ), matcher) ];\n\t\t} else {\n\t\t\tmatcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );\n\n\t\t\t// Return special upon seeing a positional matcher\n\t\t\tif ( matcher[ expando ] ) {\n\t\t\t\t// Find the next relative operator (if any) for proper handling\n\t\t\t\tj = ++i;\n\t\t\t\tfor ( ; j < len; j++ ) {\n\t\t\t\t\tif ( Expr.relative[ tokens[j].type ] ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn setMatcher(\n\t\t\t\t\ti > 1 && elementMatcher( matchers ),\n\t\t\t\t\ti > 1 && toSelector(\n\t\t\t\t\t\t// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\t\t\t\t\t\ttokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" })\n\t\t\t\t\t).replace( rtrim, \"$1\" ),\n\t\t\t\t\tmatcher,\n\t\t\t\t\ti < j && matcherFromTokens( tokens.slice( i, j ) ),\n\t\t\t\t\tj < len && matcherFromTokens( (tokens = tokens.slice( j )) ),\n\t\t\t\t\tj < len && toSelector( tokens )\n\t\t\t\t);\n\t\t\t}\n\t\t\tmatchers.push( matcher );\n\t\t}\n\t}\n\n\treturn elementMatcher( matchers );\n}\n\nfunction matcherFromGroupMatchers( elementMatchers, setMatchers ) {\n\tvar bySet = setMatchers.length > 0,\n\t\tbyElement = elementMatchers.length > 0,\n\t\tsuperMatcher = function( seed, context, xml, results, outermost ) {\n\t\t\tvar elem, j, matcher,\n\t\t\t\tmatchedCount = 0,\n\t\t\t\ti = \"0\",\n\t\t\t\tunmatched = seed && [],\n\t\t\t\tsetMatched = [],\n\t\t\t\tcontextBackup = outermostContext,\n\t\t\t\t// We must always have either seed elements or outermost context\n\t\t\t\telems = seed || byElement && Expr.find[\"TAG\"]( \"*\", outermost ),\n\t\t\t\t// Use integer dirruns iff this is the outermost matcher\n\t\t\t\tdirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),\n\t\t\t\tlen = elems.length;\n\n\t\t\tif ( outermost ) {\n\t\t\t\toutermostContext = context === document || context || outermost;\n\t\t\t}\n\n\t\t\t// Add elements passing elementMatchers directly to results\n\t\t\t// Support: IE<9, Safari\n\t\t\t// Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching elements by id\n\t\t\tfor ( ; i !== len && (elem = elems[i]) != null; i++ ) {\n\t\t\t\tif ( byElement && elem ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\tif ( !context && elem.ownerDocument !== document ) {\n\t\t\t\t\t\tsetDocument( elem );\n\t\t\t\t\t\txml = !documentIsHTML;\n\t\t\t\t\t}\n\t\t\t\t\twhile ( (matcher = elementMatchers[j++]) ) {\n\t\t\t\t\t\tif ( matcher( elem, context || document, xml) ) {\n\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( outermost ) {\n\t\t\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Track unmatched elements for set filters\n\t\t\t\tif ( bySet ) {\n\t\t\t\t\t// They will have gone through all possible matchers\n\t\t\t\t\tif ( (elem = !matcher && elem) ) {\n\t\t\t\t\t\tmatchedCount--;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Lengthen the array for every element, matched or not\n\t\t\t\t\tif ( seed ) {\n\t\t\t\t\t\tunmatched.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// `i` is now the count of elements visited above, and adding it to `matchedCount`\n\t\t\t// makes the latter nonnegative.\n\t\t\tmatchedCount += i;\n\n\t\t\t// Apply set filters to unmatched elements\n\t\t\t// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n\t\t\t// equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n\t\t\t// no element matchers and no seed.\n\t\t\t// Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n\t\t\t// case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n\t\t\t// numerically zero.\n\t\t\tif ( bySet && i !== matchedCount ) {\n\t\t\t\tj = 0;\n\t\t\t\twhile ( (matcher = setMatchers[j++]) ) {\n\t\t\t\t\tmatcher( unmatched, setMatched, context, xml );\n\t\t\t\t}\n\n\t\t\t\tif ( seed ) {\n\t\t\t\t\t// Reintegrate element matches to eliminate the need for sorting\n\t\t\t\t\tif ( matchedCount > 0 ) {\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tif ( !(unmatched[i] || setMatched[i]) ) {\n\t\t\t\t\t\t\t\tsetMatched[i] = pop.call( results );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Discard index placeholder values to get only actual matches\n\t\t\t\t\tsetMatched = condense( setMatched );\n\t\t\t\t}\n\n\t\t\t\t// Add matches to results\n\t\t\t\tpush.apply( results, setMatched );\n\n\t\t\t\t// Seedless set matches succeeding multiple successful matchers stipulate sorting\n\t\t\t\tif ( outermost && !seed && setMatched.length > 0 &&\n\t\t\t\t\t( matchedCount + setMatchers.length ) > 1 ) {\n\n\t\t\t\t\tSizzle.uniqueSort( results );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Override manipulation of globals by nested matchers\n\t\t\tif ( outermost ) {\n\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\toutermostContext = contextBackup;\n\t\t\t}\n\n\t\t\treturn unmatched;\n\t\t};\n\n\treturn bySet ?\n\t\tmarkFunction( superMatcher ) :\n\t\tsuperMatcher;\n}\n\ncompile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {\n\tvar i,\n\t\tsetMatchers = [],\n\t\telementMatchers = [],\n\t\tcached = compilerCache[ selector + \" \" ];\n\n\tif ( !cached ) {\n\t\t// Generate a function of recursive functions that can be used to check each element\n\t\tif ( !match ) {\n\t\t\tmatch = tokenize( selector );\n\t\t}\n\t\ti = match.length;\n\t\twhile ( i-- ) {\n\t\t\tcached = matcherFromTokens( match[i] );\n\t\t\tif ( cached[ expando ] ) {\n\t\t\t\tsetMatchers.push( cached );\n\t\t\t} else {\n\t\t\t\telementMatchers.push( cached );\n\t\t\t}\n\t\t}\n\n\t\t// Cache the compiled function\n\t\tcached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );\n\n\t\t// Save selector and tokenization\n\t\tcached.selector = selector;\n\t}\n\treturn cached;\n};\n\n/**\n * A low-level selection function that works with Sizzle's compiled\n *  selector functions\n * @param {String|Function} selector A selector or a pre-compiled\n *  selector function built with Sizzle.compile\n * @param {Element} context\n * @param {Array} [results]\n * @param {Array} [seed] A set of elements to match against\n */\nselect = Sizzle.select = function( selector, context, results, seed ) {\n\tvar i, tokens, token, type, find,\n\t\tcompiled = typeof selector === \"function\" && selector,\n\t\tmatch = !seed && tokenize( (selector = compiled.selector || selector) );\n\n\tresults = results || [];\n\n\t// Try to minimize operations if there is only one selector in the list and no seed\n\t// (the latter of which guarantees us context)\n\tif ( match.length === 1 ) {\n\n\t\t// Reduce context if the leading compound selector is an ID\n\t\ttokens = match[0] = match[0].slice( 0 );\n\t\tif ( tokens.length > 2 && (token = tokens[0]).type === \"ID\" &&\n\t\t\t\tcontext.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {\n\n\t\t\tcontext = ( Expr.find[\"ID\"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];\n\t\t\tif ( !context ) {\n\t\t\t\treturn results;\n\n\t\t\t// Precompiled matchers will still verify ancestry, so step up a level\n\t\t\t} else if ( compiled ) {\n\t\t\t\tcontext = context.parentNode;\n\t\t\t}\n\n\t\t\tselector = selector.slice( tokens.shift().value.length );\n\t\t}\n\n\t\t// Fetch a seed set for right-to-left matching\n\t\ti = matchExpr[\"needsContext\"].test( selector ) ? 0 : tokens.length;\n\t\twhile ( i-- ) {\n\t\t\ttoken = tokens[i];\n\n\t\t\t// Abort if we hit a combinator\n\t\t\tif ( Expr.relative[ (type = token.type) ] ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( (find = Expr.find[ type ]) ) {\n\t\t\t\t// Search, expanding context for leading sibling combinators\n\t\t\t\tif ( (seed = find(\n\t\t\t\t\ttoken.matches[0].replace( runescape, funescape ),\n\t\t\t\t\trsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context\n\t\t\t\t)) ) {\n\n\t\t\t\t\t// If seed is empty or no tokens remain, we can return early\n\t\t\t\t\ttokens.splice( i, 1 );\n\t\t\t\t\tselector = seed.length && toSelector( tokens );\n\t\t\t\t\tif ( !selector ) {\n\t\t\t\t\t\tpush.apply( results, seed );\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Compile and execute a filtering function if one is not provided\n\t// Provide `match` to avoid retokenization if we modified the selector above\n\t( compiled || compile( selector, match ) )(\n\t\tseed,\n\t\tcontext,\n\t\t!documentIsHTML,\n\t\tresults,\n\t\t!context || rsibling.test( selector ) && testContext( context.parentNode ) || context\n\t);\n\treturn results;\n};\n\n// One-time assignments\n\n// Sort stability\nsupport.sortStable = expando.split(\"\").sort( sortOrder ).join(\"\") === expando;\n\n// Support: Chrome 14-35+\n// Always assume duplicates if they aren't passed to the comparison function\nsupport.detectDuplicates = !!hasDuplicate;\n\n// Initialize against the default document\nsetDocument();\n\n// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)\n// Detached nodes confoundingly follow *each other*\nsupport.sortDetached = assert(function( el ) {\n\t// Should return 1, but returns 4 (following)\n\treturn el.compareDocumentPosition( document.createElement(\"fieldset\") ) & 1;\n});\n\n// Support: IE<8\n// Prevent attribute/property \"interpolation\"\n// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\nif ( !assert(function( el ) {\n\tel.innerHTML = \"<a href='#'></a>\";\n\treturn el.firstChild.getAttribute(\"href\") === \"#\" ;\n}) ) {\n\taddHandle( \"type|href|height|width\", function( elem, name, isXML ) {\n\t\tif ( !isXML ) {\n\t\t\treturn elem.getAttribute( name, name.toLowerCase() === \"type\" ? 1 : 2 );\n\t\t}\n\t});\n}\n\n// Support: IE<9\n// Use defaultValue in place of getAttribute(\"value\")\nif ( !support.attributes || !assert(function( el ) {\n\tel.innerHTML = \"<input/>\";\n\tel.firstChild.setAttribute( \"value\", \"\" );\n\treturn el.firstChild.getAttribute( \"value\" ) === \"\";\n}) ) {\n\taddHandle( \"value\", function( elem, name, isXML ) {\n\t\tif ( !isXML && elem.nodeName.toLowerCase() === \"input\" ) {\n\t\t\treturn elem.defaultValue;\n\t\t}\n\t});\n}\n\n// Support: IE<9\n// Use getAttributeNode to fetch booleans when getAttribute lies\nif ( !assert(function( el ) {\n\treturn el.getAttribute(\"disabled\") == null;\n}) ) {\n\taddHandle( booleans, function( elem, name, isXML ) {\n\t\tvar val;\n\t\tif ( !isXML ) {\n\t\t\treturn elem[ name ] === true ? name.toLowerCase() :\n\t\t\t\t\t(val = elem.getAttributeNode( name )) && val.specified ?\n\t\t\t\t\tval.value :\n\t\t\t\tnull;\n\t\t}\n\t});\n}\n\nreturn Sizzle;\n\n})( window );\n\n\n\njQuery.find = Sizzle;\njQuery.expr = Sizzle.selectors;\n\n// Deprecated\njQuery.expr[ \":\" ] = jQuery.expr.pseudos;\njQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;\njQuery.text = Sizzle.getText;\njQuery.isXMLDoc = Sizzle.isXML;\njQuery.contains = Sizzle.contains;\njQuery.escapeSelector = Sizzle.escape;\n\n\n\n\nvar dir = function( elem, dir, until ) {\n\tvar matched = [],\n\t\ttruncate = until !== undefined;\n\n\twhile ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {\n\t\tif ( elem.nodeType === 1 ) {\n\t\t\tif ( truncate && jQuery( elem ).is( until ) ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tmatched.push( elem );\n\t\t}\n\t}\n\treturn matched;\n};\n\n\nvar siblings = function( n, elem ) {\n\tvar matched = [];\n\n\tfor ( ; n; n = n.nextSibling ) {\n\t\tif ( n.nodeType === 1 && n !== elem ) {\n\t\t\tmatched.push( n );\n\t\t}\n\t}\n\n\treturn matched;\n};\n\n\nvar rneedsContext = jQuery.expr.match.needsContext;\n\n\n\nfunction nodeName( elem, name ) {\n\n  return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n\n};\nvar rsingleTag = ( /^<([a-z][^\\/\\0>:\\x20\\t\\r\\n\\f]*)[\\x20\\t\\r\\n\\f]*\\/?>(?:<\\/\\1>|)$/i );\n\n\n\nvar risSimple = /^.[^:#\\[\\.,]*$/;\n\n// Implement the identical functionality for filter and not\nfunction winnow( elements, qualifier, not ) {\n\tif ( jQuery.isFunction( qualifier ) ) {\n\t\treturn jQuery.grep( elements, function( elem, i ) {\n\t\t\treturn !!qualifier.call( elem, i, elem ) !== not;\n\t\t} );\n\t}\n\n\t// Single element\n\tif ( qualifier.nodeType ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( elem === qualifier ) !== not;\n\t\t} );\n\t}\n\n\t// Arraylike of elements (jQuery, arguments, Array)\n\tif ( typeof qualifier !== \"string\" ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( indexOf.call( qualifier, elem ) > -1 ) !== not;\n\t\t} );\n\t}\n\n\t// Simple selector that can be filtered directly, removing non-Elements\n\tif ( risSimple.test( qualifier ) ) {\n\t\treturn jQuery.filter( qualifier, elements, not );\n\t}\n\n\t// Complex selector, compare the two sets, removing non-Elements\n\tqualifier = jQuery.filter( qualifier, elements );\n\treturn jQuery.grep( elements, function( elem ) {\n\t\treturn ( indexOf.call( qualifier, elem ) > -1 ) !== not && elem.nodeType === 1;\n\t} );\n}\n\njQuery.filter = function( expr, elems, not ) {\n\tvar elem = elems[ 0 ];\n\n\tif ( not ) {\n\t\texpr = \":not(\" + expr + \")\";\n\t}\n\n\tif ( elems.length === 1 && elem.nodeType === 1 ) {\n\t\treturn jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];\n\t}\n\n\treturn jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {\n\t\treturn elem.nodeType === 1;\n\t} ) );\n};\n\njQuery.fn.extend( {\n\tfind: function( selector ) {\n\t\tvar i, ret,\n\t\t\tlen = this.length,\n\t\t\tself = this;\n\n\t\tif ( typeof selector !== \"string\" ) {\n\t\t\treturn this.pushStack( jQuery( selector ).filter( function() {\n\t\t\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\t\t\tif ( jQuery.contains( self[ i ], this ) ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} ) );\n\t\t}\n\n\t\tret = this.pushStack( [] );\n\n\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\tjQuery.find( selector, self[ i ], ret );\n\t\t}\n\n\t\treturn len > 1 ? jQuery.uniqueSort( ret ) : ret;\n\t},\n\tfilter: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], false ) );\n\t},\n\tnot: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], true ) );\n\t},\n\tis: function( selector ) {\n\t\treturn !!winnow(\n\t\t\tthis,\n\n\t\t\t// If this is a positional/relative selector, check membership in the returned set\n\t\t\t// so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n\t\t\ttypeof selector === \"string\" && rneedsContext.test( selector ) ?\n\t\t\t\tjQuery( selector ) :\n\t\t\t\tselector || [],\n\t\t\tfalse\n\t\t).length;\n\t}\n} );\n\n\n// Initialize a jQuery object\n\n\n// A central reference to the root jQuery(document)\nvar rootjQuery,\n\n\t// A simple way to check for HTML strings\n\t// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)\n\t// Strict HTML recognition (#11290: must start with <)\n\t// Shortcut simple #id case for speed\n\trquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]+))$/,\n\n\tinit = jQuery.fn.init = function( selector, context, root ) {\n\t\tvar match, elem;\n\n\t\t// HANDLE: $(\"\"), $(null), $(undefined), $(false)\n\t\tif ( !selector ) {\n\t\t\treturn this;\n\t\t}\n\n\t\t// Method init() accepts an alternate rootjQuery\n\t\t// so migrate can support jQuery.sub (gh-2101)\n\t\troot = root || rootjQuery;\n\n\t\t// Handle HTML strings\n\t\tif ( typeof selector === \"string\" ) {\n\t\t\tif ( selector[ 0 ] === \"<\" &&\n\t\t\t\tselector[ selector.length - 1 ] === \">\" &&\n\t\t\t\tselector.length >= 3 ) {\n\n\t\t\t\t// Assume that strings that start and end with <> are HTML and skip the regex check\n\t\t\t\tmatch = [ null, selector, null ];\n\n\t\t\t} else {\n\t\t\t\tmatch = rquickExpr.exec( selector );\n\t\t\t}\n\n\t\t\t// Match html or make sure no context is specified for #id\n\t\t\tif ( match && ( match[ 1 ] || !context ) ) {\n\n\t\t\t\t// HANDLE: $(html) -> $(array)\n\t\t\t\tif ( match[ 1 ] ) {\n\t\t\t\t\tcontext = context instanceof jQuery ? context[ 0 ] : context;\n\n\t\t\t\t\t// Option to run scripts is true for back-compat\n\t\t\t\t\t// Intentionally let the error be thrown if parseHTML is not present\n\t\t\t\t\tjQuery.merge( this, jQuery.parseHTML(\n\t\t\t\t\t\tmatch[ 1 ],\n\t\t\t\t\t\tcontext && context.nodeType ? context.ownerDocument || context : document,\n\t\t\t\t\t\ttrue\n\t\t\t\t\t) );\n\n\t\t\t\t\t// HANDLE: $(html, props)\n\t\t\t\t\tif ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {\n\t\t\t\t\t\tfor ( match in context ) {\n\n\t\t\t\t\t\t\t// Properties of context are called as methods if possible\n\t\t\t\t\t\t\tif ( jQuery.isFunction( this[ match ] ) ) {\n\t\t\t\t\t\t\t\tthis[ match ]( context[ match ] );\n\n\t\t\t\t\t\t\t// ...and otherwise set as attributes\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis.attr( match, context[ match ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn this;\n\n\t\t\t\t// HANDLE: $(#id)\n\t\t\t\t} else {\n\t\t\t\t\telem = document.getElementById( match[ 2 ] );\n\n\t\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t\t// Inject the element directly into the jQuery object\n\t\t\t\t\t\tthis[ 0 ] = elem;\n\t\t\t\t\t\tthis.length = 1;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\n\t\t\t// HANDLE: $(expr, $(...))\n\t\t\t} else if ( !context || context.jquery ) {\n\t\t\t\treturn ( context || root ).find( selector );\n\n\t\t\t// HANDLE: $(expr, context)\n\t\t\t// (which is just equivalent to: $(context).find(expr)\n\t\t\t} else {\n\t\t\t\treturn this.constructor( context ).find( selector );\n\t\t\t}\n\n\t\t// HANDLE: $(DOMElement)\n\t\t} else if ( selector.nodeType ) {\n\t\t\tthis[ 0 ] = selector;\n\t\t\tthis.length = 1;\n\t\t\treturn this;\n\n\t\t// HANDLE: $(function)\n\t\t// Shortcut for document ready\n\t\t} else if ( jQuery.isFunction( selector ) ) {\n\t\t\treturn root.ready !== undefined ?\n\t\t\t\troot.ready( selector ) :\n\n\t\t\t\t// Execute immediately if ready is not present\n\t\t\t\tselector( jQuery );\n\t\t}\n\n\t\treturn jQuery.makeArray( selector, this );\n\t};\n\n// Give the init function the jQuery prototype for later instantiation\ninit.prototype = jQuery.fn;\n\n// Initialize central reference\nrootjQuery = jQuery( document );\n\n\nvar rparentsprev = /^(?:parents|prev(?:Until|All))/,\n\n\t// Methods guaranteed to produce a unique set when starting from a unique set\n\tguaranteedUnique = {\n\t\tchildren: true,\n\t\tcontents: true,\n\t\tnext: true,\n\t\tprev: true\n\t};\n\njQuery.fn.extend( {\n\thas: function( target ) {\n\t\tvar targets = jQuery( target, this ),\n\t\t\tl = targets.length;\n\n\t\treturn this.filter( function() {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tif ( jQuery.contains( this, targets[ i ] ) ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\tclosest: function( selectors, context ) {\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\tl = this.length,\n\t\t\tmatched = [],\n\t\t\ttargets = typeof selectors !== \"string\" && jQuery( selectors );\n\n\t\t// Positional selectors never match, since there's no _selection_ context\n\t\tif ( !rneedsContext.test( selectors ) ) {\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tfor ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {\n\n\t\t\t\t\t// Always skip document fragments\n\t\t\t\t\tif ( cur.nodeType < 11 && ( targets ?\n\t\t\t\t\t\ttargets.index( cur ) > -1 :\n\n\t\t\t\t\t\t// Don't pass non-elements to Sizzle\n\t\t\t\t\t\tcur.nodeType === 1 &&\n\t\t\t\t\t\t\tjQuery.find.matchesSelector( cur, selectors ) ) ) {\n\n\t\t\t\t\t\tmatched.push( cur );\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );\n\t},\n\n\t// Determine the position of an element within the set\n\tindex: function( elem ) {\n\n\t\t// No argument, return index in parent\n\t\tif ( !elem ) {\n\t\t\treturn ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;\n\t\t}\n\n\t\t// Index in selector\n\t\tif ( typeof elem === \"string\" ) {\n\t\t\treturn indexOf.call( jQuery( elem ), this[ 0 ] );\n\t\t}\n\n\t\t// Locate the position of the desired element\n\t\treturn indexOf.call( this,\n\n\t\t\t// If it receives a jQuery object, the first element is used\n\t\t\telem.jquery ? elem[ 0 ] : elem\n\t\t);\n\t},\n\n\tadd: function( selector, context ) {\n\t\treturn this.pushStack(\n\t\t\tjQuery.uniqueSort(\n\t\t\t\tjQuery.merge( this.get(), jQuery( selector, context ) )\n\t\t\t)\n\t\t);\n\t},\n\n\taddBack: function( selector ) {\n\t\treturn this.add( selector == null ?\n\t\t\tthis.prevObject : this.prevObject.filter( selector )\n\t\t);\n\t}\n} );\n\nfunction sibling( cur, dir ) {\n\twhile ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}\n\treturn cur;\n}\n\njQuery.each( {\n\tparent: function( elem ) {\n\t\tvar parent = elem.parentNode;\n\t\treturn parent && parent.nodeType !== 11 ? parent : null;\n\t},\n\tparents: function( elem ) {\n\t\treturn dir( elem, \"parentNode\" );\n\t},\n\tparentsUntil: function( elem, i, until ) {\n\t\treturn dir( elem, \"parentNode\", until );\n\t},\n\tnext: function( elem ) {\n\t\treturn sibling( elem, \"nextSibling\" );\n\t},\n\tprev: function( elem ) {\n\t\treturn sibling( elem, \"previousSibling\" );\n\t},\n\tnextAll: function( elem ) {\n\t\treturn dir( elem, \"nextSibling\" );\n\t},\n\tprevAll: function( elem ) {\n\t\treturn dir( elem, \"previousSibling\" );\n\t},\n\tnextUntil: function( elem, i, until ) {\n\t\treturn dir( elem, \"nextSibling\", until );\n\t},\n\tprevUntil: function( elem, i, until ) {\n\t\treturn dir( elem, \"previousSibling\", until );\n\t},\n\tsiblings: function( elem ) {\n\t\treturn siblings( ( elem.parentNode || {} ).firstChild, elem );\n\t},\n\tchildren: function( elem ) {\n\t\treturn siblings( elem.firstChild );\n\t},\n\tcontents: function( elem ) {\n        if ( nodeName( elem, \"iframe\" ) ) {\n            return elem.contentDocument;\n        }\n\n        // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only\n        // Treat the template element as a regular one in browsers that\n        // don't support it.\n        if ( nodeName( elem, \"template\" ) ) {\n            elem = elem.content || elem;\n        }\n\n        return jQuery.merge( [], elem.childNodes );\n\t}\n}, function( name, fn ) {\n\tjQuery.fn[ name ] = function( until, selector ) {\n\t\tvar matched = jQuery.map( this, fn, until );\n\n\t\tif ( name.slice( -5 ) !== \"Until\" ) {\n\t\t\tselector = until;\n\t\t}\n\n\t\tif ( selector && typeof selector === \"string\" ) {\n\t\t\tmatched = jQuery.filter( selector, matched );\n\t\t}\n\n\t\tif ( this.length > 1 ) {\n\n\t\t\t// Remove duplicates\n\t\t\tif ( !guaranteedUnique[ name ] ) {\n\t\t\t\tjQuery.uniqueSort( matched );\n\t\t\t}\n\n\t\t\t// Reverse order for parents* and prev-derivatives\n\t\t\tif ( rparentsprev.test( name ) ) {\n\t\t\t\tmatched.reverse();\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched );\n\t};\n} );\nvar rnothtmlwhite = ( /[^\\x20\\t\\r\\n\\f]+/g );\n\n\n\n// Convert String-formatted options into Object-formatted ones\nfunction createOptions( options ) {\n\tvar object = {};\n\tjQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {\n\t\tobject[ flag ] = true;\n\t} );\n\treturn object;\n}\n\n/*\n * Create a callback list using the following parameters:\n *\n *\toptions: an optional list of space-separated options that will change how\n *\t\t\tthe callback list behaves or a more traditional option object\n *\n * By default a callback list will act like an event callback list and can be\n * \"fired\" multiple times.\n *\n * Possible options:\n *\n *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\n *\n *\tmemory:\t\t\twill keep track of previous values and will call any callback added\n *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\n *\t\t\t\t\tvalues (like a Deferred)\n *\n *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\n *\n *\tstopOnFalse:\tinterrupt callings when a callback returns false\n *\n */\njQuery.Callbacks = function( options ) {\n\n\t// Convert options from String-formatted to Object-formatted if needed\n\t// (we check in cache first)\n\toptions = typeof options === \"string\" ?\n\t\tcreateOptions( options ) :\n\t\tjQuery.extend( {}, options );\n\n\tvar // Flag to know if list is currently firing\n\t\tfiring,\n\n\t\t// Last fire value for non-forgettable lists\n\t\tmemory,\n\n\t\t// Flag to know if list was already fired\n\t\tfired,\n\n\t\t// Flag to prevent firing\n\t\tlocked,\n\n\t\t// Actual callback list\n\t\tlist = [],\n\n\t\t// Queue of execution data for repeatable lists\n\t\tqueue = [],\n\n\t\t// Index of currently firing callback (modified by add/remove as needed)\n\t\tfiringIndex = -1,\n\n\t\t// Fire callbacks\n\t\tfire = function() {\n\n\t\t\t// Enforce single-firing\n\t\t\tlocked = locked || options.once;\n\n\t\t\t// Execute callbacks for all pending executions,\n\t\t\t// respecting firingIndex overrides and runtime changes\n\t\t\tfired = firing = true;\n\t\t\tfor ( ; queue.length; firingIndex = -1 ) {\n\t\t\t\tmemory = queue.shift();\n\t\t\t\twhile ( ++firingIndex < list.length ) {\n\n\t\t\t\t\t// Run callback and check for early termination\n\t\t\t\t\tif ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&\n\t\t\t\t\t\toptions.stopOnFalse ) {\n\n\t\t\t\t\t\t// Jump to end and forget the data so .add doesn't re-fire\n\t\t\t\t\t\tfiringIndex = list.length;\n\t\t\t\t\t\tmemory = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Forget the data if we're done with it\n\t\t\tif ( !options.memory ) {\n\t\t\t\tmemory = false;\n\t\t\t}\n\n\t\t\tfiring = false;\n\n\t\t\t// Clean up if we're done firing for good\n\t\t\tif ( locked ) {\n\n\t\t\t\t// Keep an empty list if we have data for future add calls\n\t\t\t\tif ( memory ) {\n\t\t\t\t\tlist = [];\n\n\t\t\t\t// Otherwise, this object is spent\n\t\t\t\t} else {\n\t\t\t\t\tlist = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t// Actual Callbacks object\n\t\tself = {\n\n\t\t\t// Add a callback or a collection of callbacks to the list\n\t\t\tadd: function() {\n\t\t\t\tif ( list ) {\n\n\t\t\t\t\t// If we have memory from a past run, we should fire after adding\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfiringIndex = list.length - 1;\n\t\t\t\t\t\tqueue.push( memory );\n\t\t\t\t\t}\n\n\t\t\t\t\t( function add( args ) {\n\t\t\t\t\t\tjQuery.each( args, function( _, arg ) {\n\t\t\t\t\t\t\tif ( jQuery.isFunction( arg ) ) {\n\t\t\t\t\t\t\t\tif ( !options.unique || !self.has( arg ) ) {\n\t\t\t\t\t\t\t\t\tlist.push( arg );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else if ( arg && arg.length && jQuery.type( arg ) !== \"string\" ) {\n\n\t\t\t\t\t\t\t\t// Inspect recursively\n\t\t\t\t\t\t\t\tadd( arg );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} );\n\t\t\t\t\t} )( arguments );\n\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Remove a callback from the list\n\t\t\tremove: function() {\n\t\t\t\tjQuery.each( arguments, function( _, arg ) {\n\t\t\t\t\tvar index;\n\t\t\t\t\twhile ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {\n\t\t\t\t\t\tlist.splice( index, 1 );\n\n\t\t\t\t\t\t// Handle firing indexes\n\t\t\t\t\t\tif ( index <= firingIndex ) {\n\t\t\t\t\t\t\tfiringIndex--;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Check if a given callback is in the list.\n\t\t\t// If no argument is given, return whether or not list has callbacks attached.\n\t\t\thas: function( fn ) {\n\t\t\t\treturn fn ?\n\t\t\t\t\tjQuery.inArray( fn, list ) > -1 :\n\t\t\t\t\tlist.length > 0;\n\t\t\t},\n\n\t\t\t// Remove all callbacks from the list\n\t\t\tempty: function() {\n\t\t\t\tif ( list ) {\n\t\t\t\t\tlist = [];\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Disable .fire and .add\n\t\t\t// Abort any current/pending executions\n\t\t\t// Clear all callbacks and values\n\t\t\tdisable: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tlist = memory = \"\";\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tdisabled: function() {\n\t\t\t\treturn !list;\n\t\t\t},\n\n\t\t\t// Disable .fire\n\t\t\t// Also disable .add unless we have memory (since it would have no effect)\n\t\t\t// Abort any pending executions\n\t\t\tlock: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tif ( !memory && !firing ) {\n\t\t\t\t\tlist = memory = \"\";\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tlocked: function() {\n\t\t\t\treturn !!locked;\n\t\t\t},\n\n\t\t\t// Call all callbacks with the given context and arguments\n\t\t\tfireWith: function( context, args ) {\n\t\t\t\tif ( !locked ) {\n\t\t\t\t\targs = args || [];\n\t\t\t\t\targs = [ context, args.slice ? args.slice() : args ];\n\t\t\t\t\tqueue.push( args );\n\t\t\t\t\tif ( !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Call all the callbacks with the given arguments\n\t\t\tfire: function() {\n\t\t\t\tself.fireWith( this, arguments );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// To know if the callbacks have already been called at least once\n\t\t\tfired: function() {\n\t\t\t\treturn !!fired;\n\t\t\t}\n\t\t};\n\n\treturn self;\n};\n\n\nfunction Identity( v ) {\n\treturn v;\n}\nfunction Thrower( ex ) {\n\tthrow ex;\n}\n\nfunction adoptValue( value, resolve, reject, noValue ) {\n\tvar method;\n\n\ttry {\n\n\t\t// Check for promise aspect first to privilege synchronous behavior\n\t\tif ( value && jQuery.isFunction( ( method = value.promise ) ) ) {\n\t\t\tmethod.call( value ).done( resolve ).fail( reject );\n\n\t\t// Other thenables\n\t\t} else if ( value && jQuery.isFunction( ( method = value.then ) ) ) {\n\t\t\tmethod.call( value, resolve, reject );\n\n\t\t// Other non-thenables\n\t\t} else {\n\n\t\t\t// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:\n\t\t\t// * false: [ value ].slice( 0 ) => resolve( value )\n\t\t\t// * true: [ value ].slice( 1 ) => resolve()\n\t\t\tresolve.apply( undefined, [ value ].slice( noValue ) );\n\t\t}\n\n\t// For Promises/A+, convert exceptions into rejections\n\t// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in\n\t// Deferred#then to conditionally suppress rejection.\n\t} catch ( value ) {\n\n\t\t// Support: Android 4.0 only\n\t\t// Strict mode functions invoked without .call/.apply get global-object context\n\t\treject.apply( undefined, [ value ] );\n\t}\n}\n\njQuery.extend( {\n\n\tDeferred: function( func ) {\n\t\tvar tuples = [\n\n\t\t\t\t// action, add listener, callbacks,\n\t\t\t\t// ... .then handlers, argument index, [final state]\n\t\t\t\t[ \"notify\", \"progress\", jQuery.Callbacks( \"memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"memory\" ), 2 ],\n\t\t\t\t[ \"resolve\", \"done\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 0, \"resolved\" ],\n\t\t\t\t[ \"reject\", \"fail\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 1, \"rejected\" ]\n\t\t\t],\n\t\t\tstate = \"pending\",\n\t\t\tpromise = {\n\t\t\t\tstate: function() {\n\t\t\t\t\treturn state;\n\t\t\t\t},\n\t\t\t\talways: function() {\n\t\t\t\t\tdeferred.done( arguments ).fail( arguments );\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\t\t\t\t\"catch\": function( fn ) {\n\t\t\t\t\treturn promise.then( null, fn );\n\t\t\t\t},\n\n\t\t\t\t// Keep pipe for back-compat\n\t\t\t\tpipe: function( /* fnDone, fnFail, fnProgress */ ) {\n\t\t\t\t\tvar fns = arguments;\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\t\t\t\t\t\tjQuery.each( tuples, function( i, tuple ) {\n\n\t\t\t\t\t\t\t// Map tuples (progress, done, fail) to arguments (done, fail, progress)\n\t\t\t\t\t\t\tvar fn = jQuery.isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];\n\n\t\t\t\t\t\t\t// deferred.progress(function() { bind to newDefer or newDefer.notify })\n\t\t\t\t\t\t\t// deferred.done(function() { bind to newDefer or newDefer.resolve })\n\t\t\t\t\t\t\t// deferred.fail(function() { bind to newDefer or newDefer.reject })\n\t\t\t\t\t\t\tdeferred[ tuple[ 1 ] ]( function() {\n\t\t\t\t\t\t\t\tvar returned = fn && fn.apply( this, arguments );\n\t\t\t\t\t\t\t\tif ( returned && jQuery.isFunction( returned.promise ) ) {\n\t\t\t\t\t\t\t\t\treturned.promise()\n\t\t\t\t\t\t\t\t\t\t.progress( newDefer.notify )\n\t\t\t\t\t\t\t\t\t\t.done( newDefer.resolve )\n\t\t\t\t\t\t\t\t\t\t.fail( newDefer.reject );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tnewDefer[ tuple[ 0 ] + \"With\" ](\n\t\t\t\t\t\t\t\t\t\tthis,\n\t\t\t\t\t\t\t\t\t\tfn ? [ returned ] : arguments\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t} );\n\t\t\t\t\t\tfns = null;\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\t\t\t\tthen: function( onFulfilled, onRejected, onProgress ) {\n\t\t\t\t\tvar maxDepth = 0;\n\t\t\t\t\tfunction resolve( depth, deferred, handler, special ) {\n\t\t\t\t\t\treturn function() {\n\t\t\t\t\t\t\tvar that = this,\n\t\t\t\t\t\t\t\targs = arguments,\n\t\t\t\t\t\t\t\tmightThrow = function() {\n\t\t\t\t\t\t\t\t\tvar returned, then;\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.3\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-59\n\t\t\t\t\t\t\t\t\t// Ignore double-resolution attempts\n\t\t\t\t\t\t\t\t\tif ( depth < maxDepth ) {\n\t\t\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\treturned = handler.apply( that, args );\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.1\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-48\n\t\t\t\t\t\t\t\t\tif ( returned === deferred.promise() ) {\n\t\t\t\t\t\t\t\t\t\tthrow new TypeError( \"Thenable self-resolution\" );\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ sections 2.3.3.1, 3.5\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-54\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-75\n\t\t\t\t\t\t\t\t\t// Retrieve `then` only once\n\t\t\t\t\t\t\t\t\tthen = returned &&\n\n\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.4\n\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-64\n\t\t\t\t\t\t\t\t\t\t// Only check objects and functions for thenability\n\t\t\t\t\t\t\t\t\t\t( typeof returned === \"object\" ||\n\t\t\t\t\t\t\t\t\t\t\ttypeof returned === \"function\" ) &&\n\t\t\t\t\t\t\t\t\t\treturned.then;\n\n\t\t\t\t\t\t\t\t\t// Handle a returned thenable\n\t\t\t\t\t\t\t\t\tif ( jQuery.isFunction( then ) ) {\n\n\t\t\t\t\t\t\t\t\t\t// Special processors (notify) just wait for resolution\n\t\t\t\t\t\t\t\t\t\tif ( special ) {\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special )\n\t\t\t\t\t\t\t\t\t\t\t);\n\n\t\t\t\t\t\t\t\t\t\t// Normal processors (resolve) also hook into progress\n\t\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t\t// ...and disregard older resolution values\n\t\t\t\t\t\t\t\t\t\t\tmaxDepth++;\n\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity,\n\t\t\t\t\t\t\t\t\t\t\t\t\tdeferred.notifyWith )\n\t\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Handle all other returned values\n\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\tif ( handler !== Identity ) {\n\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\targs = [ returned ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t// Process the value(s)\n\t\t\t\t\t\t\t\t\t\t// Default process is resolve\n\t\t\t\t\t\t\t\t\t\t( special || deferred.resolveWith )( that, args );\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t},\n\n\t\t\t\t\t\t\t\t// Only normal processors (resolve) catch and reject exceptions\n\t\t\t\t\t\t\t\tprocess = special ?\n\t\t\t\t\t\t\t\t\tmightThrow :\n\t\t\t\t\t\t\t\t\tfunction() {\n\t\t\t\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\t\t\t\tmightThrow();\n\t\t\t\t\t\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t\t\t\t\t\tif ( jQuery.Deferred.exceptionHook ) {\n\t\t\t\t\t\t\t\t\t\t\t\tjQuery.Deferred.exceptionHook( e,\n\t\t\t\t\t\t\t\t\t\t\t\t\tprocess.stackTrace );\n\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.4.1\n\t\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-61\n\t\t\t\t\t\t\t\t\t\t\t// Ignore post-resolution exceptions\n\t\t\t\t\t\t\t\t\t\t\tif ( depth + 1 >= maxDepth ) {\n\n\t\t\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\t\t\tif ( handler !== Thrower ) {\n\t\t\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\t\t\targs = [ e ];\n\t\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t\tdeferred.rejectWith( that, args );\n\t\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.1\n\t\t\t\t\t\t\t// https://promisesaplus.com/#point-57\n\t\t\t\t\t\t\t// Re-resolve promises immediately to dodge false rejection from\n\t\t\t\t\t\t\t// subsequent errors\n\t\t\t\t\t\t\tif ( depth ) {\n\t\t\t\t\t\t\t\tprocess();\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t// Call an optional hook to record the stack, in case of exception\n\t\t\t\t\t\t\t\t// since it's otherwise lost when execution goes async\n\t\t\t\t\t\t\t\tif ( jQuery.Deferred.getStackHook ) {\n\t\t\t\t\t\t\t\t\tprocess.stackTrace = jQuery.Deferred.getStackHook();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\twindow.setTimeout( process );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\n\t\t\t\t\t\t// progress_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 0 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tjQuery.isFunction( onProgress ) ?\n\t\t\t\t\t\t\t\t\tonProgress :\n\t\t\t\t\t\t\t\t\tIdentity,\n\t\t\t\t\t\t\t\tnewDefer.notifyWith\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// fulfilled_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 1 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tjQuery.isFunction( onFulfilled ) ?\n\t\t\t\t\t\t\t\t\tonFulfilled :\n\t\t\t\t\t\t\t\t\tIdentity\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// rejected_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 2 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tjQuery.isFunction( onRejected ) ?\n\t\t\t\t\t\t\t\t\tonRejected :\n\t\t\t\t\t\t\t\t\tThrower\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\n\t\t\t\t// Get a promise for this deferred\n\t\t\t\t// If obj is provided, the promise aspect is added to the object\n\t\t\t\tpromise: function( obj ) {\n\t\t\t\t\treturn obj != null ? jQuery.extend( obj, promise ) : promise;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdeferred = {};\n\n\t\t// Add list-specific methods\n\t\tjQuery.each( tuples, function( i, tuple ) {\n\t\t\tvar list = tuple[ 2 ],\n\t\t\t\tstateString = tuple[ 5 ];\n\n\t\t\t// promise.progress = list.add\n\t\t\t// promise.done = list.add\n\t\t\t// promise.fail = list.add\n\t\t\tpromise[ tuple[ 1 ] ] = list.add;\n\n\t\t\t// Handle state\n\t\t\tif ( stateString ) {\n\t\t\t\tlist.add(\n\t\t\t\t\tfunction() {\n\n\t\t\t\t\t\t// state = \"resolved\" (i.e., fulfilled)\n\t\t\t\t\t\t// state = \"rejected\"\n\t\t\t\t\t\tstate = stateString;\n\t\t\t\t\t},\n\n\t\t\t\t\t// rejected_callbacks.disable\n\t\t\t\t\t// fulfilled_callbacks.disable\n\t\t\t\t\ttuples[ 3 - i ][ 2 ].disable,\n\n\t\t\t\t\t// progress_callbacks.lock\n\t\t\t\t\ttuples[ 0 ][ 2 ].lock\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// progress_handlers.fire\n\t\t\t// fulfilled_handlers.fire\n\t\t\t// rejected_handlers.fire\n\t\t\tlist.add( tuple[ 3 ].fire );\n\n\t\t\t// deferred.notify = function() { deferred.notifyWith(...) }\n\t\t\t// deferred.resolve = function() { deferred.resolveWith(...) }\n\t\t\t// deferred.reject = function() { deferred.rejectWith(...) }\n\t\t\tdeferred[ tuple[ 0 ] ] = function() {\n\t\t\t\tdeferred[ tuple[ 0 ] + \"With\" ]( this === deferred ? undefined : this, arguments );\n\t\t\t\treturn this;\n\t\t\t};\n\n\t\t\t// deferred.notifyWith = list.fireWith\n\t\t\t// deferred.resolveWith = list.fireWith\n\t\t\t// deferred.rejectWith = list.fireWith\n\t\t\tdeferred[ tuple[ 0 ] + \"With\" ] = list.fireWith;\n\t\t} );\n\n\t\t// Make the deferred a promise\n\t\tpromise.promise( deferred );\n\n\t\t// Call given func if any\n\t\tif ( func ) {\n\t\t\tfunc.call( deferred, deferred );\n\t\t}\n\n\t\t// All done!\n\t\treturn deferred;\n\t},\n\n\t// Deferred helper\n\twhen: function( singleValue ) {\n\t\tvar\n\n\t\t\t// count of uncompleted subordinates\n\t\t\tremaining = arguments.length,\n\n\t\t\t// count of unprocessed arguments\n\t\t\ti = remaining,\n\n\t\t\t// subordinate fulfillment data\n\t\t\tresolveContexts = Array( i ),\n\t\t\tresolveValues = slice.call( arguments ),\n\n\t\t\t// the master Deferred\n\t\t\tmaster = jQuery.Deferred(),\n\n\t\t\t// subordinate callback factory\n\t\t\tupdateFunc = function( i ) {\n\t\t\t\treturn function( value ) {\n\t\t\t\t\tresolveContexts[ i ] = this;\n\t\t\t\t\tresolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;\n\t\t\t\t\tif ( !( --remaining ) ) {\n\t\t\t\t\t\tmaster.resolveWith( resolveContexts, resolveValues );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\n\t\t// Single- and empty arguments are adopted like Promise.resolve\n\t\tif ( remaining <= 1 ) {\n\t\t\tadoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,\n\t\t\t\t!remaining );\n\n\t\t\t// Use .then() to unwrap secondary thenables (cf. gh-3000)\n\t\t\tif ( master.state() === \"pending\" ||\n\t\t\t\tjQuery.isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {\n\n\t\t\t\treturn master.then();\n\t\t\t}\n\t\t}\n\n\t\t// Multiple arguments are aggregated like Promise.all array elements\n\t\twhile ( i-- ) {\n\t\t\tadoptValue( resolveValues[ i ], updateFunc( i ), master.reject );\n\t\t}\n\n\t\treturn master.promise();\n\t}\n} );\n\n\n// These usually indicate a programmer mistake during development,\n// warn about them ASAP rather than swallowing them by default.\nvar rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;\n\njQuery.Deferred.exceptionHook = function( error, stack ) {\n\n\t// Support: IE 8 - 9 only\n\t// Console exists when dev tools are open, which can happen at any time\n\tif ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {\n\t\twindow.console.warn( \"jQuery.Deferred exception: \" + error.message, error.stack, stack );\n\t}\n};\n\n\n\n\njQuery.readyException = function( error ) {\n\twindow.setTimeout( function() {\n\t\tthrow error;\n\t} );\n};\n\n\n\n\n// The deferred used on DOM ready\nvar readyList = jQuery.Deferred();\n\njQuery.fn.ready = function( fn ) {\n\n\treadyList\n\t\t.then( fn )\n\n\t\t// Wrap jQuery.readyException in a function so that the lookup\n\t\t// happens at the time of error handling instead of callback\n\t\t// registration.\n\t\t.catch( function( error ) {\n\t\t\tjQuery.readyException( error );\n\t\t} );\n\n\treturn this;\n};\n\njQuery.extend( {\n\n\t// Is the DOM ready to be used? Set to true once it occurs.\n\tisReady: false,\n\n\t// A counter to track how many items to wait for before\n\t// the ready event fires. See #6781\n\treadyWait: 1,\n\n\t// Handle when the DOM is ready\n\tready: function( wait ) {\n\n\t\t// Abort if there are pending holds or we're already ready\n\t\tif ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Remember that the DOM is ready\n\t\tjQuery.isReady = true;\n\n\t\t// If a normal DOM Ready event fired, decrement, and wait if need be\n\t\tif ( wait !== true && --jQuery.readyWait > 0 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// If there are functions bound, to execute\n\t\treadyList.resolveWith( document, [ jQuery ] );\n\t}\n} );\n\njQuery.ready.then = readyList.then;\n\n// The ready event handler and self cleanup method\nfunction completed() {\n\tdocument.removeEventListener( \"DOMContentLoaded\", completed );\n\twindow.removeEventListener( \"load\", completed );\n\tjQuery.ready();\n}\n\n// Catch cases where $(document).ready() is called\n// after the browser event has already occurred.\n// Support: IE <=9 - 10 only\n// Older IE sometimes signals \"interactive\" too soon\nif ( document.readyState === \"complete\" ||\n\t( document.readyState !== \"loading\" && !document.documentElement.doScroll ) ) {\n\n\t// Handle it asynchronously to allow scripts the opportunity to delay ready\n\twindow.setTimeout( jQuery.ready );\n\n} else {\n\n\t// Use the handy event callback\n\tdocument.addEventListener( \"DOMContentLoaded\", completed );\n\n\t// A fallback to window.onload, that will always work\n\twindow.addEventListener( \"load\", completed );\n}\n\n\n\n\n// Multifunctional method to get and set values of a collection\n// The value/s can optionally be executed if it's a function\nvar access = function( elems, fn, key, value, chainable, emptyGet, raw ) {\n\tvar i = 0,\n\t\tlen = elems.length,\n\t\tbulk = key == null;\n\n\t// Sets many values\n\tif ( jQuery.type( key ) === \"object\" ) {\n\t\tchainable = true;\n\t\tfor ( i in key ) {\n\t\t\taccess( elems, fn, i, key[ i ], true, emptyGet, raw );\n\t\t}\n\n\t// Sets one value\n\t} else if ( value !== undefined ) {\n\t\tchainable = true;\n\n\t\tif ( !jQuery.isFunction( value ) ) {\n\t\t\traw = true;\n\t\t}\n\n\t\tif ( bulk ) {\n\n\t\t\t// Bulk operations run against the entire set\n\t\t\tif ( raw ) {\n\t\t\t\tfn.call( elems, value );\n\t\t\t\tfn = null;\n\n\t\t\t// ...except when executing function values\n\t\t\t} else {\n\t\t\t\tbulk = fn;\n\t\t\t\tfn = function( elem, key, value ) {\n\t\t\t\t\treturn bulk.call( jQuery( elem ), value );\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif ( fn ) {\n\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\tfn(\n\t\t\t\t\telems[ i ], key, raw ?\n\t\t\t\t\tvalue :\n\t\t\t\t\tvalue.call( elems[ i ], i, fn( elems[ i ], key ) )\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( chainable ) {\n\t\treturn elems;\n\t}\n\n\t// Gets\n\tif ( bulk ) {\n\t\treturn fn.call( elems );\n\t}\n\n\treturn len ? fn( elems[ 0 ], key ) : emptyGet;\n};\nvar acceptData = function( owner ) {\n\n\t// Accepts only:\n\t//  - Node\n\t//    - Node.ELEMENT_NODE\n\t//    - Node.DOCUMENT_NODE\n\t//  - Object\n\t//    - Any\n\treturn owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );\n};\n\n\n\n\nfunction Data() {\n\tthis.expando = jQuery.expando + Data.uid++;\n}\n\nData.uid = 1;\n\nData.prototype = {\n\n\tcache: function( owner ) {\n\n\t\t// Check if the owner object already has a cache\n\t\tvar value = owner[ this.expando ];\n\n\t\t// If not, create one\n\t\tif ( !value ) {\n\t\t\tvalue = {};\n\n\t\t\t// We can accept data for non-element nodes in modern browsers,\n\t\t\t// but we should not, see #8335.\n\t\t\t// Always return an empty object.\n\t\t\tif ( acceptData( owner ) ) {\n\n\t\t\t\t// If it is a node unlikely to be stringify-ed or looped over\n\t\t\t\t// use plain assignment\n\t\t\t\tif ( owner.nodeType ) {\n\t\t\t\t\towner[ this.expando ] = value;\n\n\t\t\t\t// Otherwise secure it in a non-enumerable property\n\t\t\t\t// configurable must be true to allow the property to be\n\t\t\t\t// deleted when data is removed\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty( owner, this.expando, {\n\t\t\t\t\t\tvalue: value,\n\t\t\t\t\t\tconfigurable: true\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn value;\n\t},\n\tset: function( owner, data, value ) {\n\t\tvar prop,\n\t\t\tcache = this.cache( owner );\n\n\t\t// Handle: [ owner, key, value ] args\n\t\t// Always use camelCase key (gh-2257)\n\t\tif ( typeof data === \"string\" ) {\n\t\t\tcache[ jQuery.camelCase( data ) ] = value;\n\n\t\t// Handle: [ owner, { properties } ] args\n\t\t} else {\n\n\t\t\t// Copy the properties one-by-one to the cache object\n\t\t\tfor ( prop in data ) {\n\t\t\t\tcache[ jQuery.camelCase( prop ) ] = data[ prop ];\n\t\t\t}\n\t\t}\n\t\treturn cache;\n\t},\n\tget: function( owner, key ) {\n\t\treturn key === undefined ?\n\t\t\tthis.cache( owner ) :\n\n\t\t\t// Always use camelCase key (gh-2257)\n\t\t\towner[ this.expando ] && owner[ this.expando ][ jQuery.camelCase( key ) ];\n\t},\n\taccess: function( owner, key, value ) {\n\n\t\t// In cases where either:\n\t\t//\n\t\t//   1. No key was specified\n\t\t//   2. A string key was specified, but no value provided\n\t\t//\n\t\t// Take the \"read\" path and allow the get method to determine\n\t\t// which value to return, respectively either:\n\t\t//\n\t\t//   1. The entire cache object\n\t\t//   2. The data stored at the key\n\t\t//\n\t\tif ( key === undefined ||\n\t\t\t\t( ( key && typeof key === \"string\" ) && value === undefined ) ) {\n\n\t\t\treturn this.get( owner, key );\n\t\t}\n\n\t\t// When the key is not a string, or both a key and value\n\t\t// are specified, set or extend (existing objects) with either:\n\t\t//\n\t\t//   1. An object of properties\n\t\t//   2. A key and value\n\t\t//\n\t\tthis.set( owner, key, value );\n\n\t\t// Since the \"set\" path can have two possible entry points\n\t\t// return the expected data based on which path was taken[*]\n\t\treturn value !== undefined ? value : key;\n\t},\n\tremove: function( owner, key ) {\n\t\tvar i,\n\t\t\tcache = owner[ this.expando ];\n\n\t\tif ( cache === undefined ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( key !== undefined ) {\n\n\t\t\t// Support array or space separated string of keys\n\t\t\tif ( Array.isArray( key ) ) {\n\n\t\t\t\t// If key is an array of keys...\n\t\t\t\t// We always set camelCase keys, so remove that.\n\t\t\t\tkey = key.map( jQuery.camelCase );\n\t\t\t} else {\n\t\t\t\tkey = jQuery.camelCase( key );\n\n\t\t\t\t// If a key with the spaces exists, use it.\n\t\t\t\t// Otherwise, create an array by matching non-whitespace\n\t\t\t\tkey = key in cache ?\n\t\t\t\t\t[ key ] :\n\t\t\t\t\t( key.match( rnothtmlwhite ) || [] );\n\t\t\t}\n\n\t\t\ti = key.length;\n\n\t\t\twhile ( i-- ) {\n\t\t\t\tdelete cache[ key[ i ] ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove the expando if there's no more data\n\t\tif ( key === undefined || jQuery.isEmptyObject( cache ) ) {\n\n\t\t\t// Support: Chrome <=35 - 45\n\t\t\t// Webkit & Blink performance suffers when deleting properties\n\t\t\t// from DOM nodes, so set to undefined instead\n\t\t\t// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)\n\t\t\tif ( owner.nodeType ) {\n\t\t\t\towner[ this.expando ] = undefined;\n\t\t\t} else {\n\t\t\t\tdelete owner[ this.expando ];\n\t\t\t}\n\t\t}\n\t},\n\thasData: function( owner ) {\n\t\tvar cache = owner[ this.expando ];\n\t\treturn cache !== undefined && !jQuery.isEmptyObject( cache );\n\t}\n};\nvar dataPriv = new Data();\n\nvar dataUser = new Data();\n\n\n\n//\tImplementation Summary\n//\n//\t1. Enforce API surface and semantic compatibility with 1.9.x branch\n//\t2. Improve the module's maintainability by reducing the storage\n//\t\tpaths to a single mechanism.\n//\t3. Use the same single mechanism to support \"private\" and \"user\" data.\n//\t4. _Never_ expose \"private\" data to user code (TODO: Drop _data, _removeData)\n//\t5. Avoid exposing implementation details on user objects (eg. expando properties)\n//\t6. Provide a clear path for implementation upgrade to WeakMap in 2014\n\nvar rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n\trmultiDash = /[A-Z]/g;\n\nfunction getData( data ) {\n\tif ( data === \"true\" ) {\n\t\treturn true;\n\t}\n\n\tif ( data === \"false\" ) {\n\t\treturn false;\n\t}\n\n\tif ( data === \"null\" ) {\n\t\treturn null;\n\t}\n\n\t// Only convert to a number if it doesn't change the string\n\tif ( data === +data + \"\" ) {\n\t\treturn +data;\n\t}\n\n\tif ( rbrace.test( data ) ) {\n\t\treturn JSON.parse( data );\n\t}\n\n\treturn data;\n}\n\nfunction dataAttr( elem, key, data ) {\n\tvar name;\n\n\t// If nothing was found internally, try to fetch any\n\t// data from the HTML5 data-* attribute\n\tif ( data === undefined && elem.nodeType === 1 ) {\n\t\tname = \"data-\" + key.replace( rmultiDash, \"-$&\" ).toLowerCase();\n\t\tdata = elem.getAttribute( name );\n\n\t\tif ( typeof data === \"string\" ) {\n\t\t\ttry {\n\t\t\t\tdata = getData( data );\n\t\t\t} catch ( e ) {}\n\n\t\t\t// Make sure we set the data so it isn't changed later\n\t\t\tdataUser.set( elem, key, data );\n\t\t} else {\n\t\t\tdata = undefined;\n\t\t}\n\t}\n\treturn data;\n}\n\njQuery.extend( {\n\thasData: function( elem ) {\n\t\treturn dataUser.hasData( elem ) || dataPriv.hasData( elem );\n\t},\n\n\tdata: function( elem, name, data ) {\n\t\treturn dataUser.access( elem, name, data );\n\t},\n\n\tremoveData: function( elem, name ) {\n\t\tdataUser.remove( elem, name );\n\t},\n\n\t// TODO: Now that all calls to _data and _removeData have been replaced\n\t// with direct calls to dataPriv methods, these can be deprecated.\n\t_data: function( elem, name, data ) {\n\t\treturn dataPriv.access( elem, name, data );\n\t},\n\n\t_removeData: function( elem, name ) {\n\t\tdataPriv.remove( elem, name );\n\t}\n} );\n\njQuery.fn.extend( {\n\tdata: function( key, value ) {\n\t\tvar i, name, data,\n\t\t\telem = this[ 0 ],\n\t\t\tattrs = elem && elem.attributes;\n\n\t\t// Gets all values\n\t\tif ( key === undefined ) {\n\t\t\tif ( this.length ) {\n\t\t\t\tdata = dataUser.get( elem );\n\n\t\t\t\tif ( elem.nodeType === 1 && !dataPriv.get( elem, \"hasDataAttrs\" ) ) {\n\t\t\t\t\ti = attrs.length;\n\t\t\t\t\twhile ( i-- ) {\n\n\t\t\t\t\t\t// Support: IE 11 only\n\t\t\t\t\t\t// The attrs elements can be null (#14894)\n\t\t\t\t\t\tif ( attrs[ i ] ) {\n\t\t\t\t\t\t\tname = attrs[ i ].name;\n\t\t\t\t\t\t\tif ( name.indexOf( \"data-\" ) === 0 ) {\n\t\t\t\t\t\t\t\tname = jQuery.camelCase( name.slice( 5 ) );\n\t\t\t\t\t\t\t\tdataAttr( elem, name, data[ name ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tdataPriv.set( elem, \"hasDataAttrs\", true );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn data;\n\t\t}\n\n\t\t// Sets multiple values\n\t\tif ( typeof key === \"object\" ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tdataUser.set( this, key );\n\t\t\t} );\n\t\t}\n\n\t\treturn access( this, function( value ) {\n\t\t\tvar data;\n\n\t\t\t// The calling jQuery object (element matches) is not empty\n\t\t\t// (and therefore has an element appears at this[ 0 ]) and the\n\t\t\t// `value` parameter was not undefined. An empty jQuery object\n\t\t\t// will result in `undefined` for elem = this[ 0 ] which will\n\t\t\t// throw an exception if an attempt to read a data cache is made.\n\t\t\tif ( elem && value === undefined ) {\n\n\t\t\t\t// Attempt to get data from the cache\n\t\t\t\t// The key will always be camelCased in Data\n\t\t\t\tdata = dataUser.get( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// Attempt to \"discover\" the data in\n\t\t\t\t// HTML5 custom data-* attrs\n\t\t\t\tdata = dataAttr( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// We tried really hard, but the data doesn't exist.\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Set the data...\n\t\t\tthis.each( function() {\n\n\t\t\t\t// We always store the camelCased key\n\t\t\t\tdataUser.set( this, key, value );\n\t\t\t} );\n\t\t}, null, value, arguments.length > 1, null, true );\n\t},\n\n\tremoveData: function( key ) {\n\t\treturn this.each( function() {\n\t\t\tdataUser.remove( this, key );\n\t\t} );\n\t}\n} );\n\n\njQuery.extend( {\n\tqueue: function( elem, type, data ) {\n\t\tvar queue;\n\n\t\tif ( elem ) {\n\t\t\ttype = ( type || \"fx\" ) + \"queue\";\n\t\t\tqueue = dataPriv.get( elem, type );\n\n\t\t\t// Speed up dequeue by getting out quickly if this is just a lookup\n\t\t\tif ( data ) {\n\t\t\t\tif ( !queue || Array.isArray( data ) ) {\n\t\t\t\t\tqueue = dataPriv.access( elem, type, jQuery.makeArray( data ) );\n\t\t\t\t} else {\n\t\t\t\t\tqueue.push( data );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn queue || [];\n\t\t}\n\t},\n\n\tdequeue: function( elem, type ) {\n\t\ttype = type || \"fx\";\n\n\t\tvar queue = jQuery.queue( elem, type ),\n\t\t\tstartLength = queue.length,\n\t\t\tfn = queue.shift(),\n\t\t\thooks = jQuery._queueHooks( elem, type ),\n\t\t\tnext = function() {\n\t\t\t\tjQuery.dequeue( elem, type );\n\t\t\t};\n\n\t\t// If the fx queue is dequeued, always remove the progress sentinel\n\t\tif ( fn === \"inprogress\" ) {\n\t\t\tfn = queue.shift();\n\t\t\tstartLength--;\n\t\t}\n\n\t\tif ( fn ) {\n\n\t\t\t// Add a progress sentinel to prevent the fx queue from being\n\t\t\t// automatically dequeued\n\t\t\tif ( type === \"fx\" ) {\n\t\t\t\tqueue.unshift( \"inprogress\" );\n\t\t\t}\n\n\t\t\t// Clear up the last queue stop function\n\t\t\tdelete hooks.stop;\n\t\t\tfn.call( elem, next, hooks );\n\t\t}\n\n\t\tif ( !startLength && hooks ) {\n\t\t\thooks.empty.fire();\n\t\t}\n\t},\n\n\t// Not public - generate a queueHooks object, or return the current one\n\t_queueHooks: function( elem, type ) {\n\t\tvar key = type + \"queueHooks\";\n\t\treturn dataPriv.get( elem, key ) || dataPriv.access( elem, key, {\n\t\t\tempty: jQuery.Callbacks( \"once memory\" ).add( function() {\n\t\t\t\tdataPriv.remove( elem, [ type + \"queue\", key ] );\n\t\t\t} )\n\t\t} );\n\t}\n} );\n\njQuery.fn.extend( {\n\tqueue: function( type, data ) {\n\t\tvar setter = 2;\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tdata = type;\n\t\t\ttype = \"fx\";\n\t\t\tsetter--;\n\t\t}\n\n\t\tif ( arguments.length < setter ) {\n\t\t\treturn jQuery.queue( this[ 0 ], type );\n\t\t}\n\n\t\treturn data === undefined ?\n\t\t\tthis :\n\t\t\tthis.each( function() {\n\t\t\t\tvar queue = jQuery.queue( this, type, data );\n\n\t\t\t\t// Ensure a hooks for this queue\n\t\t\t\tjQuery._queueHooks( this, type );\n\n\t\t\t\tif ( type === \"fx\" && queue[ 0 ] !== \"inprogress\" ) {\n\t\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t\t}\n\t\t\t} );\n\t},\n\tdequeue: function( type ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.dequeue( this, type );\n\t\t} );\n\t},\n\tclearQueue: function( type ) {\n\t\treturn this.queue( type || \"fx\", [] );\n\t},\n\n\t// Get a promise resolved when queues of a certain type\n\t// are emptied (fx is the type by default)\n\tpromise: function( type, obj ) {\n\t\tvar tmp,\n\t\t\tcount = 1,\n\t\t\tdefer = jQuery.Deferred(),\n\t\t\telements = this,\n\t\t\ti = this.length,\n\t\t\tresolve = function() {\n\t\t\t\tif ( !( --count ) ) {\n\t\t\t\t\tdefer.resolveWith( elements, [ elements ] );\n\t\t\t\t}\n\t\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tobj = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\ttype = type || \"fx\";\n\n\t\twhile ( i-- ) {\n\t\t\ttmp = dataPriv.get( elements[ i ], type + \"queueHooks\" );\n\t\t\tif ( tmp && tmp.empty ) {\n\t\t\t\tcount++;\n\t\t\t\ttmp.empty.add( resolve );\n\t\t\t}\n\t\t}\n\t\tresolve();\n\t\treturn defer.promise( obj );\n\t}\n} );\nvar pnum = ( /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/ ).source;\n\nvar rcssNum = new RegExp( \"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\" );\n\n\nvar cssExpand = [ \"Top\", \"Right\", \"Bottom\", \"Left\" ];\n\nvar isHiddenWithinTree = function( elem, el ) {\n\n\t\t// isHiddenWithinTree might be called from jQuery#filter function;\n\t\t// in that case, element will be second argument\n\t\telem = el || elem;\n\n\t\t// Inline style trumps all\n\t\treturn elem.style.display === \"none\" ||\n\t\t\telem.style.display === \"\" &&\n\n\t\t\t// Otherwise, check computed style\n\t\t\t// Support: Firefox <=43 - 45\n\t\t\t// Disconnected elements can have computed display: none, so first confirm that elem is\n\t\t\t// in the document.\n\t\t\tjQuery.contains( elem.ownerDocument, elem ) &&\n\n\t\t\tjQuery.css( elem, \"display\" ) === \"none\";\n\t};\n\nvar swap = function( elem, options, callback, args ) {\n\tvar ret, name,\n\t\told = {};\n\n\t// Remember the old values, and insert the new ones\n\tfor ( name in options ) {\n\t\told[ name ] = elem.style[ name ];\n\t\telem.style[ name ] = options[ name ];\n\t}\n\n\tret = callback.apply( elem, args || [] );\n\n\t// Revert the old values\n\tfor ( name in options ) {\n\t\telem.style[ name ] = old[ name ];\n\t}\n\n\treturn ret;\n};\n\n\n\n\nfunction adjustCSS( elem, prop, valueParts, tween ) {\n\tvar adjusted,\n\t\tscale = 1,\n\t\tmaxIterations = 20,\n\t\tcurrentValue = tween ?\n\t\t\tfunction() {\n\t\t\t\treturn tween.cur();\n\t\t\t} :\n\t\t\tfunction() {\n\t\t\t\treturn jQuery.css( elem, prop, \"\" );\n\t\t\t},\n\t\tinitial = currentValue(),\n\t\tunit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" ),\n\n\t\t// Starting value computation is required for potential unit mismatches\n\t\tinitialInUnit = ( jQuery.cssNumber[ prop ] || unit !== \"px\" && +initial ) &&\n\t\t\trcssNum.exec( jQuery.css( elem, prop ) );\n\n\tif ( initialInUnit && initialInUnit[ 3 ] !== unit ) {\n\n\t\t// Trust units reported by jQuery.css\n\t\tunit = unit || initialInUnit[ 3 ];\n\n\t\t// Make sure we update the tween properties later on\n\t\tvalueParts = valueParts || [];\n\n\t\t// Iteratively approximate from a nonzero starting point\n\t\tinitialInUnit = +initial || 1;\n\n\t\tdo {\n\n\t\t\t// If previous iteration zeroed out, double until we get *something*.\n\t\t\t// Use string for doubling so we don't accidentally see scale as unchanged below\n\t\t\tscale = scale || \".5\";\n\n\t\t\t// Adjust and apply\n\t\t\tinitialInUnit = initialInUnit / scale;\n\t\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\n\t\t// Update scale, tolerating zero or NaN from tween.cur()\n\t\t// Break the loop if scale is unchanged or perfect, or if we've just had enough.\n\t\t} while (\n\t\t\tscale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations\n\t\t);\n\t}\n\n\tif ( valueParts ) {\n\t\tinitialInUnit = +initialInUnit || +initial || 0;\n\n\t\t// Apply relative offset (+=/-=) if specified\n\t\tadjusted = valueParts[ 1 ] ?\n\t\t\tinitialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :\n\t\t\t+valueParts[ 2 ];\n\t\tif ( tween ) {\n\t\t\ttween.unit = unit;\n\t\t\ttween.start = initialInUnit;\n\t\t\ttween.end = adjusted;\n\t\t}\n\t}\n\treturn adjusted;\n}\n\n\nvar defaultDisplayMap = {};\n\nfunction getDefaultDisplay( elem ) {\n\tvar temp,\n\t\tdoc = elem.ownerDocument,\n\t\tnodeName = elem.nodeName,\n\t\tdisplay = defaultDisplayMap[ nodeName ];\n\n\tif ( display ) {\n\t\treturn display;\n\t}\n\n\ttemp = doc.body.appendChild( doc.createElement( nodeName ) );\n\tdisplay = jQuery.css( temp, \"display\" );\n\n\ttemp.parentNode.removeChild( temp );\n\n\tif ( display === \"none\" ) {\n\t\tdisplay = \"block\";\n\t}\n\tdefaultDisplayMap[ nodeName ] = display;\n\n\treturn display;\n}\n\nfunction showHide( elements, show ) {\n\tvar display, elem,\n\t\tvalues = [],\n\t\tindex = 0,\n\t\tlength = elements.length;\n\n\t// Determine new display value for elements that need to change\n\tfor ( ; index < length; index++ ) {\n\t\telem = elements[ index ];\n\t\tif ( !elem.style ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tdisplay = elem.style.display;\n\t\tif ( show ) {\n\n\t\t\t// Since we force visibility upon cascade-hidden elements, an immediate (and slow)\n\t\t\t// check is required in this first loop unless we have a nonempty display value (either\n\t\t\t// inline or about-to-be-restored)\n\t\t\tif ( display === \"none\" ) {\n\t\t\t\tvalues[ index ] = dataPriv.get( elem, \"display\" ) || null;\n\t\t\t\tif ( !values[ index ] ) {\n\t\t\t\t\telem.style.display = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t\tif ( elem.style.display === \"\" && isHiddenWithinTree( elem ) ) {\n\t\t\t\tvalues[ index ] = getDefaultDisplay( elem );\n\t\t\t}\n\t\t} else {\n\t\t\tif ( display !== \"none\" ) {\n\t\t\t\tvalues[ index ] = \"none\";\n\n\t\t\t\t// Remember what we're overwriting\n\t\t\t\tdataPriv.set( elem, \"display\", display );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Set the display of the elements in a second loop to avoid constant reflow\n\tfor ( index = 0; index < length; index++ ) {\n\t\tif ( values[ index ] != null ) {\n\t\t\telements[ index ].style.display = values[ index ];\n\t\t}\n\t}\n\n\treturn elements;\n}\n\njQuery.fn.extend( {\n\tshow: function() {\n\t\treturn showHide( this, true );\n\t},\n\thide: function() {\n\t\treturn showHide( this );\n\t},\n\ttoggle: function( state ) {\n\t\tif ( typeof state === \"boolean\" ) {\n\t\t\treturn state ? this.show() : this.hide();\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tif ( isHiddenWithinTree( this ) ) {\n\t\t\t\tjQuery( this ).show();\n\t\t\t} else {\n\t\t\t\tjQuery( this ).hide();\n\t\t\t}\n\t\t} );\n\t}\n} );\nvar rcheckableType = ( /^(?:checkbox|radio)$/i );\n\nvar rtagName = ( /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]+)/i );\n\nvar rscriptType = ( /^$|\\/(?:java|ecma)script/i );\n\n\n\n// We have to close these tags to support XHTML (#13200)\nvar wrapMap = {\n\n\t// Support: IE <=9 only\n\toption: [ 1, \"<select multiple='multiple'>\", \"</select>\" ],\n\n\t// XHTML parsers do not magically insert elements in the\n\t// same way that tag soup parsers do. So we cannot shorten\n\t// this by omitting <tbody> or other required elements.\n\tthead: [ 1, \"<table>\", \"</table>\" ],\n\tcol: [ 2, \"<table><colgroup>\", \"</colgroup></table>\" ],\n\ttr: [ 2, \"<table><tbody>\", \"</tbody></table>\" ],\n\ttd: [ 3, \"<table><tbody><tr>\", \"</tr></tbody></table>\" ],\n\n\t_default: [ 0, \"\", \"\" ]\n};\n\n// Support: IE <=9 only\nwrapMap.optgroup = wrapMap.option;\n\nwrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\nwrapMap.th = wrapMap.td;\n\n\nfunction getAll( context, tag ) {\n\n\t// Support: IE <=9 - 11 only\n\t// Use typeof to avoid zero-argument method invocation on host objects (#15151)\n\tvar ret;\n\n\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\tret = context.getElementsByTagName( tag || \"*\" );\n\n\t} else if ( typeof context.querySelectorAll !== \"undefined\" ) {\n\t\tret = context.querySelectorAll( tag || \"*\" );\n\n\t} else {\n\t\tret = [];\n\t}\n\n\tif ( tag === undefined || tag && nodeName( context, tag ) ) {\n\t\treturn jQuery.merge( [ context ], ret );\n\t}\n\n\treturn ret;\n}\n\n\n// Mark scripts as having already been evaluated\nfunction setGlobalEval( elems, refElements ) {\n\tvar i = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\tdataPriv.set(\n\t\t\telems[ i ],\n\t\t\t\"globalEval\",\n\t\t\t!refElements || dataPriv.get( refElements[ i ], \"globalEval\" )\n\t\t);\n\t}\n}\n\n\nvar rhtml = /<|&#?\\w+;/;\n\nfunction buildFragment( elems, context, scripts, selection, ignored ) {\n\tvar elem, tmp, tag, wrap, contains, j,\n\t\tfragment = context.createDocumentFragment(),\n\t\tnodes = [],\n\t\ti = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\telem = elems[ i ];\n\n\t\tif ( elem || elem === 0 ) {\n\n\t\t\t// Add nodes directly\n\t\t\tif ( jQuery.type( elem ) === \"object\" ) {\n\n\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );\n\n\t\t\t// Convert non-html into a text node\n\t\t\t} else if ( !rhtml.test( elem ) ) {\n\t\t\t\tnodes.push( context.createTextNode( elem ) );\n\n\t\t\t// Convert html into DOM nodes\n\t\t\t} else {\n\t\t\t\ttmp = tmp || fragment.appendChild( context.createElement( \"div\" ) );\n\n\t\t\t\t// Deserialize a standard representation\n\t\t\t\ttag = ( rtagName.exec( elem ) || [ \"\", \"\" ] )[ 1 ].toLowerCase();\n\t\t\t\twrap = wrapMap[ tag ] || wrapMap._default;\n\t\t\t\ttmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];\n\n\t\t\t\t// Descend through wrappers to the right content\n\t\t\t\tj = wrap[ 0 ];\n\t\t\t\twhile ( j-- ) {\n\t\t\t\t\ttmp = tmp.lastChild;\n\t\t\t\t}\n\n\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, tmp.childNodes );\n\n\t\t\t\t// Remember the top-level container\n\t\t\t\ttmp = fragment.firstChild;\n\n\t\t\t\t// Ensure the created nodes are orphaned (#12392)\n\t\t\t\ttmp.textContent = \"\";\n\t\t\t}\n\t\t}\n\t}\n\n\t// Remove wrapper from fragment\n\tfragment.textContent = \"\";\n\n\ti = 0;\n\twhile ( ( elem = nodes[ i++ ] ) ) {\n\n\t\t// Skip elements already in the context collection (trac-4087)\n\t\tif ( selection && jQuery.inArray( elem, selection ) > -1 ) {\n\t\t\tif ( ignored ) {\n\t\t\t\tignored.push( elem );\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\tcontains = jQuery.contains( elem.ownerDocument, elem );\n\n\t\t// Append to fragment\n\t\ttmp = getAll( fragment.appendChild( elem ), \"script\" );\n\n\t\t// Preserve script evaluation history\n\t\tif ( contains ) {\n\t\t\tsetGlobalEval( tmp );\n\t\t}\n\n\t\t// Capture executables\n\t\tif ( scripts ) {\n\t\t\tj = 0;\n\t\t\twhile ( ( elem = tmp[ j++ ] ) ) {\n\t\t\t\tif ( rscriptType.test( elem.type || \"\" ) ) {\n\t\t\t\t\tscripts.push( elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn fragment;\n}\n\n\n( function() {\n\tvar fragment = document.createDocumentFragment(),\n\t\tdiv = fragment.appendChild( document.createElement( \"div\" ) ),\n\t\tinput = document.createElement( \"input\" );\n\n\t// Support: Android 4.0 - 4.3 only\n\t// Check state lost if the name is set (#11217)\n\t// Support: Windows Web Apps (WWA)\n\t// `name` and `type` must use .setAttribute for WWA (#14901)\n\tinput.setAttribute( \"type\", \"radio\" );\n\tinput.setAttribute( \"checked\", \"checked\" );\n\tinput.setAttribute( \"name\", \"t\" );\n\n\tdiv.appendChild( input );\n\n\t// Support: Android <=4.1 only\n\t// Older WebKit doesn't clone checked state correctly in fragments\n\tsupport.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;\n\n\t// Support: IE <=11 only\n\t// Make sure textarea (and checkbox) defaultValue is properly cloned\n\tdiv.innerHTML = \"<textarea>x</textarea>\";\n\tsupport.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;\n} )();\nvar documentElement = document.documentElement;\n\n\n\nvar\n\trkeyEvent = /^key/,\n\trmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,\n\trtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\nfunction returnTrue() {\n\treturn true;\n}\n\nfunction returnFalse() {\n\treturn false;\n}\n\n// Support: IE <=9 only\n// See #13393 for more info\nfunction safeActiveElement() {\n\ttry {\n\t\treturn document.activeElement;\n\t} catch ( err ) { }\n}\n\nfunction on( elem, types, selector, data, fn, one ) {\n\tvar origFn, type;\n\n\t// Types can be a map of types/handlers\n\tif ( typeof types === \"object\" ) {\n\n\t\t// ( types-Object, selector, data )\n\t\tif ( typeof selector !== \"string\" ) {\n\n\t\t\t// ( types-Object, data )\n\t\t\tdata = data || selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tfor ( type in types ) {\n\t\t\ton( elem, type, selector, data, types[ type ], one );\n\t\t}\n\t\treturn elem;\n\t}\n\n\tif ( data == null && fn == null ) {\n\n\t\t// ( types, fn )\n\t\tfn = selector;\n\t\tdata = selector = undefined;\n\t} else if ( fn == null ) {\n\t\tif ( typeof selector === \"string\" ) {\n\n\t\t\t// ( types, selector, fn )\n\t\t\tfn = data;\n\t\t\tdata = undefined;\n\t\t} else {\n\n\t\t\t// ( types, data, fn )\n\t\t\tfn = data;\n\t\t\tdata = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t}\n\tif ( fn === false ) {\n\t\tfn = returnFalse;\n\t} else if ( !fn ) {\n\t\treturn elem;\n\t}\n\n\tif ( one === 1 ) {\n\t\torigFn = fn;\n\t\tfn = function( event ) {\n\n\t\t\t// Can use an empty set, since event contains the info\n\t\t\tjQuery().off( event );\n\t\t\treturn origFn.apply( this, arguments );\n\t\t};\n\n\t\t// Use same guid so caller can remove using origFn\n\t\tfn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );\n\t}\n\treturn elem.each( function() {\n\t\tjQuery.event.add( this, types, fn, data, selector );\n\t} );\n}\n\n/*\n * Helper functions for managing events -- not part of the public interface.\n * Props to Dean Edwards' addEvent library for many of the ideas.\n */\njQuery.event = {\n\n\tglobal: {},\n\n\tadd: function( elem, types, handler, data, selector ) {\n\n\t\tvar handleObjIn, eventHandle, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.get( elem );\n\n\t\t// Don't attach events to noData or text/comment nodes (but allow plain objects)\n\t\tif ( !elemData ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Caller can pass in an object of custom data in lieu of the handler\n\t\tif ( handler.handler ) {\n\t\t\thandleObjIn = handler;\n\t\t\thandler = handleObjIn.handler;\n\t\t\tselector = handleObjIn.selector;\n\t\t}\n\n\t\t// Ensure that invalid selectors throw exceptions at attach time\n\t\t// Evaluate against documentElement in case elem is a non-element node (e.g., document)\n\t\tif ( selector ) {\n\t\t\tjQuery.find.matchesSelector( documentElement, selector );\n\t\t}\n\n\t\t// Make sure that the handler has a unique ID, used to find/remove it later\n\t\tif ( !handler.guid ) {\n\t\t\thandler.guid = jQuery.guid++;\n\t\t}\n\n\t\t// Init the element's event structure and main handler, if this is the first\n\t\tif ( !( events = elemData.events ) ) {\n\t\t\tevents = elemData.events = {};\n\t\t}\n\t\tif ( !( eventHandle = elemData.handle ) ) {\n\t\t\teventHandle = elemData.handle = function( e ) {\n\n\t\t\t\t// Discard the second event of a jQuery.event.trigger() and\n\t\t\t\t// when an event is called after a page has unloaded\n\t\t\t\treturn typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ?\n\t\t\t\t\tjQuery.event.dispatch.apply( elem, arguments ) : undefined;\n\t\t\t};\n\t\t}\n\n\t\t// Handle multiple events separated by a space\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// There *must* be a type, no attaching namespace-only handlers\n\t\t\tif ( !type ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// If event changes its type, use the special event handlers for the changed type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// If selector defined, determine special event api type, otherwise given type\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\n\t\t\t// Update special based on newly reset type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// handleObj is passed to all event handlers\n\t\t\thandleObj = jQuery.extend( {\n\t\t\t\ttype: type,\n\t\t\t\torigType: origType,\n\t\t\t\tdata: data,\n\t\t\t\thandler: handler,\n\t\t\t\tguid: handler.guid,\n\t\t\t\tselector: selector,\n\t\t\t\tneedsContext: selector && jQuery.expr.match.needsContext.test( selector ),\n\t\t\t\tnamespace: namespaces.join( \".\" )\n\t\t\t}, handleObjIn );\n\n\t\t\t// Init the event handler queue if we're the first\n\t\t\tif ( !( handlers = events[ type ] ) ) {\n\t\t\t\thandlers = events[ type ] = [];\n\t\t\t\thandlers.delegateCount = 0;\n\n\t\t\t\t// Only use addEventListener if the special events handler returns false\n\t\t\t\tif ( !special.setup ||\n\t\t\t\t\tspecial.setup.call( elem, data, namespaces, eventHandle ) === false ) {\n\n\t\t\t\t\tif ( elem.addEventListener ) {\n\t\t\t\t\t\telem.addEventListener( type, eventHandle );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif ( special.add ) {\n\t\t\t\tspecial.add.call( elem, handleObj );\n\n\t\t\t\tif ( !handleObj.handler.guid ) {\n\t\t\t\t\thandleObj.handler.guid = handler.guid;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Add to the element's handler list, delegates in front\n\t\t\tif ( selector ) {\n\t\t\t\thandlers.splice( handlers.delegateCount++, 0, handleObj );\n\t\t\t} else {\n\t\t\t\thandlers.push( handleObj );\n\t\t\t}\n\n\t\t\t// Keep track of which events have ever been used, for event optimization\n\t\t\tjQuery.event.global[ type ] = true;\n\t\t}\n\n\t},\n\n\t// Detach an event or set of events from an element\n\tremove: function( elem, types, handler, selector, mappedTypes ) {\n\n\t\tvar j, origCount, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.hasData( elem ) && dataPriv.get( elem );\n\n\t\tif ( !elemData || !( events = elemData.events ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Once for each type.namespace in types; type may be omitted\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// Unbind all events (on this namespace, if provided) for the element\n\t\t\tif ( !type ) {\n\t\t\t\tfor ( type in events ) {\n\t\t\t\t\tjQuery.event.remove( elem, type + types[ t ], handler, selector, true );\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\t\t\thandlers = events[ type ] || [];\n\t\t\ttmp = tmp[ 2 ] &&\n\t\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" );\n\n\t\t\t// Remove matching events\n\t\t\torigCount = j = handlers.length;\n\t\t\twhile ( j-- ) {\n\t\t\t\thandleObj = handlers[ j ];\n\n\t\t\t\tif ( ( mappedTypes || origType === handleObj.origType ) &&\n\t\t\t\t\t( !handler || handler.guid === handleObj.guid ) &&\n\t\t\t\t\t( !tmp || tmp.test( handleObj.namespace ) ) &&\n\t\t\t\t\t( !selector || selector === handleObj.selector ||\n\t\t\t\t\t\tselector === \"**\" && handleObj.selector ) ) {\n\t\t\t\t\thandlers.splice( j, 1 );\n\n\t\t\t\t\tif ( handleObj.selector ) {\n\t\t\t\t\t\thandlers.delegateCount--;\n\t\t\t\t\t}\n\t\t\t\t\tif ( special.remove ) {\n\t\t\t\t\t\tspecial.remove.call( elem, handleObj );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Remove generic event handler if we removed something and no more handlers exist\n\t\t\t// (avoids potential for endless recursion during removal of special event handlers)\n\t\t\tif ( origCount && !handlers.length ) {\n\t\t\t\tif ( !special.teardown ||\n\t\t\t\t\tspecial.teardown.call( elem, namespaces, elemData.handle ) === false ) {\n\n\t\t\t\t\tjQuery.removeEvent( elem, type, elemData.handle );\n\t\t\t\t}\n\n\t\t\t\tdelete events[ type ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove data and the expando if it's no longer used\n\t\tif ( jQuery.isEmptyObject( events ) ) {\n\t\t\tdataPriv.remove( elem, \"handle events\" );\n\t\t}\n\t},\n\n\tdispatch: function( nativeEvent ) {\n\n\t\t// Make a writable jQuery.Event from the native event object\n\t\tvar event = jQuery.event.fix( nativeEvent );\n\n\t\tvar i, j, ret, matched, handleObj, handlerQueue,\n\t\t\targs = new Array( arguments.length ),\n\t\t\thandlers = ( dataPriv.get( this, \"events\" ) || {} )[ event.type ] || [],\n\t\t\tspecial = jQuery.event.special[ event.type ] || {};\n\n\t\t// Use the fix-ed jQuery.Event rather than the (read-only) native event\n\t\targs[ 0 ] = event;\n\n\t\tfor ( i = 1; i < arguments.length; i++ ) {\n\t\t\targs[ i ] = arguments[ i ];\n\t\t}\n\n\t\tevent.delegateTarget = this;\n\n\t\t// Call the preDispatch hook for the mapped type, and let it bail if desired\n\t\tif ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine handlers\n\t\thandlerQueue = jQuery.event.handlers.call( this, event, handlers );\n\n\t\t// Run delegates first; they may want to stop propagation beneath us\n\t\ti = 0;\n\t\twhile ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tevent.currentTarget = matched.elem;\n\n\t\t\tj = 0;\n\t\t\twhile ( ( handleObj = matched.handlers[ j++ ] ) &&\n\t\t\t\t!event.isImmediatePropagationStopped() ) {\n\n\t\t\t\t// Triggered event must either 1) have no namespace, or 2) have namespace(s)\n\t\t\t\t// a subset or equal to those in the bound event (both can have no namespace).\n\t\t\t\tif ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {\n\n\t\t\t\t\tevent.handleObj = handleObj;\n\t\t\t\t\tevent.data = handleObj.data;\n\n\t\t\t\t\tret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||\n\t\t\t\t\t\thandleObj.handler ).apply( matched.elem, args );\n\n\t\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\t\tif ( ( event.result = ret ) === false ) {\n\t\t\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Call the postDispatch hook for the mapped type\n\t\tif ( special.postDispatch ) {\n\t\t\tspecial.postDispatch.call( this, event );\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\thandlers: function( event, handlers ) {\n\t\tvar i, handleObj, sel, matchedHandlers, matchedSelectors,\n\t\t\thandlerQueue = [],\n\t\t\tdelegateCount = handlers.delegateCount,\n\t\t\tcur = event.target;\n\n\t\t// Find delegate handlers\n\t\tif ( delegateCount &&\n\n\t\t\t// Support: IE <=9\n\t\t\t// Black-hole SVG <use> instance trees (trac-13180)\n\t\t\tcur.nodeType &&\n\n\t\t\t// Support: Firefox <=42\n\t\t\t// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)\n\t\t\t// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click\n\t\t\t// Support: IE 11 only\n\t\t\t// ...but not arrow key \"clicks\" of radio inputs, which can have `button` -1 (gh-2343)\n\t\t\t!( event.type === \"click\" && event.button >= 1 ) ) {\n\n\t\t\tfor ( ; cur !== this; cur = cur.parentNode || this ) {\n\n\t\t\t\t// Don't check non-elements (#13208)\n\t\t\t\t// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)\n\t\t\t\tif ( cur.nodeType === 1 && !( event.type === \"click\" && cur.disabled === true ) ) {\n\t\t\t\t\tmatchedHandlers = [];\n\t\t\t\t\tmatchedSelectors = {};\n\t\t\t\t\tfor ( i = 0; i < delegateCount; i++ ) {\n\t\t\t\t\t\thandleObj = handlers[ i ];\n\n\t\t\t\t\t\t// Don't conflict with Object.prototype properties (#13203)\n\t\t\t\t\t\tsel = handleObj.selector + \" \";\n\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] === undefined ) {\n\t\t\t\t\t\t\tmatchedSelectors[ sel ] = handleObj.needsContext ?\n\t\t\t\t\t\t\t\tjQuery( sel, this ).index( cur ) > -1 :\n\t\t\t\t\t\t\t\tjQuery.find( sel, this, null, [ cur ] ).length;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] ) {\n\t\t\t\t\t\t\tmatchedHandlers.push( handleObj );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( matchedHandlers.length ) {\n\t\t\t\t\t\thandlerQueue.push( { elem: cur, handlers: matchedHandlers } );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Add the remaining (directly-bound) handlers\n\t\tcur = this;\n\t\tif ( delegateCount < handlers.length ) {\n\t\t\thandlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );\n\t\t}\n\n\t\treturn handlerQueue;\n\t},\n\n\taddProp: function( name, hook ) {\n\t\tObject.defineProperty( jQuery.Event.prototype, name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\n\t\t\tget: jQuery.isFunction( hook ) ?\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\t\treturn hook( this.originalEvent );\n\t\t\t\t\t}\n\t\t\t\t} :\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\t\treturn this.originalEvent[ name ];\n\t\t\t\t\t}\n\t\t\t\t},\n\n\t\t\tset: function( value ) {\n\t\t\t\tObject.defineProperty( this, name, {\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\twritable: true,\n\t\t\t\t\tvalue: value\n\t\t\t\t} );\n\t\t\t}\n\t\t} );\n\t},\n\n\tfix: function( originalEvent ) {\n\t\treturn originalEvent[ jQuery.expando ] ?\n\t\t\toriginalEvent :\n\t\t\tnew jQuery.Event( originalEvent );\n\t},\n\n\tspecial: {\n\t\tload: {\n\n\t\t\t// Prevent triggered image.load events from bubbling to window.load\n\t\t\tnoBubble: true\n\t\t},\n\t\tfocus: {\n\n\t\t\t// Fire native event if possible so blur/focus sequence is correct\n\t\t\ttrigger: function() {\n\t\t\t\tif ( this !== safeActiveElement() && this.focus ) {\n\t\t\t\t\tthis.focus();\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdelegateType: \"focusin\"\n\t\t},\n\t\tblur: {\n\t\t\ttrigger: function() {\n\t\t\t\tif ( this === safeActiveElement() && this.blur ) {\n\t\t\t\t\tthis.blur();\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdelegateType: \"focusout\"\n\t\t},\n\t\tclick: {\n\n\t\t\t// For checkbox, fire native event so checked state will be right\n\t\t\ttrigger: function() {\n\t\t\t\tif ( this.type === \"checkbox\" && this.click && nodeName( this, \"input\" ) ) {\n\t\t\t\t\tthis.click();\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t},\n\n\t\t\t// For cross-browser consistency, don't fire native .click() on links\n\t\t\t_default: function( event ) {\n\t\t\t\treturn nodeName( event.target, \"a\" );\n\t\t\t}\n\t\t},\n\n\t\tbeforeunload: {\n\t\t\tpostDispatch: function( event ) {\n\n\t\t\t\t// Support: Firefox 20+\n\t\t\t\t// Firefox doesn't alert if the returnValue field is not set.\n\t\t\t\tif ( event.result !== undefined && event.originalEvent ) {\n\t\t\t\t\tevent.originalEvent.returnValue = event.result;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n};\n\njQuery.removeEvent = function( elem, type, handle ) {\n\n\t// This \"if\" is needed for plain objects\n\tif ( elem.removeEventListener ) {\n\t\telem.removeEventListener( type, handle );\n\t}\n};\n\njQuery.Event = function( src, props ) {\n\n\t// Allow instantiation without the 'new' keyword\n\tif ( !( this instanceof jQuery.Event ) ) {\n\t\treturn new jQuery.Event( src, props );\n\t}\n\n\t// Event object\n\tif ( src && src.type ) {\n\t\tthis.originalEvent = src;\n\t\tthis.type = src.type;\n\n\t\t// Events bubbling up the document may have been marked as prevented\n\t\t// by a handler lower down the tree; reflect the correct value.\n\t\tthis.isDefaultPrevented = src.defaultPrevented ||\n\t\t\t\tsrc.defaultPrevented === undefined &&\n\n\t\t\t\t// Support: Android <=2.3 only\n\t\t\t\tsrc.returnValue === false ?\n\t\t\treturnTrue :\n\t\t\treturnFalse;\n\n\t\t// Create target properties\n\t\t// Support: Safari <=6 - 7 only\n\t\t// Target should not be a text node (#504, #13143)\n\t\tthis.target = ( src.target && src.target.nodeType === 3 ) ?\n\t\t\tsrc.target.parentNode :\n\t\t\tsrc.target;\n\n\t\tthis.currentTarget = src.currentTarget;\n\t\tthis.relatedTarget = src.relatedTarget;\n\n\t// Event type\n\t} else {\n\t\tthis.type = src;\n\t}\n\n\t// Put explicitly provided properties onto the event object\n\tif ( props ) {\n\t\tjQuery.extend( this, props );\n\t}\n\n\t// Create a timestamp if incoming event doesn't have one\n\tthis.timeStamp = src && src.timeStamp || jQuery.now();\n\n\t// Mark it as fixed\n\tthis[ jQuery.expando ] = true;\n};\n\n// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\n// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\njQuery.Event.prototype = {\n\tconstructor: jQuery.Event,\n\tisDefaultPrevented: returnFalse,\n\tisPropagationStopped: returnFalse,\n\tisImmediatePropagationStopped: returnFalse,\n\tisSimulated: false,\n\n\tpreventDefault: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isDefaultPrevented = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.preventDefault();\n\t\t}\n\t},\n\tstopPropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isPropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopPropagation();\n\t\t}\n\t},\n\tstopImmediatePropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isImmediatePropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopImmediatePropagation();\n\t\t}\n\n\t\tthis.stopPropagation();\n\t}\n};\n\n// Includes all common event props including KeyEvent and MouseEvent specific props\njQuery.each( {\n\taltKey: true,\n\tbubbles: true,\n\tcancelable: true,\n\tchangedTouches: true,\n\tctrlKey: true,\n\tdetail: true,\n\teventPhase: true,\n\tmetaKey: true,\n\tpageX: true,\n\tpageY: true,\n\tshiftKey: true,\n\tview: true,\n\t\"char\": true,\n\tcharCode: true,\n\tkey: true,\n\tkeyCode: true,\n\tbutton: true,\n\tbuttons: true,\n\tclientX: true,\n\tclientY: true,\n\toffsetX: true,\n\toffsetY: true,\n\tpointerId: true,\n\tpointerType: true,\n\tscreenX: true,\n\tscreenY: true,\n\ttargetTouches: true,\n\ttoElement: true,\n\ttouches: true,\n\n\twhich: function( event ) {\n\t\tvar button = event.button;\n\n\t\t// Add which for key events\n\t\tif ( event.which == null && rkeyEvent.test( event.type ) ) {\n\t\t\treturn event.charCode != null ? event.charCode : event.keyCode;\n\t\t}\n\n\t\t// Add which for click: 1 === left; 2 === middle; 3 === right\n\t\tif ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {\n\t\t\tif ( button & 1 ) {\n\t\t\t\treturn 1;\n\t\t\t}\n\n\t\t\tif ( button & 2 ) {\n\t\t\t\treturn 3;\n\t\t\t}\n\n\t\t\tif ( button & 4 ) {\n\t\t\t\treturn 2;\n\t\t\t}\n\n\t\t\treturn 0;\n\t\t}\n\n\t\treturn event.which;\n\t}\n}, jQuery.event.addProp );\n\n// Create mouseenter/leave events using mouseover/out and event-time checks\n// so that event delegation works in jQuery.\n// Do the same for pointerenter/pointerleave and pointerover/pointerout\n//\n// Support: Safari 7 only\n// Safari sends mouseenter too often; see:\n// https://bugs.chromium.org/p/chromium/issues/detail?id=470258\n// for the description of the bug (it existed in older Chrome versions as well).\njQuery.each( {\n\tmouseenter: \"mouseover\",\n\tmouseleave: \"mouseout\",\n\tpointerenter: \"pointerover\",\n\tpointerleave: \"pointerout\"\n}, function( orig, fix ) {\n\tjQuery.event.special[ orig ] = {\n\t\tdelegateType: fix,\n\t\tbindType: fix,\n\n\t\thandle: function( event ) {\n\t\t\tvar ret,\n\t\t\t\ttarget = this,\n\t\t\t\trelated = event.relatedTarget,\n\t\t\t\thandleObj = event.handleObj;\n\n\t\t\t// For mouseenter/leave call the handler if related is outside the target.\n\t\t\t// NB: No relatedTarget if the mouse left/entered the browser window\n\t\t\tif ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {\n\t\t\t\tevent.type = handleObj.origType;\n\t\t\t\tret = handleObj.handler.apply( this, arguments );\n\t\t\t\tevent.type = fix;\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t};\n} );\n\njQuery.fn.extend( {\n\n\ton: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn );\n\t},\n\tone: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn, 1 );\n\t},\n\toff: function( types, selector, fn ) {\n\t\tvar handleObj, type;\n\t\tif ( types && types.preventDefault && types.handleObj ) {\n\n\t\t\t// ( event )  dispatched jQuery.Event\n\t\t\thandleObj = types.handleObj;\n\t\t\tjQuery( types.delegateTarget ).off(\n\t\t\t\thandleObj.namespace ?\n\t\t\t\t\thandleObj.origType + \".\" + handleObj.namespace :\n\t\t\t\t\thandleObj.origType,\n\t\t\t\thandleObj.selector,\n\t\t\t\thandleObj.handler\n\t\t\t);\n\t\t\treturn this;\n\t\t}\n\t\tif ( typeof types === \"object\" ) {\n\n\t\t\t// ( types-object [, selector] )\n\t\t\tfor ( type in types ) {\n\t\t\t\tthis.off( type, selector, types[ type ] );\n\t\t\t}\n\t\t\treturn this;\n\t\t}\n\t\tif ( selector === false || typeof selector === \"function\" ) {\n\n\t\t\t// ( types [, fn] )\n\t\t\tfn = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tif ( fn === false ) {\n\t\t\tfn = returnFalse;\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.remove( this, types, fn, selector );\n\t\t} );\n\t}\n} );\n\n\nvar\n\n\t/* eslint-disable max-len */\n\n\t// See https://github.com/eslint/eslint/issues/3229\n\trxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)[^>]*)\\/>/gi,\n\n\t/* eslint-enable */\n\n\t// Support: IE <=10 - 11, Edge 12 - 13\n\t// In IE/Edge using regex groups here causes severe slowdowns.\n\t// See https://connect.microsoft.com/IE/feedback/details/1736512/\n\trnoInnerhtml = /<script|<style|<link/i,\n\n\t// checked=\"checked\" or checked\n\trchecked = /checked\\s*(?:[^=]|=\\s*.checked.)/i,\n\trscriptTypeMasked = /^true\\/(.*)/,\n\trcleanScript = /^\\s*<!(?:\\[CDATA\\[|--)|(?:\\]\\]|--)>\\s*$/g;\n\n// Prefer a tbody over its parent table for containing new rows\nfunction manipulationTarget( elem, content ) {\n\tif ( nodeName( elem, \"table\" ) &&\n\t\tnodeName( content.nodeType !== 11 ? content : content.firstChild, \"tr\" ) ) {\n\n\t\treturn jQuery( \">tbody\", elem )[ 0 ] || elem;\n\t}\n\n\treturn elem;\n}\n\n// Replace/restore the type attribute of script elements for safe DOM manipulation\nfunction disableScript( elem ) {\n\telem.type = ( elem.getAttribute( \"type\" ) !== null ) + \"/\" + elem.type;\n\treturn elem;\n}\nfunction restoreScript( elem ) {\n\tvar match = rscriptTypeMasked.exec( elem.type );\n\n\tif ( match ) {\n\t\telem.type = match[ 1 ];\n\t} else {\n\t\telem.removeAttribute( \"type\" );\n\t}\n\n\treturn elem;\n}\n\nfunction cloneCopyEvent( src, dest ) {\n\tvar i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;\n\n\tif ( dest.nodeType !== 1 ) {\n\t\treturn;\n\t}\n\n\t// 1. Copy private data: events, handlers, etc.\n\tif ( dataPriv.hasData( src ) ) {\n\t\tpdataOld = dataPriv.access( src );\n\t\tpdataCur = dataPriv.set( dest, pdataOld );\n\t\tevents = pdataOld.events;\n\n\t\tif ( events ) {\n\t\t\tdelete pdataCur.handle;\n\t\t\tpdataCur.events = {};\n\n\t\t\tfor ( type in events ) {\n\t\t\t\tfor ( i = 0, l = events[ type ].length; i < l; i++ ) {\n\t\t\t\t\tjQuery.event.add( dest, type, events[ type ][ i ] );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// 2. Copy user data\n\tif ( dataUser.hasData( src ) ) {\n\t\tudataOld = dataUser.access( src );\n\t\tudataCur = jQuery.extend( {}, udataOld );\n\n\t\tdataUser.set( dest, udataCur );\n\t}\n}\n\n// Fix IE bugs, see support tests\nfunction fixInput( src, dest ) {\n\tvar nodeName = dest.nodeName.toLowerCase();\n\n\t// Fails to persist the checked state of a cloned checkbox or radio button.\n\tif ( nodeName === \"input\" && rcheckableType.test( src.type ) ) {\n\t\tdest.checked = src.checked;\n\n\t// Fails to return the selected option to the default selected state when cloning options\n\t} else if ( nodeName === \"input\" || nodeName === \"textarea\" ) {\n\t\tdest.defaultValue = src.defaultValue;\n\t}\n}\n\nfunction domManip( collection, args, callback, ignored ) {\n\n\t// Flatten any nested arrays\n\targs = concat.apply( [], args );\n\n\tvar fragment, first, scripts, hasScripts, node, doc,\n\t\ti = 0,\n\t\tl = collection.length,\n\t\tiNoClone = l - 1,\n\t\tvalue = args[ 0 ],\n\t\tisFunction = jQuery.isFunction( value );\n\n\t// We can't cloneNode fragments that contain checked, in WebKit\n\tif ( isFunction ||\n\t\t\t( l > 1 && typeof value === \"string\" &&\n\t\t\t\t!support.checkClone && rchecked.test( value ) ) ) {\n\t\treturn collection.each( function( index ) {\n\t\t\tvar self = collection.eq( index );\n\t\t\tif ( isFunction ) {\n\t\t\t\targs[ 0 ] = value.call( this, index, self.html() );\n\t\t\t}\n\t\t\tdomManip( self, args, callback, ignored );\n\t\t} );\n\t}\n\n\tif ( l ) {\n\t\tfragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );\n\t\tfirst = fragment.firstChild;\n\n\t\tif ( fragment.childNodes.length === 1 ) {\n\t\t\tfragment = first;\n\t\t}\n\n\t\t// Require either new content or an interest in ignored elements to invoke the callback\n\t\tif ( first || ignored ) {\n\t\t\tscripts = jQuery.map( getAll( fragment, \"script\" ), disableScript );\n\t\t\thasScripts = scripts.length;\n\n\t\t\t// Use the original fragment for the last item\n\t\t\t// instead of the first because it can end up\n\t\t\t// being emptied incorrectly in certain situations (#8070).\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tnode = fragment;\n\n\t\t\t\tif ( i !== iNoClone ) {\n\t\t\t\t\tnode = jQuery.clone( node, true, true );\n\n\t\t\t\t\t// Keep references to cloned scripts for later restoration\n\t\t\t\t\tif ( hasScripts ) {\n\n\t\t\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\t\t\tjQuery.merge( scripts, getAll( node, \"script\" ) );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tcallback.call( collection[ i ], node, i );\n\t\t\t}\n\n\t\t\tif ( hasScripts ) {\n\t\t\t\tdoc = scripts[ scripts.length - 1 ].ownerDocument;\n\n\t\t\t\t// Reenable scripts\n\t\t\t\tjQuery.map( scripts, restoreScript );\n\n\t\t\t\t// Evaluate executable scripts on first document insertion\n\t\t\t\tfor ( i = 0; i < hasScripts; i++ ) {\n\t\t\t\t\tnode = scripts[ i ];\n\t\t\t\t\tif ( rscriptType.test( node.type || \"\" ) &&\n\t\t\t\t\t\t!dataPriv.access( node, \"globalEval\" ) &&\n\t\t\t\t\t\tjQuery.contains( doc, node ) ) {\n\n\t\t\t\t\t\tif ( node.src ) {\n\n\t\t\t\t\t\t\t// Optional AJAX dependency, but won't run scripts if not present\n\t\t\t\t\t\t\tif ( jQuery._evalUrl ) {\n\t\t\t\t\t\t\t\tjQuery._evalUrl( node.src );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tDOMEval( node.textContent.replace( rcleanScript, \"\" ), doc );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn collection;\n}\n\nfunction remove( elem, selector, keepData ) {\n\tvar node,\n\t\tnodes = selector ? jQuery.filter( selector, elem ) : elem,\n\t\ti = 0;\n\n\tfor ( ; ( node = nodes[ i ] ) != null; i++ ) {\n\t\tif ( !keepData && node.nodeType === 1 ) {\n\t\t\tjQuery.cleanData( getAll( node ) );\n\t\t}\n\n\t\tif ( node.parentNode ) {\n\t\t\tif ( keepData && jQuery.contains( node.ownerDocument, node ) ) {\n\t\t\t\tsetGlobalEval( getAll( node, \"script\" ) );\n\t\t\t}\n\t\t\tnode.parentNode.removeChild( node );\n\t\t}\n\t}\n\n\treturn elem;\n}\n\njQuery.extend( {\n\thtmlPrefilter: function( html ) {\n\t\treturn html.replace( rxhtmlTag, \"<$1></$2>\" );\n\t},\n\n\tclone: function( elem, dataAndEvents, deepDataAndEvents ) {\n\t\tvar i, l, srcElements, destElements,\n\t\t\tclone = elem.cloneNode( true ),\n\t\t\tinPage = jQuery.contains( elem.ownerDocument, elem );\n\n\t\t// Fix IE cloning issues\n\t\tif ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&\n\t\t\t\t!jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2\n\t\t\tdestElements = getAll( clone );\n\t\t\tsrcElements = getAll( elem );\n\n\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\tfixInput( srcElements[ i ], destElements[ i ] );\n\t\t\t}\n\t\t}\n\n\t\t// Copy the events from the original to the clone\n\t\tif ( dataAndEvents ) {\n\t\t\tif ( deepDataAndEvents ) {\n\t\t\t\tsrcElements = srcElements || getAll( elem );\n\t\t\t\tdestElements = destElements || getAll( clone );\n\n\t\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\t\tcloneCopyEvent( srcElements[ i ], destElements[ i ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tcloneCopyEvent( elem, clone );\n\t\t\t}\n\t\t}\n\n\t\t// Preserve script evaluation history\n\t\tdestElements = getAll( clone, \"script\" );\n\t\tif ( destElements.length > 0 ) {\n\t\t\tsetGlobalEval( destElements, !inPage && getAll( elem, \"script\" ) );\n\t\t}\n\n\t\t// Return the cloned set\n\t\treturn clone;\n\t},\n\n\tcleanData: function( elems ) {\n\t\tvar data, elem, type,\n\t\t\tspecial = jQuery.event.special,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {\n\t\t\tif ( acceptData( elem ) ) {\n\t\t\t\tif ( ( data = elem[ dataPriv.expando ] ) ) {\n\t\t\t\t\tif ( data.events ) {\n\t\t\t\t\t\tfor ( type in data.events ) {\n\t\t\t\t\t\t\tif ( special[ type ] ) {\n\t\t\t\t\t\t\t\tjQuery.event.remove( elem, type );\n\n\t\t\t\t\t\t\t// This is a shortcut to avoid jQuery.event.remove's overhead\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tjQuery.removeEvent( elem, type, data.handle );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataPriv.expando ] = undefined;\n\t\t\t\t}\n\t\t\t\tif ( elem[ dataUser.expando ] ) {\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataUser.expando ] = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n} );\n\njQuery.fn.extend( {\n\tdetach: function( selector ) {\n\t\treturn remove( this, selector, true );\n\t},\n\n\tremove: function( selector ) {\n\t\treturn remove( this, selector );\n\t},\n\n\ttext: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\treturn value === undefined ?\n\t\t\t\tjQuery.text( this ) :\n\t\t\t\tthis.empty().each( function() {\n\t\t\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\t\t\tthis.textContent = value;\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t}, null, value, arguments.length );\n\t},\n\n\tappend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.appendChild( elem );\n\t\t\t}\n\t\t} );\n\t},\n\n\tprepend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.insertBefore( elem, target.firstChild );\n\t\t\t}\n\t\t} );\n\t},\n\n\tbefore: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this );\n\t\t\t}\n\t\t} );\n\t},\n\n\tafter: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this.nextSibling );\n\t\t\t}\n\t\t} );\n\t},\n\n\tempty: function() {\n\t\tvar elem,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = this[ i ] ) != null; i++ ) {\n\t\t\tif ( elem.nodeType === 1 ) {\n\n\t\t\t\t// Prevent memory leaks\n\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\n\t\t\t\t// Remove any remaining nodes\n\t\t\t\telem.textContent = \"\";\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tclone: function( dataAndEvents, deepDataAndEvents ) {\n\t\tdataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n\t\tdeepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n\n\t\treturn this.map( function() {\n\t\t\treturn jQuery.clone( this, dataAndEvents, deepDataAndEvents );\n\t\t} );\n\t},\n\n\thtml: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\tvar elem = this[ 0 ] || {},\n\t\t\t\ti = 0,\n\t\t\t\tl = this.length;\n\n\t\t\tif ( value === undefined && elem.nodeType === 1 ) {\n\t\t\t\treturn elem.innerHTML;\n\t\t\t}\n\n\t\t\t// See if we can take a shortcut and just use innerHTML\n\t\t\tif ( typeof value === \"string\" && !rnoInnerhtml.test( value ) &&\n\t\t\t\t!wrapMap[ ( rtagName.exec( value ) || [ \"\", \"\" ] )[ 1 ].toLowerCase() ] ) {\n\n\t\t\t\tvalue = jQuery.htmlPrefilter( value );\n\n\t\t\t\ttry {\n\t\t\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\t\t\telem = this[ i ] || {};\n\n\t\t\t\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\t\t\t\t\t\t\telem.innerHTML = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\telem = 0;\n\n\t\t\t\t// If using innerHTML throws an exception, use the fallback method\n\t\t\t\t} catch ( e ) {}\n\t\t\t}\n\n\t\t\tif ( elem ) {\n\t\t\t\tthis.empty().append( value );\n\t\t\t}\n\t\t}, null, value, arguments.length );\n\t},\n\n\treplaceWith: function() {\n\t\tvar ignored = [];\n\n\t\t// Make the changes, replacing each non-ignored context element with the new content\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tvar parent = this.parentNode;\n\n\t\t\tif ( jQuery.inArray( this, ignored ) < 0 ) {\n\t\t\t\tjQuery.cleanData( getAll( this ) );\n\t\t\t\tif ( parent ) {\n\t\t\t\t\tparent.replaceChild( elem, this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Force callback invocation\n\t\t}, ignored );\n\t}\n} );\n\njQuery.each( {\n\tappendTo: \"append\",\n\tprependTo: \"prepend\",\n\tinsertBefore: \"before\",\n\tinsertAfter: \"after\",\n\treplaceAll: \"replaceWith\"\n}, function( name, original ) {\n\tjQuery.fn[ name ] = function( selector ) {\n\t\tvar elems,\n\t\t\tret = [],\n\t\t\tinsert = jQuery( selector ),\n\t\t\tlast = insert.length - 1,\n\t\t\ti = 0;\n\n\t\tfor ( ; i <= last; i++ ) {\n\t\t\telems = i === last ? this : this.clone( true );\n\t\t\tjQuery( insert[ i ] )[ original ]( elems );\n\n\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t// .get() because push.apply(_, arraylike) throws on ancient WebKit\n\t\t\tpush.apply( ret, elems.get() );\n\t\t}\n\n\t\treturn this.pushStack( ret );\n\t};\n} );\nvar rmargin = ( /^margin/ );\n\nvar rnumnonpx = new RegExp( \"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\" );\n\nvar getStyles = function( elem ) {\n\n\t\t// Support: IE <=11 only, Firefox <=30 (#15098, #14150)\n\t\t// IE throws on elements created in popups\n\t\t// FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\n\t\tvar view = elem.ownerDocument.defaultView;\n\n\t\tif ( !view || !view.opener ) {\n\t\t\tview = window;\n\t\t}\n\n\t\treturn view.getComputedStyle( elem );\n\t};\n\n\n\n( function() {\n\n\t// Executing both pixelPosition & boxSizingReliable tests require only one layout\n\t// so they're executed at the same time to save the second computation.\n\tfunction computeStyleTests() {\n\n\t\t// This is a singleton, we need to execute it only once\n\t\tif ( !div ) {\n\t\t\treturn;\n\t\t}\n\n\t\tdiv.style.cssText =\n\t\t\t\"box-sizing:border-box;\" +\n\t\t\t\"position:relative;display:block;\" +\n\t\t\t\"margin:auto;border:1px;padding:1px;\" +\n\t\t\t\"top:1%;width:50%\";\n\t\tdiv.innerHTML = \"\";\n\t\tdocumentElement.appendChild( container );\n\n\t\tvar divStyle = window.getComputedStyle( div );\n\t\tpixelPositionVal = divStyle.top !== \"1%\";\n\n\t\t// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44\n\t\treliableMarginLeftVal = divStyle.marginLeft === \"2px\";\n\t\tboxSizingReliableVal = divStyle.width === \"4px\";\n\n\t\t// Support: Android 4.0 - 4.3 only\n\t\t// Some styles come back with percentage values, even though they shouldn't\n\t\tdiv.style.marginRight = \"50%\";\n\t\tpixelMarginRightVal = divStyle.marginRight === \"4px\";\n\n\t\tdocumentElement.removeChild( container );\n\n\t\t// Nullify the div so it wouldn't be stored in the memory and\n\t\t// it will also be a sign that checks already performed\n\t\tdiv = null;\n\t}\n\n\tvar pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,\n\t\tcontainer = document.createElement( \"div\" ),\n\t\tdiv = document.createElement( \"div\" );\n\n\t// Finish early in limited (non-browser) environments\n\tif ( !div.style ) {\n\t\treturn;\n\t}\n\n\t// Support: IE <=9 - 11 only\n\t// Style of cloned element affects source element cloned (#8908)\n\tdiv.style.backgroundClip = \"content-box\";\n\tdiv.cloneNode( true ).style.backgroundClip = \"\";\n\tsupport.clearCloneStyle = div.style.backgroundClip === \"content-box\";\n\n\tcontainer.style.cssText = \"border:0;width:8px;height:0;top:0;left:-9999px;\" +\n\t\t\"padding:0;margin-top:1px;position:absolute\";\n\tcontainer.appendChild( div );\n\n\tjQuery.extend( support, {\n\t\tpixelPosition: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelPositionVal;\n\t\t},\n\t\tboxSizingReliable: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn boxSizingReliableVal;\n\t\t},\n\t\tpixelMarginRight: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelMarginRightVal;\n\t\t},\n\t\treliableMarginLeft: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn reliableMarginLeftVal;\n\t\t}\n\t} );\n} )();\n\n\nfunction curCSS( elem, name, computed ) {\n\tvar width, minWidth, maxWidth, ret,\n\n\t\t// Support: Firefox 51+\n\t\t// Retrieving style before computed somehow\n\t\t// fixes an issue with getting wrong values\n\t\t// on detached elements\n\t\tstyle = elem.style;\n\n\tcomputed = computed || getStyles( elem );\n\n\t// getPropertyValue is needed for:\n\t//   .css('filter') (IE 9 only, #12537)\n\t//   .css('--customProperty) (#3144)\n\tif ( computed ) {\n\t\tret = computed.getPropertyValue( name ) || computed[ name ];\n\n\t\tif ( ret === \"\" && !jQuery.contains( elem.ownerDocument, elem ) ) {\n\t\t\tret = jQuery.style( elem, name );\n\t\t}\n\n\t\t// A tribute to the \"awesome hack by Dean Edwards\"\n\t\t// Android Browser returns percentage for some values,\n\t\t// but width seems to be reliably pixels.\n\t\t// This is against the CSSOM draft spec:\n\t\t// https://drafts.csswg.org/cssom/#resolved-values\n\t\tif ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {\n\n\t\t\t// Remember the original values\n\t\t\twidth = style.width;\n\t\t\tminWidth = style.minWidth;\n\t\t\tmaxWidth = style.maxWidth;\n\n\t\t\t// Put in the new values to get a computed value out\n\t\t\tstyle.minWidth = style.maxWidth = style.width = ret;\n\t\t\tret = computed.width;\n\n\t\t\t// Revert the changed values\n\t\t\tstyle.width = width;\n\t\t\tstyle.minWidth = minWidth;\n\t\t\tstyle.maxWidth = maxWidth;\n\t\t}\n\t}\n\n\treturn ret !== undefined ?\n\n\t\t// Support: IE <=9 - 11 only\n\t\t// IE returns zIndex value as an integer.\n\t\tret + \"\" :\n\t\tret;\n}\n\n\nfunction addGetHookIf( conditionFn, hookFn ) {\n\n\t// Define the hook, we'll check on the first run if it's really needed.\n\treturn {\n\t\tget: function() {\n\t\t\tif ( conditionFn() ) {\n\n\t\t\t\t// Hook not needed (or it's not possible to use it due\n\t\t\t\t// to missing dependency), remove it.\n\t\t\t\tdelete this.get;\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Hook needed; redefine it so that the support test is not executed again.\n\t\t\treturn ( this.get = hookFn ).apply( this, arguments );\n\t\t}\n\t};\n}\n\n\nvar\n\n\t// Swappable if display is none or starts with table\n\t// except \"table\", \"table-cell\", or \"table-caption\"\n\t// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display\n\trdisplayswap = /^(none|table(?!-c[ea]).+)/,\n\trcustomProp = /^--/,\n\tcssShow = { position: \"absolute\", visibility: \"hidden\", display: \"block\" },\n\tcssNormalTransform = {\n\t\tletterSpacing: \"0\",\n\t\tfontWeight: \"400\"\n\t},\n\n\tcssPrefixes = [ \"Webkit\", \"Moz\", \"ms\" ],\n\temptyStyle = document.createElement( \"div\" ).style;\n\n// Return a css property mapped to a potentially vendor prefixed property\nfunction vendorPropName( name ) {\n\n\t// Shortcut for names that are not vendor prefixed\n\tif ( name in emptyStyle ) {\n\t\treturn name;\n\t}\n\n\t// Check for vendor prefixed names\n\tvar capName = name[ 0 ].toUpperCase() + name.slice( 1 ),\n\t\ti = cssPrefixes.length;\n\n\twhile ( i-- ) {\n\t\tname = cssPrefixes[ i ] + capName;\n\t\tif ( name in emptyStyle ) {\n\t\t\treturn name;\n\t\t}\n\t}\n}\n\n// Return a property mapped along what jQuery.cssProps suggests or to\n// a vendor prefixed property.\nfunction finalPropName( name ) {\n\tvar ret = jQuery.cssProps[ name ];\n\tif ( !ret ) {\n\t\tret = jQuery.cssProps[ name ] = vendorPropName( name ) || name;\n\t}\n\treturn ret;\n}\n\nfunction setPositiveNumber( elem, value, subtract ) {\n\n\t// Any relative (+/-) values have already been\n\t// normalized at this point\n\tvar matches = rcssNum.exec( value );\n\treturn matches ?\n\n\t\t// Guard against undefined \"subtract\", e.g., when used as in cssHooks\n\t\tMath.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || \"px\" ) :\n\t\tvalue;\n}\n\nfunction augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {\n\tvar i,\n\t\tval = 0;\n\n\t// If we already have the right measurement, avoid augmentation\n\tif ( extra === ( isBorderBox ? \"border\" : \"content\" ) ) {\n\t\ti = 4;\n\n\t// Otherwise initialize for horizontal or vertical properties\n\t} else {\n\t\ti = name === \"width\" ? 1 : 0;\n\t}\n\n\tfor ( ; i < 4; i += 2 ) {\n\n\t\t// Both box models exclude margin, so add it if we want it\n\t\tif ( extra === \"margin\" ) {\n\t\t\tval += jQuery.css( elem, extra + cssExpand[ i ], true, styles );\n\t\t}\n\n\t\tif ( isBorderBox ) {\n\n\t\t\t// border-box includes padding, so remove it if we want content\n\t\t\tif ( extra === \"content\" ) {\n\t\t\t\tval -= jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\t\t\t}\n\n\t\t\t// At this point, extra isn't border nor margin, so remove border\n\t\t\tif ( extra !== \"margin\" ) {\n\t\t\t\tval -= jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t} else {\n\n\t\t\t// At this point, extra isn't content, so add padding\n\t\t\tval += jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\n\t\t\t// At this point, extra isn't content nor padding, so add border\n\t\t\tif ( extra !== \"padding\" ) {\n\t\t\t\tval += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t}\n\t}\n\n\treturn val;\n}\n\nfunction getWidthOrHeight( elem, name, extra ) {\n\n\t// Start with computed style\n\tvar valueIsBorderBox,\n\t\tstyles = getStyles( elem ),\n\t\tval = curCSS( elem, name, styles ),\n\t\tisBorderBox = jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\";\n\n\t// Computed unit is not pixels. Stop here and return.\n\tif ( rnumnonpx.test( val ) ) {\n\t\treturn val;\n\t}\n\n\t// Check for style in case a browser which returns unreliable values\n\t// for getComputedStyle silently falls back to the reliable elem.style\n\tvalueIsBorderBox = isBorderBox &&\n\t\t( support.boxSizingReliable() || val === elem.style[ name ] );\n\n\t// Fall back to offsetWidth/Height when value is \"auto\"\n\t// This happens for inline elements with no explicit setting (gh-3571)\n\tif ( val === \"auto\" ) {\n\t\tval = elem[ \"offset\" + name[ 0 ].toUpperCase() + name.slice( 1 ) ];\n\t}\n\n\t// Normalize \"\", auto, and prepare for extra\n\tval = parseFloat( val ) || 0;\n\n\t// Use the active box-sizing model to add/subtract irrelevant styles\n\treturn ( val +\n\t\taugmentWidthOrHeight(\n\t\t\telem,\n\t\t\tname,\n\t\t\textra || ( isBorderBox ? \"border\" : \"content\" ),\n\t\t\tvalueIsBorderBox,\n\t\t\tstyles\n\t\t)\n\t) + \"px\";\n}\n\njQuery.extend( {\n\n\t// Add in style property hooks for overriding the default\n\t// behavior of getting and setting a style property\n\tcssHooks: {\n\t\topacity: {\n\t\t\tget: function( elem, computed ) {\n\t\t\t\tif ( computed ) {\n\n\t\t\t\t\t// We should always get a number back from opacity\n\t\t\t\t\tvar ret = curCSS( elem, \"opacity\" );\n\t\t\t\t\treturn ret === \"\" ? \"1\" : ret;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\t// Don't automatically add \"px\" to these possibly-unitless properties\n\tcssNumber: {\n\t\t\"animationIterationCount\": true,\n\t\t\"columnCount\": true,\n\t\t\"fillOpacity\": true,\n\t\t\"flexGrow\": true,\n\t\t\"flexShrink\": true,\n\t\t\"fontWeight\": true,\n\t\t\"lineHeight\": true,\n\t\t\"opacity\": true,\n\t\t\"order\": true,\n\t\t\"orphans\": true,\n\t\t\"widows\": true,\n\t\t\"zIndex\": true,\n\t\t\"zoom\": true\n\t},\n\n\t// Add in properties whose names you wish to fix before\n\t// setting or getting the value\n\tcssProps: {\n\t\t\"float\": \"cssFloat\"\n\t},\n\n\t// Get and set the style property on a DOM Node\n\tstyle: function( elem, name, value, extra ) {\n\n\t\t// Don't set styles on text and comment nodes\n\t\tif ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Make sure that we're working with the right name\n\t\tvar ret, type, hooks,\n\t\t\torigName = jQuery.camelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name ),\n\t\t\tstyle = elem.style;\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to query the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Gets hook for the prefixed version, then unprefixed version\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// Check if we're setting a value\n\t\tif ( value !== undefined ) {\n\t\t\ttype = typeof value;\n\n\t\t\t// Convert \"+=\" or \"-=\" to relative numbers (#7345)\n\t\t\tif ( type === \"string\" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {\n\t\t\t\tvalue = adjustCSS( elem, name, ret );\n\n\t\t\t\t// Fixes bug #9237\n\t\t\t\ttype = \"number\";\n\t\t\t}\n\n\t\t\t// Make sure that null and NaN values aren't set (#7116)\n\t\t\tif ( value == null || value !== value ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// If a number was passed in, add the unit (except for certain CSS properties)\n\t\t\tif ( type === \"number\" ) {\n\t\t\t\tvalue += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? \"\" : \"px\" );\n\t\t\t}\n\n\t\t\t// background-* props affect original clone's values\n\t\t\tif ( !support.clearCloneStyle && value === \"\" && name.indexOf( \"background\" ) === 0 ) {\n\t\t\t\tstyle[ name ] = \"inherit\";\n\t\t\t}\n\n\t\t\t// If a hook was provided, use that value, otherwise just set the specified value\n\t\t\tif ( !hooks || !( \"set\" in hooks ) ||\n\t\t\t\t( value = hooks.set( elem, value, extra ) ) !== undefined ) {\n\n\t\t\t\tif ( isCustomProp ) {\n\t\t\t\t\tstyle.setProperty( name, value );\n\t\t\t\t} else {\n\t\t\t\t\tstyle[ name ] = value;\n\t\t\t\t}\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// If a hook was provided get the non-computed value from there\n\t\t\tif ( hooks && \"get\" in hooks &&\n\t\t\t\t( ret = hooks.get( elem, false, extra ) ) !== undefined ) {\n\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\t// Otherwise just get the value from the style object\n\t\t\treturn style[ name ];\n\t\t}\n\t},\n\n\tcss: function( elem, name, extra, styles ) {\n\t\tvar val, num, hooks,\n\t\t\torigName = jQuery.camelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name );\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to modify the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Try prefixed name followed by the unprefixed name\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// If a hook was provided get the computed value from there\n\t\tif ( hooks && \"get\" in hooks ) {\n\t\t\tval = hooks.get( elem, true, extra );\n\t\t}\n\n\t\t// Otherwise, if a way to get the computed value exists, use that\n\t\tif ( val === undefined ) {\n\t\t\tval = curCSS( elem, name, styles );\n\t\t}\n\n\t\t// Convert \"normal\" to computed value\n\t\tif ( val === \"normal\" && name in cssNormalTransform ) {\n\t\t\tval = cssNormalTransform[ name ];\n\t\t}\n\n\t\t// Make numeric if forced or a qualifier was provided and val looks numeric\n\t\tif ( extra === \"\" || extra ) {\n\t\t\tnum = parseFloat( val );\n\t\t\treturn extra === true || isFinite( num ) ? num || 0 : val;\n\t\t}\n\n\t\treturn val;\n\t}\n} );\n\njQuery.each( [ \"height\", \"width\" ], function( i, name ) {\n\tjQuery.cssHooks[ name ] = {\n\t\tget: function( elem, computed, extra ) {\n\t\t\tif ( computed ) {\n\n\t\t\t\t// Certain elements can have dimension info if we invisibly show them\n\t\t\t\t// but it must have a current display style that would benefit\n\t\t\t\treturn rdisplayswap.test( jQuery.css( elem, \"display\" ) ) &&\n\n\t\t\t\t\t// Support: Safari 8+\n\t\t\t\t\t// Table columns in Safari have non-zero offsetWidth & zero\n\t\t\t\t\t// getBoundingClientRect().width unless display is changed.\n\t\t\t\t\t// Support: IE <=11 only\n\t\t\t\t\t// Running getBoundingClientRect on a disconnected node\n\t\t\t\t\t// in IE throws an error.\n\t\t\t\t\t( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?\n\t\t\t\t\t\tswap( elem, cssShow, function() {\n\t\t\t\t\t\t\treturn getWidthOrHeight( elem, name, extra );\n\t\t\t\t\t\t} ) :\n\t\t\t\t\t\tgetWidthOrHeight( elem, name, extra );\n\t\t\t}\n\t\t},\n\n\t\tset: function( elem, value, extra ) {\n\t\t\tvar matches,\n\t\t\t\tstyles = extra && getStyles( elem ),\n\t\t\t\tsubtract = extra && augmentWidthOrHeight(\n\t\t\t\t\telem,\n\t\t\t\t\tname,\n\t\t\t\t\textra,\n\t\t\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\t\t\t\tstyles\n\t\t\t\t);\n\n\t\t\t// Convert to pixels if value adjustment is needed\n\t\t\tif ( subtract && ( matches = rcssNum.exec( value ) ) &&\n\t\t\t\t( matches[ 3 ] || \"px\" ) !== \"px\" ) {\n\n\t\t\t\telem.style[ name ] = value;\n\t\t\t\tvalue = jQuery.css( elem, name );\n\t\t\t}\n\n\t\t\treturn setPositiveNumber( elem, value, subtract );\n\t\t}\n\t};\n} );\n\njQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,\n\tfunction( elem, computed ) {\n\t\tif ( computed ) {\n\t\t\treturn ( parseFloat( curCSS( elem, \"marginLeft\" ) ) ||\n\t\t\t\telem.getBoundingClientRect().left -\n\t\t\t\t\tswap( elem, { marginLeft: 0 }, function() {\n\t\t\t\t\t\treturn elem.getBoundingClientRect().left;\n\t\t\t\t\t} )\n\t\t\t\t) + \"px\";\n\t\t}\n\t}\n);\n\n// These hooks are used by animate to expand properties\njQuery.each( {\n\tmargin: \"\",\n\tpadding: \"\",\n\tborder: \"Width\"\n}, function( prefix, suffix ) {\n\tjQuery.cssHooks[ prefix + suffix ] = {\n\t\texpand: function( value ) {\n\t\t\tvar i = 0,\n\t\t\t\texpanded = {},\n\n\t\t\t\t// Assumes a single number if not a string\n\t\t\t\tparts = typeof value === \"string\" ? value.split( \" \" ) : [ value ];\n\n\t\t\tfor ( ; i < 4; i++ ) {\n\t\t\t\texpanded[ prefix + cssExpand[ i ] + suffix ] =\n\t\t\t\t\tparts[ i ] || parts[ i - 2 ] || parts[ 0 ];\n\t\t\t}\n\n\t\t\treturn expanded;\n\t\t}\n\t};\n\n\tif ( !rmargin.test( prefix ) ) {\n\t\tjQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;\n\t}\n} );\n\njQuery.fn.extend( {\n\tcss: function( name, value ) {\n\t\treturn access( this, function( elem, name, value ) {\n\t\t\tvar styles, len,\n\t\t\t\tmap = {},\n\t\t\t\ti = 0;\n\n\t\t\tif ( Array.isArray( name ) ) {\n\t\t\t\tstyles = getStyles( elem );\n\t\t\t\tlen = name.length;\n\n\t\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\t\tmap[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );\n\t\t\t\t}\n\n\t\t\t\treturn map;\n\t\t\t}\n\n\t\t\treturn value !== undefined ?\n\t\t\t\tjQuery.style( elem, name, value ) :\n\t\t\t\tjQuery.css( elem, name );\n\t\t}, name, value, arguments.length > 1 );\n\t}\n} );\n\n\nfunction Tween( elem, options, prop, end, easing ) {\n\treturn new Tween.prototype.init( elem, options, prop, end, easing );\n}\njQuery.Tween = Tween;\n\nTween.prototype = {\n\tconstructor: Tween,\n\tinit: function( elem, options, prop, end, easing, unit ) {\n\t\tthis.elem = elem;\n\t\tthis.prop = prop;\n\t\tthis.easing = easing || jQuery.easing._default;\n\t\tthis.options = options;\n\t\tthis.start = this.now = this.cur();\n\t\tthis.end = end;\n\t\tthis.unit = unit || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" );\n\t},\n\tcur: function() {\n\t\tvar hooks = Tween.propHooks[ this.prop ];\n\n\t\treturn hooks && hooks.get ?\n\t\t\thooks.get( this ) :\n\t\t\tTween.propHooks._default.get( this );\n\t},\n\trun: function( percent ) {\n\t\tvar eased,\n\t\t\thooks = Tween.propHooks[ this.prop ];\n\n\t\tif ( this.options.duration ) {\n\t\t\tthis.pos = eased = jQuery.easing[ this.easing ](\n\t\t\t\tpercent, this.options.duration * percent, 0, 1, this.options.duration\n\t\t\t);\n\t\t} else {\n\t\t\tthis.pos = eased = percent;\n\t\t}\n\t\tthis.now = ( this.end - this.start ) * eased + this.start;\n\n\t\tif ( this.options.step ) {\n\t\t\tthis.options.step.call( this.elem, this.now, this );\n\t\t}\n\n\t\tif ( hooks && hooks.set ) {\n\t\t\thooks.set( this );\n\t\t} else {\n\t\t\tTween.propHooks._default.set( this );\n\t\t}\n\t\treturn this;\n\t}\n};\n\nTween.prototype.init.prototype = Tween.prototype;\n\nTween.propHooks = {\n\t_default: {\n\t\tget: function( tween ) {\n\t\t\tvar result;\n\n\t\t\t// Use a property on the element directly when it is not a DOM element,\n\t\t\t// or when there is no matching style property that exists.\n\t\t\tif ( tween.elem.nodeType !== 1 ||\n\t\t\t\ttween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {\n\t\t\t\treturn tween.elem[ tween.prop ];\n\t\t\t}\n\n\t\t\t// Passing an empty string as a 3rd parameter to .css will automatically\n\t\t\t// attempt a parseFloat and fallback to a string if the parse fails.\n\t\t\t// Simple values such as \"10px\" are parsed to Float;\n\t\t\t// complex values such as \"rotate(1rad)\" are returned as-is.\n\t\t\tresult = jQuery.css( tween.elem, tween.prop, \"\" );\n\n\t\t\t// Empty strings, null, undefined and \"auto\" are converted to 0.\n\t\t\treturn !result || result === \"auto\" ? 0 : result;\n\t\t},\n\t\tset: function( tween ) {\n\n\t\t\t// Use step hook for back compat.\n\t\t\t// Use cssHook if its there.\n\t\t\t// Use .style if available and use plain properties where available.\n\t\t\tif ( jQuery.fx.step[ tween.prop ] ) {\n\t\t\t\tjQuery.fx.step[ tween.prop ]( tween );\n\t\t\t} else if ( tween.elem.nodeType === 1 &&\n\t\t\t\t( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||\n\t\t\t\t\tjQuery.cssHooks[ tween.prop ] ) ) {\n\t\t\t\tjQuery.style( tween.elem, tween.prop, tween.now + tween.unit );\n\t\t\t} else {\n\t\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t\t}\n\t\t}\n\t}\n};\n\n// Support: IE <=9 only\n// Panic based approach to setting things on disconnected nodes\nTween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {\n\tset: function( tween ) {\n\t\tif ( tween.elem.nodeType && tween.elem.parentNode ) {\n\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t}\n\t}\n};\n\njQuery.easing = {\n\tlinear: function( p ) {\n\t\treturn p;\n\t},\n\tswing: function( p ) {\n\t\treturn 0.5 - Math.cos( p * Math.PI ) / 2;\n\t},\n\t_default: \"swing\"\n};\n\njQuery.fx = Tween.prototype.init;\n\n// Back compat <1.8 extension point\njQuery.fx.step = {};\n\n\n\n\nvar\n\tfxNow, inProgress,\n\trfxtypes = /^(?:toggle|show|hide)$/,\n\trrun = /queueHooks$/;\n\nfunction schedule() {\n\tif ( inProgress ) {\n\t\tif ( document.hidden === false && window.requestAnimationFrame ) {\n\t\t\twindow.requestAnimationFrame( schedule );\n\t\t} else {\n\t\t\twindow.setTimeout( schedule, jQuery.fx.interval );\n\t\t}\n\n\t\tjQuery.fx.tick();\n\t}\n}\n\n// Animations created synchronously will run synchronously\nfunction createFxNow() {\n\twindow.setTimeout( function() {\n\t\tfxNow = undefined;\n\t} );\n\treturn ( fxNow = jQuery.now() );\n}\n\n// Generate parameters to create a standard animation\nfunction genFx( type, includeWidth ) {\n\tvar which,\n\t\ti = 0,\n\t\tattrs = { height: type };\n\n\t// If we include width, step value is 1 to do all cssExpand values,\n\t// otherwise step value is 2 to skip over Left and Right\n\tincludeWidth = includeWidth ? 1 : 0;\n\tfor ( ; i < 4; i += 2 - includeWidth ) {\n\t\twhich = cssExpand[ i ];\n\t\tattrs[ \"margin\" + which ] = attrs[ \"padding\" + which ] = type;\n\t}\n\n\tif ( includeWidth ) {\n\t\tattrs.opacity = attrs.width = type;\n\t}\n\n\treturn attrs;\n}\n\nfunction createTween( value, prop, animation ) {\n\tvar tween,\n\t\tcollection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ \"*\" ] ),\n\t\tindex = 0,\n\t\tlength = collection.length;\n\tfor ( ; index < length; index++ ) {\n\t\tif ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {\n\n\t\t\t// We're done with this property\n\t\t\treturn tween;\n\t\t}\n\t}\n}\n\nfunction defaultPrefilter( elem, props, opts ) {\n\tvar prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,\n\t\tisBox = \"width\" in props || \"height\" in props,\n\t\tanim = this,\n\t\torig = {},\n\t\tstyle = elem.style,\n\t\thidden = elem.nodeType && isHiddenWithinTree( elem ),\n\t\tdataShow = dataPriv.get( elem, \"fxshow\" );\n\n\t// Queue-skipping animations hijack the fx hooks\n\tif ( !opts.queue ) {\n\t\thooks = jQuery._queueHooks( elem, \"fx\" );\n\t\tif ( hooks.unqueued == null ) {\n\t\t\thooks.unqueued = 0;\n\t\t\toldfire = hooks.empty.fire;\n\t\t\thooks.empty.fire = function() {\n\t\t\t\tif ( !hooks.unqueued ) {\n\t\t\t\t\toldfire();\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t\thooks.unqueued++;\n\n\t\tanim.always( function() {\n\n\t\t\t// Ensure the complete handler is called before this completes\n\t\t\tanim.always( function() {\n\t\t\t\thooks.unqueued--;\n\t\t\t\tif ( !jQuery.queue( elem, \"fx\" ).length ) {\n\t\t\t\t\thooks.empty.fire();\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\t}\n\n\t// Detect show/hide animations\n\tfor ( prop in props ) {\n\t\tvalue = props[ prop ];\n\t\tif ( rfxtypes.test( value ) ) {\n\t\t\tdelete props[ prop ];\n\t\t\ttoggle = toggle || value === \"toggle\";\n\t\t\tif ( value === ( hidden ? \"hide\" : \"show\" ) ) {\n\n\t\t\t\t// Pretend to be hidden if this is a \"show\" and\n\t\t\t\t// there is still data from a stopped show/hide\n\t\t\t\tif ( value === \"show\" && dataShow && dataShow[ prop ] !== undefined ) {\n\t\t\t\t\thidden = true;\n\n\t\t\t\t// Ignore all other no-op show/hide data\n\t\t\t\t} else {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\torig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );\n\t\t}\n\t}\n\n\t// Bail out if this is a no-op like .hide().hide()\n\tpropTween = !jQuery.isEmptyObject( props );\n\tif ( !propTween && jQuery.isEmptyObject( orig ) ) {\n\t\treturn;\n\t}\n\n\t// Restrict \"overflow\" and \"display\" styles during box animations\n\tif ( isBox && elem.nodeType === 1 ) {\n\n\t\t// Support: IE <=9 - 11, Edge 12 - 13\n\t\t// Record all 3 overflow attributes because IE does not infer the shorthand\n\t\t// from identically-valued overflowX and overflowY\n\t\topts.overflow = [ style.overflow, style.overflowX, style.overflowY ];\n\n\t\t// Identify a display type, preferring old show/hide data over the CSS cascade\n\t\trestoreDisplay = dataShow && dataShow.display;\n\t\tif ( restoreDisplay == null ) {\n\t\t\trestoreDisplay = dataPriv.get( elem, \"display\" );\n\t\t}\n\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\tif ( display === \"none\" ) {\n\t\t\tif ( restoreDisplay ) {\n\t\t\t\tdisplay = restoreDisplay;\n\t\t\t} else {\n\n\t\t\t\t// Get nonempty value(s) by temporarily forcing visibility\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t\trestoreDisplay = elem.style.display || restoreDisplay;\n\t\t\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\t\t\tshowHide( [ elem ] );\n\t\t\t}\n\t\t}\n\n\t\t// Animate inline elements as inline-block\n\t\tif ( display === \"inline\" || display === \"inline-block\" && restoreDisplay != null ) {\n\t\t\tif ( jQuery.css( elem, \"float\" ) === \"none\" ) {\n\n\t\t\t\t// Restore the original display value at the end of pure show/hide animations\n\t\t\t\tif ( !propTween ) {\n\t\t\t\t\tanim.done( function() {\n\t\t\t\t\t\tstyle.display = restoreDisplay;\n\t\t\t\t\t} );\n\t\t\t\t\tif ( restoreDisplay == null ) {\n\t\t\t\t\t\tdisplay = style.display;\n\t\t\t\t\t\trestoreDisplay = display === \"none\" ? \"\" : display;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tstyle.display = \"inline-block\";\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( opts.overflow ) {\n\t\tstyle.overflow = \"hidden\";\n\t\tanim.always( function() {\n\t\t\tstyle.overflow = opts.overflow[ 0 ];\n\t\t\tstyle.overflowX = opts.overflow[ 1 ];\n\t\t\tstyle.overflowY = opts.overflow[ 2 ];\n\t\t} );\n\t}\n\n\t// Implement show/hide animations\n\tpropTween = false;\n\tfor ( prop in orig ) {\n\n\t\t// General show/hide setup for this element animation\n\t\tif ( !propTween ) {\n\t\t\tif ( dataShow ) {\n\t\t\t\tif ( \"hidden\" in dataShow ) {\n\t\t\t\t\thidden = dataShow.hidden;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tdataShow = dataPriv.access( elem, \"fxshow\", { display: restoreDisplay } );\n\t\t\t}\n\n\t\t\t// Store hidden/visible for toggle so `.stop().toggle()` \"reverses\"\n\t\t\tif ( toggle ) {\n\t\t\t\tdataShow.hidden = !hidden;\n\t\t\t}\n\n\t\t\t// Show elements before animating them\n\t\t\tif ( hidden ) {\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t}\n\n\t\t\t/* eslint-disable no-loop-func */\n\n\t\t\tanim.done( function() {\n\n\t\t\t/* eslint-enable no-loop-func */\n\n\t\t\t\t// The final step of a \"hide\" animation is actually hiding the element\n\t\t\t\tif ( !hidden ) {\n\t\t\t\t\tshowHide( [ elem ] );\n\t\t\t\t}\n\t\t\t\tdataPriv.remove( elem, \"fxshow\" );\n\t\t\t\tfor ( prop in orig ) {\n\t\t\t\t\tjQuery.style( elem, prop, orig[ prop ] );\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\t// Per-property setup\n\t\tpropTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );\n\t\tif ( !( prop in dataShow ) ) {\n\t\t\tdataShow[ prop ] = propTween.start;\n\t\t\tif ( hidden ) {\n\t\t\t\tpropTween.end = propTween.start;\n\t\t\t\tpropTween.start = 0;\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction propFilter( props, specialEasing ) {\n\tvar index, name, easing, value, hooks;\n\n\t// camelCase, specialEasing and expand cssHook pass\n\tfor ( index in props ) {\n\t\tname = jQuery.camelCase( index );\n\t\teasing = specialEasing[ name ];\n\t\tvalue = props[ index ];\n\t\tif ( Array.isArray( value ) ) {\n\t\t\teasing = value[ 1 ];\n\t\t\tvalue = props[ index ] = value[ 0 ];\n\t\t}\n\n\t\tif ( index !== name ) {\n\t\t\tprops[ name ] = value;\n\t\t\tdelete props[ index ];\n\t\t}\n\n\t\thooks = jQuery.cssHooks[ name ];\n\t\tif ( hooks && \"expand\" in hooks ) {\n\t\t\tvalue = hooks.expand( value );\n\t\t\tdelete props[ name ];\n\n\t\t\t// Not quite $.extend, this won't overwrite existing keys.\n\t\t\t// Reusing 'index' because we have the correct \"name\"\n\t\t\tfor ( index in value ) {\n\t\t\t\tif ( !( index in props ) ) {\n\t\t\t\t\tprops[ index ] = value[ index ];\n\t\t\t\t\tspecialEasing[ index ] = easing;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tspecialEasing[ name ] = easing;\n\t\t}\n\t}\n}\n\nfunction Animation( elem, properties, options ) {\n\tvar result,\n\t\tstopped,\n\t\tindex = 0,\n\t\tlength = Animation.prefilters.length,\n\t\tdeferred = jQuery.Deferred().always( function() {\n\n\t\t\t// Don't match elem in the :animated selector\n\t\t\tdelete tick.elem;\n\t\t} ),\n\t\ttick = function() {\n\t\t\tif ( stopped ) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tvar currentTime = fxNow || createFxNow(),\n\t\t\t\tremaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),\n\n\t\t\t\t// Support: Android 2.3 only\n\t\t\t\t// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)\n\t\t\t\ttemp = remaining / animation.duration || 0,\n\t\t\t\tpercent = 1 - temp,\n\t\t\t\tindex = 0,\n\t\t\t\tlength = animation.tweens.length;\n\n\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\tanimation.tweens[ index ].run( percent );\n\t\t\t}\n\n\t\t\tdeferred.notifyWith( elem, [ animation, percent, remaining ] );\n\n\t\t\t// If there's more to do, yield\n\t\t\tif ( percent < 1 && length ) {\n\t\t\t\treturn remaining;\n\t\t\t}\n\n\t\t\t// If this was an empty animation, synthesize a final progress notification\n\t\t\tif ( !length ) {\n\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t}\n\n\t\t\t// Resolve the animation and report its conclusion\n\t\t\tdeferred.resolveWith( elem, [ animation ] );\n\t\t\treturn false;\n\t\t},\n\t\tanimation = deferred.promise( {\n\t\t\telem: elem,\n\t\t\tprops: jQuery.extend( {}, properties ),\n\t\t\topts: jQuery.extend( true, {\n\t\t\t\tspecialEasing: {},\n\t\t\t\teasing: jQuery.easing._default\n\t\t\t}, options ),\n\t\t\toriginalProperties: properties,\n\t\t\toriginalOptions: options,\n\t\t\tstartTime: fxNow || createFxNow(),\n\t\t\tduration: options.duration,\n\t\t\ttweens: [],\n\t\t\tcreateTween: function( prop, end ) {\n\t\t\t\tvar tween = jQuery.Tween( elem, animation.opts, prop, end,\n\t\t\t\t\t\tanimation.opts.specialEasing[ prop ] || animation.opts.easing );\n\t\t\t\tanimation.tweens.push( tween );\n\t\t\t\treturn tween;\n\t\t\t},\n\t\t\tstop: function( gotoEnd ) {\n\t\t\t\tvar index = 0,\n\n\t\t\t\t\t// If we are going to the end, we want to run all the tweens\n\t\t\t\t\t// otherwise we skip this part\n\t\t\t\t\tlength = gotoEnd ? animation.tweens.length : 0;\n\t\t\t\tif ( stopped ) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t\tstopped = true;\n\t\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\t\tanimation.tweens[ index ].run( 1 );\n\t\t\t\t}\n\n\t\t\t\t// Resolve when we played the last frame; otherwise, reject\n\t\t\t\tif ( gotoEnd ) {\n\t\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t\t\tdeferred.resolveWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t} else {\n\t\t\t\t\tdeferred.rejectWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t}\n\t\t} ),\n\t\tprops = animation.props;\n\n\tpropFilter( props, animation.opts.specialEasing );\n\n\tfor ( ; index < length; index++ ) {\n\t\tresult = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );\n\t\tif ( result ) {\n\t\t\tif ( jQuery.isFunction( result.stop ) ) {\n\t\t\t\tjQuery._queueHooks( animation.elem, animation.opts.queue ).stop =\n\t\t\t\t\tjQuery.proxy( result.stop, result );\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\t}\n\n\tjQuery.map( props, createTween, animation );\n\n\tif ( jQuery.isFunction( animation.opts.start ) ) {\n\t\tanimation.opts.start.call( elem, animation );\n\t}\n\n\t// Attach callbacks from options\n\tanimation\n\t\t.progress( animation.opts.progress )\n\t\t.done( animation.opts.done, animation.opts.complete )\n\t\t.fail( animation.opts.fail )\n\t\t.always( animation.opts.always );\n\n\tjQuery.fx.timer(\n\t\tjQuery.extend( tick, {\n\t\t\telem: elem,\n\t\t\tanim: animation,\n\t\t\tqueue: animation.opts.queue\n\t\t} )\n\t);\n\n\treturn animation;\n}\n\njQuery.Animation = jQuery.extend( Animation, {\n\n\ttweeners: {\n\t\t\"*\": [ function( prop, value ) {\n\t\t\tvar tween = this.createTween( prop, value );\n\t\t\tadjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );\n\t\t\treturn tween;\n\t\t} ]\n\t},\n\n\ttweener: function( props, callback ) {\n\t\tif ( jQuery.isFunction( props ) ) {\n\t\t\tcallback = props;\n\t\t\tprops = [ \"*\" ];\n\t\t} else {\n\t\t\tprops = props.match( rnothtmlwhite );\n\t\t}\n\n\t\tvar prop,\n\t\t\tindex = 0,\n\t\t\tlength = props.length;\n\n\t\tfor ( ; index < length; index++ ) {\n\t\t\tprop = props[ index ];\n\t\t\tAnimation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];\n\t\t\tAnimation.tweeners[ prop ].unshift( callback );\n\t\t}\n\t},\n\n\tprefilters: [ defaultPrefilter ],\n\n\tprefilter: function( callback, prepend ) {\n\t\tif ( prepend ) {\n\t\t\tAnimation.prefilters.unshift( callback );\n\t\t} else {\n\t\t\tAnimation.prefilters.push( callback );\n\t\t}\n\t}\n} );\n\njQuery.speed = function( speed, easing, fn ) {\n\tvar opt = speed && typeof speed === \"object\" ? jQuery.extend( {}, speed ) : {\n\t\tcomplete: fn || !fn && easing ||\n\t\t\tjQuery.isFunction( speed ) && speed,\n\t\tduration: speed,\n\t\teasing: fn && easing || easing && !jQuery.isFunction( easing ) && easing\n\t};\n\n\t// Go to the end state if fx are off\n\tif ( jQuery.fx.off ) {\n\t\topt.duration = 0;\n\n\t} else {\n\t\tif ( typeof opt.duration !== \"number\" ) {\n\t\t\tif ( opt.duration in jQuery.fx.speeds ) {\n\t\t\t\topt.duration = jQuery.fx.speeds[ opt.duration ];\n\n\t\t\t} else {\n\t\t\t\topt.duration = jQuery.fx.speeds._default;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Normalize opt.queue - true/undefined/null -> \"fx\"\n\tif ( opt.queue == null || opt.queue === true ) {\n\t\topt.queue = \"fx\";\n\t}\n\n\t// Queueing\n\topt.old = opt.complete;\n\n\topt.complete = function() {\n\t\tif ( jQuery.isFunction( opt.old ) ) {\n\t\t\topt.old.call( this );\n\t\t}\n\n\t\tif ( opt.queue ) {\n\t\t\tjQuery.dequeue( this, opt.queue );\n\t\t}\n\t};\n\n\treturn opt;\n};\n\njQuery.fn.extend( {\n\tfadeTo: function( speed, to, easing, callback ) {\n\n\t\t// Show any hidden elements after setting opacity to 0\n\t\treturn this.filter( isHiddenWithinTree ).css( \"opacity\", 0 ).show()\n\n\t\t\t// Animate to the value specified\n\t\t\t.end().animate( { opacity: to }, speed, easing, callback );\n\t},\n\tanimate: function( prop, speed, easing, callback ) {\n\t\tvar empty = jQuery.isEmptyObject( prop ),\n\t\t\toptall = jQuery.speed( speed, easing, callback ),\n\t\t\tdoAnimation = function() {\n\n\t\t\t\t// Operate on a copy of prop so per-property easing won't be lost\n\t\t\t\tvar anim = Animation( this, jQuery.extend( {}, prop ), optall );\n\n\t\t\t\t// Empty animations, or finishing resolves immediately\n\t\t\t\tif ( empty || dataPriv.get( this, \"finish\" ) ) {\n\t\t\t\t\tanim.stop( true );\n\t\t\t\t}\n\t\t\t};\n\t\t\tdoAnimation.finish = doAnimation;\n\n\t\treturn empty || optall.queue === false ?\n\t\t\tthis.each( doAnimation ) :\n\t\t\tthis.queue( optall.queue, doAnimation );\n\t},\n\tstop: function( type, clearQueue, gotoEnd ) {\n\t\tvar stopQueue = function( hooks ) {\n\t\t\tvar stop = hooks.stop;\n\t\t\tdelete hooks.stop;\n\t\t\tstop( gotoEnd );\n\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tgotoEnd = clearQueue;\n\t\t\tclearQueue = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\tif ( clearQueue && type !== false ) {\n\t\t\tthis.queue( type || \"fx\", [] );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar dequeue = true,\n\t\t\t\tindex = type != null && type + \"queueHooks\",\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tdata = dataPriv.get( this );\n\n\t\t\tif ( index ) {\n\t\t\t\tif ( data[ index ] && data[ index ].stop ) {\n\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor ( index in data ) {\n\t\t\t\t\tif ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {\n\t\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this &&\n\t\t\t\t\t( type == null || timers[ index ].queue === type ) ) {\n\n\t\t\t\t\ttimers[ index ].anim.stop( gotoEnd );\n\t\t\t\t\tdequeue = false;\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Start the next in the queue if the last step wasn't forced.\n\t\t\t// Timers currently will call their complete callbacks, which\n\t\t\t// will dequeue but only if they were gotoEnd.\n\t\t\tif ( dequeue || !gotoEnd ) {\n\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t}\n\t\t} );\n\t},\n\tfinish: function( type ) {\n\t\tif ( type !== false ) {\n\t\t\ttype = type || \"fx\";\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tvar index,\n\t\t\t\tdata = dataPriv.get( this ),\n\t\t\t\tqueue = data[ type + \"queue\" ],\n\t\t\t\thooks = data[ type + \"queueHooks\" ],\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tlength = queue ? queue.length : 0;\n\n\t\t\t// Enable finishing flag on private data\n\t\t\tdata.finish = true;\n\n\t\t\t// Empty the queue first\n\t\t\tjQuery.queue( this, type, [] );\n\n\t\t\tif ( hooks && hooks.stop ) {\n\t\t\t\thooks.stop.call( this, true );\n\t\t\t}\n\n\t\t\t// Look for any active animations, and finish them\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this && timers[ index ].queue === type ) {\n\t\t\t\t\ttimers[ index ].anim.stop( true );\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Look for any animations in the old queue and finish them\n\t\t\tfor ( index = 0; index < length; index++ ) {\n\t\t\t\tif ( queue[ index ] && queue[ index ].finish ) {\n\t\t\t\t\tqueue[ index ].finish.call( this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Turn off finishing flag\n\t\t\tdelete data.finish;\n\t\t} );\n\t}\n} );\n\njQuery.each( [ \"toggle\", \"show\", \"hide\" ], function( i, name ) {\n\tvar cssFn = jQuery.fn[ name ];\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn speed == null || typeof speed === \"boolean\" ?\n\t\t\tcssFn.apply( this, arguments ) :\n\t\t\tthis.animate( genFx( name, true ), speed, easing, callback );\n\t};\n} );\n\n// Generate shortcuts for custom animations\njQuery.each( {\n\tslideDown: genFx( \"show\" ),\n\tslideUp: genFx( \"hide\" ),\n\tslideToggle: genFx( \"toggle\" ),\n\tfadeIn: { opacity: \"show\" },\n\tfadeOut: { opacity: \"hide\" },\n\tfadeToggle: { opacity: \"toggle\" }\n}, function( name, props ) {\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn this.animate( props, speed, easing, callback );\n\t};\n} );\n\njQuery.timers = [];\njQuery.fx.tick = function() {\n\tvar timer,\n\t\ti = 0,\n\t\ttimers = jQuery.timers;\n\n\tfxNow = jQuery.now();\n\n\tfor ( ; i < timers.length; i++ ) {\n\t\ttimer = timers[ i ];\n\n\t\t// Run the timer and safely remove it when done (allowing for external removal)\n\t\tif ( !timer() && timers[ i ] === timer ) {\n\t\t\ttimers.splice( i--, 1 );\n\t\t}\n\t}\n\n\tif ( !timers.length ) {\n\t\tjQuery.fx.stop();\n\t}\n\tfxNow = undefined;\n};\n\njQuery.fx.timer = function( timer ) {\n\tjQuery.timers.push( timer );\n\tjQuery.fx.start();\n};\n\njQuery.fx.interval = 13;\njQuery.fx.start = function() {\n\tif ( inProgress ) {\n\t\treturn;\n\t}\n\n\tinProgress = true;\n\tschedule();\n};\n\njQuery.fx.stop = function() {\n\tinProgress = null;\n};\n\njQuery.fx.speeds = {\n\tslow: 600,\n\tfast: 200,\n\n\t// Default speed\n\t_default: 400\n};\n\n\n// Based off of the plugin by Clint Helfers, with permission.\n// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/\njQuery.fn.delay = function( time, type ) {\n\ttime = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;\n\ttype = type || \"fx\";\n\n\treturn this.queue( type, function( next, hooks ) {\n\t\tvar timeout = window.setTimeout( next, time );\n\t\thooks.stop = function() {\n\t\t\twindow.clearTimeout( timeout );\n\t\t};\n\t} );\n};\n\n\n( function() {\n\tvar input = document.createElement( \"input\" ),\n\t\tselect = document.createElement( \"select\" ),\n\t\topt = select.appendChild( document.createElement( \"option\" ) );\n\n\tinput.type = \"checkbox\";\n\n\t// Support: Android <=4.3 only\n\t// Default value for a checkbox should be \"on\"\n\tsupport.checkOn = input.value !== \"\";\n\n\t// Support: IE <=11 only\n\t// Must access selectedIndex to make default options select\n\tsupport.optSelected = opt.selected;\n\n\t// Support: IE <=11 only\n\t// An input loses its value after becoming a radio\n\tinput = document.createElement( \"input\" );\n\tinput.value = \"t\";\n\tinput.type = \"radio\";\n\tsupport.radioValue = input.value === \"t\";\n} )();\n\n\nvar boolHook,\n\tattrHandle = jQuery.expr.attrHandle;\n\njQuery.fn.extend( {\n\tattr: function( name, value ) {\n\t\treturn access( this, jQuery.attr, name, value, arguments.length > 1 );\n\t},\n\n\tremoveAttr: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.removeAttr( this, name );\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tattr: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set attributes on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Fallback to prop when attributes are not supported\n\t\tif ( typeof elem.getAttribute === \"undefined\" ) {\n\t\t\treturn jQuery.prop( elem, name, value );\n\t\t}\n\n\t\t// Attribute hooks are determined by the lowercase version\n\t\t// Grab necessary hook if one is defined\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\t\t\thooks = jQuery.attrHooks[ name.toLowerCase() ] ||\n\t\t\t\t( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( value === null ) {\n\t\t\t\tjQuery.removeAttr( elem, name );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\telem.setAttribute( name, value + \"\" );\n\t\t\treturn value;\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\tret = jQuery.find.attr( elem, name );\n\n\t\t// Non-existent attributes return null, we normalize to undefined\n\t\treturn ret == null ? undefined : ret;\n\t},\n\n\tattrHooks: {\n\t\ttype: {\n\t\t\tset: function( elem, value ) {\n\t\t\t\tif ( !support.radioValue && value === \"radio\" &&\n\t\t\t\t\tnodeName( elem, \"input\" ) ) {\n\t\t\t\t\tvar val = elem.value;\n\t\t\t\t\telem.setAttribute( \"type\", value );\n\t\t\t\t\tif ( val ) {\n\t\t\t\t\t\telem.value = val;\n\t\t\t\t\t}\n\t\t\t\t\treturn value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\tremoveAttr: function( elem, value ) {\n\t\tvar name,\n\t\t\ti = 0,\n\n\t\t\t// Attribute names can contain non-HTML whitespace characters\n\t\t\t// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n\t\t\tattrNames = value && value.match( rnothtmlwhite );\n\n\t\tif ( attrNames && elem.nodeType === 1 ) {\n\t\t\twhile ( ( name = attrNames[ i++ ] ) ) {\n\t\t\t\telem.removeAttribute( name );\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Hooks for boolean attributes\nboolHook = {\n\tset: function( elem, value, name ) {\n\t\tif ( value === false ) {\n\n\t\t\t// Remove boolean attributes when set to false\n\t\t\tjQuery.removeAttr( elem, name );\n\t\t} else {\n\t\t\telem.setAttribute( name, name );\n\t\t}\n\t\treturn name;\n\t}\n};\n\njQuery.each( jQuery.expr.match.bool.source.match( /\\w+/g ), function( i, name ) {\n\tvar getter = attrHandle[ name ] || jQuery.find.attr;\n\n\tattrHandle[ name ] = function( elem, name, isXML ) {\n\t\tvar ret, handle,\n\t\t\tlowercaseName = name.toLowerCase();\n\n\t\tif ( !isXML ) {\n\n\t\t\t// Avoid an infinite loop by temporarily removing this function from the getter\n\t\t\thandle = attrHandle[ lowercaseName ];\n\t\t\tattrHandle[ lowercaseName ] = ret;\n\t\t\tret = getter( elem, name, isXML ) != null ?\n\t\t\t\tlowercaseName :\n\t\t\t\tnull;\n\t\t\tattrHandle[ lowercaseName ] = handle;\n\t\t}\n\t\treturn ret;\n\t};\n} );\n\n\n\n\nvar rfocusable = /^(?:input|select|textarea|button)$/i,\n\trclickable = /^(?:a|area)$/i;\n\njQuery.fn.extend( {\n\tprop: function( name, value ) {\n\t\treturn access( this, jQuery.prop, name, value, arguments.length > 1 );\n\t},\n\n\tremoveProp: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tdelete this[ jQuery.propFix[ name ] || name ];\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tprop: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set properties on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// Fix name and attach hooks\n\t\t\tname = jQuery.propFix[ name ] || name;\n\t\t\thooks = jQuery.propHooks[ name ];\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\treturn ( elem[ name ] = value );\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\treturn elem[ name ];\n\t},\n\n\tpropHooks: {\n\t\ttabIndex: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\t// Support: IE <=9 - 11 only\n\t\t\t\t// elem.tabIndex doesn't always return the\n\t\t\t\t// correct value when it hasn't been explicitly set\n\t\t\t\t// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/\n\t\t\t\t// Use proper attribute retrieval(#12072)\n\t\t\t\tvar tabindex = jQuery.find.attr( elem, \"tabindex\" );\n\n\t\t\t\tif ( tabindex ) {\n\t\t\t\t\treturn parseInt( tabindex, 10 );\n\t\t\t\t}\n\n\t\t\t\tif (\n\t\t\t\t\trfocusable.test( elem.nodeName ) ||\n\t\t\t\t\trclickable.test( elem.nodeName ) &&\n\t\t\t\t\telem.href\n\t\t\t\t) {\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t},\n\n\tpropFix: {\n\t\t\"for\": \"htmlFor\",\n\t\t\"class\": \"className\"\n\t}\n} );\n\n// Support: IE <=11 only\n// Accessing the selectedIndex property\n// forces the browser to respect setting selected\n// on the option\n// The getter ensures a default option is selected\n// when in an optgroup\n// eslint rule \"no-unused-expressions\" is disabled for this code\n// since it considers such accessions noop\nif ( !support.optSelected ) {\n\tjQuery.propHooks.selected = {\n\t\tget: function( elem ) {\n\n\t\t\t/* eslint no-unused-expressions: \"off\" */\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent && parent.parentNode ) {\n\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t}\n\t\t\treturn null;\n\t\t},\n\t\tset: function( elem ) {\n\n\t\t\t/* eslint no-unused-expressions: \"off\" */\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent ) {\n\t\t\t\tparent.selectedIndex;\n\n\t\t\t\tif ( parent.parentNode ) {\n\t\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\njQuery.each( [\n\t\"tabIndex\",\n\t\"readOnly\",\n\t\"maxLength\",\n\t\"cellSpacing\",\n\t\"cellPadding\",\n\t\"rowSpan\",\n\t\"colSpan\",\n\t\"useMap\",\n\t\"frameBorder\",\n\t\"contentEditable\"\n], function() {\n\tjQuery.propFix[ this.toLowerCase() ] = this;\n} );\n\n\n\n\n\t// Strip and collapse whitespace according to HTML spec\n\t// https://html.spec.whatwg.org/multipage/infrastructure.html#strip-and-collapse-whitespace\n\tfunction stripAndCollapse( value ) {\n\t\tvar tokens = value.match( rnothtmlwhite ) || [];\n\t\treturn tokens.join( \" \" );\n\t}\n\n\nfunction getClass( elem ) {\n\treturn elem.getAttribute && elem.getAttribute( \"class\" ) || \"\";\n}\n\njQuery.fn.extend( {\n\taddClass: function( value ) {\n\t\tvar classes, elem, cur, curValue, clazz, j, finalValue,\n\t\t\ti = 0;\n\n\t\tif ( jQuery.isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).addClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( typeof value === \"string\" && value ) {\n\t\t\tclasses = value.match( rnothtmlwhite ) || [];\n\n\t\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\t\tcurValue = getClass( elem );\n\t\t\t\tcur = elem.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\twhile ( ( clazz = classes[ j++ ] ) ) {\n\t\t\t\t\t\tif ( cur.indexOf( \" \" + clazz + \" \" ) < 0 ) {\n\t\t\t\t\t\t\tcur += clazz + \" \";\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\telem.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tremoveClass: function( value ) {\n\t\tvar classes, elem, cur, curValue, clazz, j, finalValue,\n\t\t\ti = 0;\n\n\t\tif ( jQuery.isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( !arguments.length ) {\n\t\t\treturn this.attr( \"class\", \"\" );\n\t\t}\n\n\t\tif ( typeof value === \"string\" && value ) {\n\t\t\tclasses = value.match( rnothtmlwhite ) || [];\n\n\t\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\t\tcurValue = getClass( elem );\n\n\t\t\t\t// This expression is here for better compressibility (see addClass)\n\t\t\t\tcur = elem.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\twhile ( ( clazz = classes[ j++ ] ) ) {\n\n\t\t\t\t\t\t// Remove *all* instances\n\t\t\t\t\t\twhile ( cur.indexOf( \" \" + clazz + \" \" ) > -1 ) {\n\t\t\t\t\t\t\tcur = cur.replace( \" \" + clazz + \" \", \" \" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\telem.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\ttoggleClass: function( value, stateVal ) {\n\t\tvar type = typeof value;\n\n\t\tif ( typeof stateVal === \"boolean\" && type === \"string\" ) {\n\t\t\treturn stateVal ? this.addClass( value ) : this.removeClass( value );\n\t\t}\n\n\t\tif ( jQuery.isFunction( value ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).toggleClass(\n\t\t\t\t\tvalue.call( this, i, getClass( this ), stateVal ),\n\t\t\t\t\tstateVal\n\t\t\t\t);\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar className, i, self, classNames;\n\n\t\t\tif ( type === \"string\" ) {\n\n\t\t\t\t// Toggle individual class names\n\t\t\t\ti = 0;\n\t\t\t\tself = jQuery( this );\n\t\t\t\tclassNames = value.match( rnothtmlwhite ) || [];\n\n\t\t\t\twhile ( ( className = classNames[ i++ ] ) ) {\n\n\t\t\t\t\t// Check each className given, space separated list\n\t\t\t\t\tif ( self.hasClass( className ) ) {\n\t\t\t\t\t\tself.removeClass( className );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself.addClass( className );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t// Toggle whole class name\n\t\t\t} else if ( value === undefined || type === \"boolean\" ) {\n\t\t\t\tclassName = getClass( this );\n\t\t\t\tif ( className ) {\n\n\t\t\t\t\t// Store className if set\n\t\t\t\t\tdataPriv.set( this, \"__className__\", className );\n\t\t\t\t}\n\n\t\t\t\t// If the element has a class name or if we're passed `false`,\n\t\t\t\t// then remove the whole classname (if there was one, the above saved it).\n\t\t\t\t// Otherwise bring back whatever was previously saved (if anything),\n\t\t\t\t// falling back to the empty string if nothing was stored.\n\t\t\t\tif ( this.setAttribute ) {\n\t\t\t\t\tthis.setAttribute( \"class\",\n\t\t\t\t\t\tclassName || value === false ?\n\t\t\t\t\t\t\"\" :\n\t\t\t\t\t\tdataPriv.get( this, \"__className__\" ) || \"\"\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\thasClass: function( selector ) {\n\t\tvar className, elem,\n\t\t\ti = 0;\n\n\t\tclassName = \" \" + selector + \" \";\n\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\tif ( elem.nodeType === 1 &&\n\t\t\t\t( \" \" + stripAndCollapse( getClass( elem ) ) + \" \" ).indexOf( className ) > -1 ) {\n\t\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n} );\n\n\n\n\nvar rreturn = /\\r/g;\n\njQuery.fn.extend( {\n\tval: function( value ) {\n\t\tvar hooks, ret, isFunction,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !arguments.length ) {\n\t\t\tif ( elem ) {\n\t\t\t\thooks = jQuery.valHooks[ elem.type ] ||\n\t\t\t\t\tjQuery.valHooks[ elem.nodeName.toLowerCase() ];\n\n\t\t\t\tif ( hooks &&\n\t\t\t\t\t\"get\" in hooks &&\n\t\t\t\t\t( ret = hooks.get( elem, \"value\" ) ) !== undefined\n\t\t\t\t) {\n\t\t\t\t\treturn ret;\n\t\t\t\t}\n\n\t\t\t\tret = elem.value;\n\n\t\t\t\t// Handle most common string cases\n\t\t\t\tif ( typeof ret === \"string\" ) {\n\t\t\t\t\treturn ret.replace( rreturn, \"\" );\n\t\t\t\t}\n\n\t\t\t\t// Handle cases where value is null/undef or number\n\t\t\t\treturn ret == null ? \"\" : ret;\n\t\t\t}\n\n\t\t\treturn;\n\t\t}\n\n\t\tisFunction = jQuery.isFunction( value );\n\n\t\treturn this.each( function( i ) {\n\t\t\tvar val;\n\n\t\t\tif ( this.nodeType !== 1 ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( isFunction ) {\n\t\t\t\tval = value.call( this, i, jQuery( this ).val() );\n\t\t\t} else {\n\t\t\t\tval = value;\n\t\t\t}\n\n\t\t\t// Treat null/undefined as \"\"; convert numbers to string\n\t\t\tif ( val == null ) {\n\t\t\t\tval = \"\";\n\n\t\t\t} else if ( typeof val === \"number\" ) {\n\t\t\t\tval += \"\";\n\n\t\t\t} else if ( Array.isArray( val ) ) {\n\t\t\t\tval = jQuery.map( val, function( value ) {\n\t\t\t\t\treturn value == null ? \"\" : value + \"\";\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\thooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];\n\n\t\t\t// If set returns undefined, fall back to normal setting\n\t\t\tif ( !hooks || !( \"set\" in hooks ) || hooks.set( this, val, \"value\" ) === undefined ) {\n\t\t\t\tthis.value = val;\n\t\t\t}\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tvalHooks: {\n\t\toption: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\tvar val = jQuery.find.attr( elem, \"value\" );\n\t\t\t\treturn val != null ?\n\t\t\t\t\tval :\n\n\t\t\t\t\t// Support: IE <=10 - 11 only\n\t\t\t\t\t// option.text throws exceptions (#14686, #14858)\n\t\t\t\t\t// Strip and collapse whitespace\n\t\t\t\t\t// https://html.spec.whatwg.org/#strip-and-collapse-whitespace\n\t\t\t\t\tstripAndCollapse( jQuery.text( elem ) );\n\t\t\t}\n\t\t},\n\t\tselect: {\n\t\t\tget: function( elem ) {\n\t\t\t\tvar value, option, i,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tindex = elem.selectedIndex,\n\t\t\t\t\tone = elem.type === \"select-one\",\n\t\t\t\t\tvalues = one ? null : [],\n\t\t\t\t\tmax = one ? index + 1 : options.length;\n\n\t\t\t\tif ( index < 0 ) {\n\t\t\t\t\ti = max;\n\n\t\t\t\t} else {\n\t\t\t\t\ti = one ? index : 0;\n\t\t\t\t}\n\n\t\t\t\t// Loop through all the selected options\n\t\t\t\tfor ( ; i < max; i++ ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t// IE8-9 doesn't update selected after form reset (#2551)\n\t\t\t\t\tif ( ( option.selected || i === index ) &&\n\n\t\t\t\t\t\t\t// Don't return options that are disabled or in a disabled optgroup\n\t\t\t\t\t\t\t!option.disabled &&\n\t\t\t\t\t\t\t( !option.parentNode.disabled ||\n\t\t\t\t\t\t\t\t!nodeName( option.parentNode, \"optgroup\" ) ) ) {\n\n\t\t\t\t\t\t// Get the specific value for the option\n\t\t\t\t\t\tvalue = jQuery( option ).val();\n\n\t\t\t\t\t\t// We don't need an array for one selects\n\t\t\t\t\t\tif ( one ) {\n\t\t\t\t\t\t\treturn value;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Multi-Selects return an array\n\t\t\t\t\t\tvalues.push( value );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn values;\n\t\t\t},\n\n\t\t\tset: function( elem, value ) {\n\t\t\t\tvar optionSet, option,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tvalues = jQuery.makeArray( value ),\n\t\t\t\t\ti = options.length;\n\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t/* eslint-disable no-cond-assign */\n\n\t\t\t\t\tif ( option.selected =\n\t\t\t\t\t\tjQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1\n\t\t\t\t\t) {\n\t\t\t\t\t\toptionSet = true;\n\t\t\t\t\t}\n\n\t\t\t\t\t/* eslint-enable no-cond-assign */\n\t\t\t\t}\n\n\t\t\t\t// Force browsers to behave consistently when non-matching value is set\n\t\t\t\tif ( !optionSet ) {\n\t\t\t\t\telem.selectedIndex = -1;\n\t\t\t\t}\n\t\t\t\treturn values;\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Radios and checkboxes getter/setter\njQuery.each( [ \"radio\", \"checkbox\" ], function() {\n\tjQuery.valHooks[ this ] = {\n\t\tset: function( elem, value ) {\n\t\t\tif ( Array.isArray( value ) ) {\n\t\t\t\treturn ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );\n\t\t\t}\n\t\t}\n\t};\n\tif ( !support.checkOn ) {\n\t\tjQuery.valHooks[ this ].get = function( elem ) {\n\t\t\treturn elem.getAttribute( \"value\" ) === null ? \"on\" : elem.value;\n\t\t};\n\t}\n} );\n\n\n\n\n// Return jQuery for attributes-only inclusion\n\n\nvar rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;\n\njQuery.extend( jQuery.event, {\n\n\ttrigger: function( event, data, elem, onlyHandlers ) {\n\n\t\tvar i, cur, tmp, bubbleType, ontype, handle, special,\n\t\t\teventPath = [ elem || document ],\n\t\t\ttype = hasOwn.call( event, \"type\" ) ? event.type : event,\n\t\t\tnamespaces = hasOwn.call( event, \"namespace\" ) ? event.namespace.split( \".\" ) : [];\n\n\t\tcur = tmp = elem = elem || document;\n\n\t\t// Don't do events on text and comment nodes\n\t\tif ( elem.nodeType === 3 || elem.nodeType === 8 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// focus/blur morphs to focusin/out; ensure we're not firing them right now\n\t\tif ( rfocusMorph.test( type + jQuery.event.triggered ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( type.indexOf( \".\" ) > -1 ) {\n\n\t\t\t// Namespaced trigger; create a regexp to match event type in handle()\n\t\t\tnamespaces = type.split( \".\" );\n\t\t\ttype = namespaces.shift();\n\t\t\tnamespaces.sort();\n\t\t}\n\t\tontype = type.indexOf( \":\" ) < 0 && \"on\" + type;\n\n\t\t// Caller can pass in a jQuery.Event object, Object, or just an event type string\n\t\tevent = event[ jQuery.expando ] ?\n\t\t\tevent :\n\t\t\tnew jQuery.Event( type, typeof event === \"object\" && event );\n\n\t\t// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n\t\tevent.isTrigger = onlyHandlers ? 2 : 3;\n\t\tevent.namespace = namespaces.join( \".\" );\n\t\tevent.rnamespace = event.namespace ?\n\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" ) :\n\t\t\tnull;\n\n\t\t// Clean up the event in case it is being reused\n\t\tevent.result = undefined;\n\t\tif ( !event.target ) {\n\t\t\tevent.target = elem;\n\t\t}\n\n\t\t// Clone any incoming data and prepend the event, creating the handler arg list\n\t\tdata = data == null ?\n\t\t\t[ event ] :\n\t\t\tjQuery.makeArray( data, [ event ] );\n\n\t\t// Allow special events to draw outside the lines\n\t\tspecial = jQuery.event.special[ type ] || {};\n\t\tif ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine event propagation path in advance, per W3C events spec (#9951)\n\t\t// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)\n\t\tif ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {\n\n\t\t\tbubbleType = special.delegateType || type;\n\t\t\tif ( !rfocusMorph.test( bubbleType + type ) ) {\n\t\t\t\tcur = cur.parentNode;\n\t\t\t}\n\t\t\tfor ( ; cur; cur = cur.parentNode ) {\n\t\t\t\teventPath.push( cur );\n\t\t\t\ttmp = cur;\n\t\t\t}\n\n\t\t\t// Only add window if we got to document (e.g., not plain obj or detached DOM)\n\t\t\tif ( tmp === ( elem.ownerDocument || document ) ) {\n\t\t\t\teventPath.push( tmp.defaultView || tmp.parentWindow || window );\n\t\t\t}\n\t\t}\n\n\t\t// Fire handlers on the event path\n\t\ti = 0;\n\t\twhile ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {\n\n\t\t\tevent.type = i > 1 ?\n\t\t\t\tbubbleType :\n\t\t\t\tspecial.bindType || type;\n\n\t\t\t// jQuery handler\n\t\t\thandle = ( dataPriv.get( cur, \"events\" ) || {} )[ event.type ] &&\n\t\t\t\tdataPriv.get( cur, \"handle\" );\n\t\t\tif ( handle ) {\n\t\t\t\thandle.apply( cur, data );\n\t\t\t}\n\n\t\t\t// Native handler\n\t\t\thandle = ontype && cur[ ontype ];\n\t\t\tif ( handle && handle.apply && acceptData( cur ) ) {\n\t\t\t\tevent.result = handle.apply( cur, data );\n\t\t\t\tif ( event.result === false ) {\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tevent.type = type;\n\n\t\t// If nobody prevented the default action, do it now\n\t\tif ( !onlyHandlers && !event.isDefaultPrevented() ) {\n\n\t\t\tif ( ( !special._default ||\n\t\t\t\tspecial._default.apply( eventPath.pop(), data ) === false ) &&\n\t\t\t\tacceptData( elem ) ) {\n\n\t\t\t\t// Call a native DOM method on the target with the same name as the event.\n\t\t\t\t// Don't do default actions on window, that's where global variables be (#6170)\n\t\t\t\tif ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {\n\n\t\t\t\t\t// Don't re-trigger an onFOO event when we call its FOO() method\n\t\t\t\t\ttmp = elem[ ontype ];\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = null;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prevent re-triggering of the same event, since we already bubbled it above\n\t\t\t\t\tjQuery.event.triggered = type;\n\t\t\t\t\telem[ type ]();\n\t\t\t\t\tjQuery.event.triggered = undefined;\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = tmp;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\t// Piggyback on a donor event to simulate a different one\n\t// Used only for `focus(in | out)` events\n\tsimulate: function( type, elem, event ) {\n\t\tvar e = jQuery.extend(\n\t\t\tnew jQuery.Event(),\n\t\t\tevent,\n\t\t\t{\n\t\t\t\ttype: type,\n\t\t\t\tisSimulated: true\n\t\t\t}\n\t\t);\n\n\t\tjQuery.event.trigger( e, null, elem );\n\t}\n\n} );\n\njQuery.fn.extend( {\n\n\ttrigger: function( type, data ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.trigger( type, data, this );\n\t\t} );\n\t},\n\ttriggerHandler: function( type, data ) {\n\t\tvar elem = this[ 0 ];\n\t\tif ( elem ) {\n\t\t\treturn jQuery.event.trigger( type, data, elem, true );\n\t\t}\n\t}\n} );\n\n\njQuery.each( ( \"blur focus focusin focusout resize scroll click dblclick \" +\n\t\"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave \" +\n\t\"change select submit keydown keypress keyup contextmenu\" ).split( \" \" ),\n\tfunction( i, name ) {\n\n\t// Handle event binding\n\tjQuery.fn[ name ] = function( data, fn ) {\n\t\treturn arguments.length > 0 ?\n\t\t\tthis.on( name, null, data, fn ) :\n\t\t\tthis.trigger( name );\n\t};\n} );\n\njQuery.fn.extend( {\n\thover: function( fnOver, fnOut ) {\n\t\treturn this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );\n\t}\n} );\n\n\n\n\nsupport.focusin = \"onfocusin\" in window;\n\n\n// Support: Firefox <=44\n// Firefox doesn't have focus(in | out) events\n// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787\n//\n// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1\n// focus(in | out) events fire after focus & blur events,\n// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order\n// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857\nif ( !support.focusin ) {\n\tjQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( orig, fix ) {\n\n\t\t// Attach a single capturing handler on the document while someone wants focusin/focusout\n\t\tvar handler = function( event ) {\n\t\t\tjQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );\n\t\t};\n\n\t\tjQuery.event.special[ fix ] = {\n\t\t\tsetup: function() {\n\t\t\t\tvar doc = this.ownerDocument || this,\n\t\t\t\t\tattaches = dataPriv.access( doc, fix );\n\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tdoc.addEventListener( orig, handler, true );\n\t\t\t\t}\n\t\t\t\tdataPriv.access( doc, fix, ( attaches || 0 ) + 1 );\n\t\t\t},\n\t\t\tteardown: function() {\n\t\t\t\tvar doc = this.ownerDocument || this,\n\t\t\t\t\tattaches = dataPriv.access( doc, fix ) - 1;\n\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tdoc.removeEventListener( orig, handler, true );\n\t\t\t\t\tdataPriv.remove( doc, fix );\n\n\t\t\t\t} else {\n\t\t\t\t\tdataPriv.access( doc, fix, attaches );\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t} );\n}\nvar location = window.location;\n\nvar nonce = jQuery.now();\n\nvar rquery = ( /\\?/ );\n\n\n\n// Cross-browser xml parsing\njQuery.parseXML = function( data ) {\n\tvar xml;\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\n\t// Support: IE 9 - 11 only\n\t// IE throws on parseFromString with invalid input.\n\ttry {\n\t\txml = ( new window.DOMParser() ).parseFromString( data, \"text/xml\" );\n\t} catch ( e ) {\n\t\txml = undefined;\n\t}\n\n\tif ( !xml || xml.getElementsByTagName( \"parsererror\" ).length ) {\n\t\tjQuery.error( \"Invalid XML: \" + data );\n\t}\n\treturn xml;\n};\n\n\nvar\n\trbracket = /\\[\\]$/,\n\trCRLF = /\\r?\\n/g,\n\trsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\n\trsubmittable = /^(?:input|select|textarea|keygen)/i;\n\nfunction buildParams( prefix, obj, traditional, add ) {\n\tvar name;\n\n\tif ( Array.isArray( obj ) ) {\n\n\t\t// Serialize array item.\n\t\tjQuery.each( obj, function( i, v ) {\n\t\t\tif ( traditional || rbracket.test( prefix ) ) {\n\n\t\t\t\t// Treat each array item as a scalar.\n\t\t\t\tadd( prefix, v );\n\n\t\t\t} else {\n\n\t\t\t\t// Item is non-scalar (array or object), encode its numeric index.\n\t\t\t\tbuildParams(\n\t\t\t\t\tprefix + \"[\" + ( typeof v === \"object\" && v != null ? i : \"\" ) + \"]\",\n\t\t\t\t\tv,\n\t\t\t\t\ttraditional,\n\t\t\t\t\tadd\n\t\t\t\t);\n\t\t\t}\n\t\t} );\n\n\t} else if ( !traditional && jQuery.type( obj ) === \"object\" ) {\n\n\t\t// Serialize object item.\n\t\tfor ( name in obj ) {\n\t\t\tbuildParams( prefix + \"[\" + name + \"]\", obj[ name ], traditional, add );\n\t\t}\n\n\t} else {\n\n\t\t// Serialize scalar item.\n\t\tadd( prefix, obj );\n\t}\n}\n\n// Serialize an array of form elements or a set of\n// key/values into a query string\njQuery.param = function( a, traditional ) {\n\tvar prefix,\n\t\ts = [],\n\t\tadd = function( key, valueOrFunction ) {\n\n\t\t\t// If value is a function, invoke it and use its return value\n\t\t\tvar value = jQuery.isFunction( valueOrFunction ) ?\n\t\t\t\tvalueOrFunction() :\n\t\t\t\tvalueOrFunction;\n\n\t\t\ts[ s.length ] = encodeURIComponent( key ) + \"=\" +\n\t\t\t\tencodeURIComponent( value == null ? \"\" : value );\n\t\t};\n\n\t// If an array was passed in, assume that it is an array of form elements.\n\tif ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {\n\n\t\t// Serialize the form elements\n\t\tjQuery.each( a, function() {\n\t\t\tadd( this.name, this.value );\n\t\t} );\n\n\t} else {\n\n\t\t// If traditional, encode the \"old\" way (the way 1.3.2 or older\n\t\t// did it), otherwise encode params recursively.\n\t\tfor ( prefix in a ) {\n\t\t\tbuildParams( prefix, a[ prefix ], traditional, add );\n\t\t}\n\t}\n\n\t// Return the resulting serialization\n\treturn s.join( \"&\" );\n};\n\njQuery.fn.extend( {\n\tserialize: function() {\n\t\treturn jQuery.param( this.serializeArray() );\n\t},\n\tserializeArray: function() {\n\t\treturn this.map( function() {\n\n\t\t\t// Can add propHook for \"elements\" to filter or add form elements\n\t\t\tvar elements = jQuery.prop( this, \"elements\" );\n\t\t\treturn elements ? jQuery.makeArray( elements ) : this;\n\t\t} )\n\t\t.filter( function() {\n\t\t\tvar type = this.type;\n\n\t\t\t// Use .is( \":disabled\" ) so that fieldset[disabled] works\n\t\t\treturn this.name && !jQuery( this ).is( \":disabled\" ) &&\n\t\t\t\trsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&\n\t\t\t\t( this.checked || !rcheckableType.test( type ) );\n\t\t} )\n\t\t.map( function( i, elem ) {\n\t\t\tvar val = jQuery( this ).val();\n\n\t\t\tif ( val == null ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tif ( Array.isArray( val ) ) {\n\t\t\t\treturn jQuery.map( val, function( val ) {\n\t\t\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t} ).get();\n\t}\n} );\n\n\nvar\n\tr20 = /%20/g,\n\trhash = /#.*$/,\n\trantiCache = /([?&])_=[^&]*/,\n\trheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\n\n\t// #7653, #8125, #8152: local protocol detection\n\trlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\n\trnoContent = /^(?:GET|HEAD)$/,\n\trprotocol = /^\\/\\//,\n\n\t/* Prefilters\n\t * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\n\t * 2) These are called:\n\t *    - BEFORE asking for a transport\n\t *    - AFTER param serialization (s.data is a string if s.processData is true)\n\t * 3) key is the dataType\n\t * 4) the catchall symbol \"*\" can be used\n\t * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\n\t */\n\tprefilters = {},\n\n\t/* Transports bindings\n\t * 1) key is the dataType\n\t * 2) the catchall symbol \"*\" can be used\n\t * 3) selection will start with transport dataType and THEN go to \"*\" if needed\n\t */\n\ttransports = {},\n\n\t// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression\n\tallTypes = \"*/\".concat( \"*\" ),\n\n\t// Anchor tag for parsing the document origin\n\toriginAnchor = document.createElement( \"a\" );\n\toriginAnchor.href = location.href;\n\n// Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\nfunction addToPrefiltersOrTransports( structure ) {\n\n\t// dataTypeExpression is optional and defaults to \"*\"\n\treturn function( dataTypeExpression, func ) {\n\n\t\tif ( typeof dataTypeExpression !== \"string\" ) {\n\t\t\tfunc = dataTypeExpression;\n\t\t\tdataTypeExpression = \"*\";\n\t\t}\n\n\t\tvar dataType,\n\t\t\ti = 0,\n\t\t\tdataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];\n\n\t\tif ( jQuery.isFunction( func ) ) {\n\n\t\t\t// For each dataType in the dataTypeExpression\n\t\t\twhile ( ( dataType = dataTypes[ i++ ] ) ) {\n\n\t\t\t\t// Prepend if requested\n\t\t\t\tif ( dataType[ 0 ] === \"+\" ) {\n\t\t\t\t\tdataType = dataType.slice( 1 ) || \"*\";\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );\n\n\t\t\t\t// Otherwise append\n\t\t\t\t} else {\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).push( func );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\n// Base inspection function for prefilters and transports\nfunction inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {\n\n\tvar inspected = {},\n\t\tseekingTransport = ( structure === transports );\n\n\tfunction inspect( dataType ) {\n\t\tvar selected;\n\t\tinspected[ dataType ] = true;\n\t\tjQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {\n\t\t\tvar dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );\n\t\t\tif ( typeof dataTypeOrTransport === \"string\" &&\n\t\t\t\t!seekingTransport && !inspected[ dataTypeOrTransport ] ) {\n\n\t\t\t\toptions.dataTypes.unshift( dataTypeOrTransport );\n\t\t\t\tinspect( dataTypeOrTransport );\n\t\t\t\treturn false;\n\t\t\t} else if ( seekingTransport ) {\n\t\t\t\treturn !( selected = dataTypeOrTransport );\n\t\t\t}\n\t\t} );\n\t\treturn selected;\n\t}\n\n\treturn inspect( options.dataTypes[ 0 ] ) || !inspected[ \"*\" ] && inspect( \"*\" );\n}\n\n// A special extend for ajax options\n// that takes \"flat\" options (not to be deep extended)\n// Fixes #9887\nfunction ajaxExtend( target, src ) {\n\tvar key, deep,\n\t\tflatOptions = jQuery.ajaxSettings.flatOptions || {};\n\n\tfor ( key in src ) {\n\t\tif ( src[ key ] !== undefined ) {\n\t\t\t( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];\n\t\t}\n\t}\n\tif ( deep ) {\n\t\tjQuery.extend( true, target, deep );\n\t}\n\n\treturn target;\n}\n\n/* Handles responses to an ajax request:\n * - finds the right dataType (mediates between content-type and expected dataType)\n * - returns the corresponding response\n */\nfunction ajaxHandleResponses( s, jqXHR, responses ) {\n\n\tvar ct, type, finalDataType, firstDataType,\n\t\tcontents = s.contents,\n\t\tdataTypes = s.dataTypes;\n\n\t// Remove auto dataType and get content-type in the process\n\twhile ( dataTypes[ 0 ] === \"*\" ) {\n\t\tdataTypes.shift();\n\t\tif ( ct === undefined ) {\n\t\t\tct = s.mimeType || jqXHR.getResponseHeader( \"Content-Type\" );\n\t\t}\n\t}\n\n\t// Check if we're dealing with a known content-type\n\tif ( ct ) {\n\t\tfor ( type in contents ) {\n\t\t\tif ( contents[ type ] && contents[ type ].test( ct ) ) {\n\t\t\t\tdataTypes.unshift( type );\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Check to see if we have a response for the expected dataType\n\tif ( dataTypes[ 0 ] in responses ) {\n\t\tfinalDataType = dataTypes[ 0 ];\n\t} else {\n\n\t\t// Try convertible dataTypes\n\t\tfor ( type in responses ) {\n\t\t\tif ( !dataTypes[ 0 ] || s.converters[ type + \" \" + dataTypes[ 0 ] ] ) {\n\t\t\t\tfinalDataType = type;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( !firstDataType ) {\n\t\t\t\tfirstDataType = type;\n\t\t\t}\n\t\t}\n\n\t\t// Or just use first one\n\t\tfinalDataType = finalDataType || firstDataType;\n\t}\n\n\t// If we found a dataType\n\t// We add the dataType to the list if needed\n\t// and return the corresponding response\n\tif ( finalDataType ) {\n\t\tif ( finalDataType !== dataTypes[ 0 ] ) {\n\t\t\tdataTypes.unshift( finalDataType );\n\t\t}\n\t\treturn responses[ finalDataType ];\n\t}\n}\n\n/* Chain conversions given the request and the original response\n * Also sets the responseXXX fields on the jqXHR instance\n */\nfunction ajaxConvert( s, response, jqXHR, isSuccess ) {\n\tvar conv2, current, conv, tmp, prev,\n\t\tconverters = {},\n\n\t\t// Work with a copy of dataTypes in case we need to modify it for conversion\n\t\tdataTypes = s.dataTypes.slice();\n\n\t// Create converters map with lowercased keys\n\tif ( dataTypes[ 1 ] ) {\n\t\tfor ( conv in s.converters ) {\n\t\t\tconverters[ conv.toLowerCase() ] = s.converters[ conv ];\n\t\t}\n\t}\n\n\tcurrent = dataTypes.shift();\n\n\t// Convert to each sequential dataType\n\twhile ( current ) {\n\n\t\tif ( s.responseFields[ current ] ) {\n\t\t\tjqXHR[ s.responseFields[ current ] ] = response;\n\t\t}\n\n\t\t// Apply the dataFilter if provided\n\t\tif ( !prev && isSuccess && s.dataFilter ) {\n\t\t\tresponse = s.dataFilter( response, s.dataType );\n\t\t}\n\n\t\tprev = current;\n\t\tcurrent = dataTypes.shift();\n\n\t\tif ( current ) {\n\n\t\t\t// There's only work to do if current dataType is non-auto\n\t\t\tif ( current === \"*\" ) {\n\n\t\t\t\tcurrent = prev;\n\n\t\t\t// Convert response if prev dataType is non-auto and differs from current\n\t\t\t} else if ( prev !== \"*\" && prev !== current ) {\n\n\t\t\t\t// Seek a direct converter\n\t\t\t\tconv = converters[ prev + \" \" + current ] || converters[ \"* \" + current ];\n\n\t\t\t\t// If none found, seek a pair\n\t\t\t\tif ( !conv ) {\n\t\t\t\t\tfor ( conv2 in converters ) {\n\n\t\t\t\t\t\t// If conv2 outputs current\n\t\t\t\t\t\ttmp = conv2.split( \" \" );\n\t\t\t\t\t\tif ( tmp[ 1 ] === current ) {\n\n\t\t\t\t\t\t\t// If prev can be converted to accepted input\n\t\t\t\t\t\t\tconv = converters[ prev + \" \" + tmp[ 0 ] ] ||\n\t\t\t\t\t\t\t\tconverters[ \"* \" + tmp[ 0 ] ];\n\t\t\t\t\t\t\tif ( conv ) {\n\n\t\t\t\t\t\t\t\t// Condense equivalence converters\n\t\t\t\t\t\t\t\tif ( conv === true ) {\n\t\t\t\t\t\t\t\t\tconv = converters[ conv2 ];\n\n\t\t\t\t\t\t\t\t// Otherwise, insert the intermediate dataType\n\t\t\t\t\t\t\t\t} else if ( converters[ conv2 ] !== true ) {\n\t\t\t\t\t\t\t\t\tcurrent = tmp[ 0 ];\n\t\t\t\t\t\t\t\t\tdataTypes.unshift( tmp[ 1 ] );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Apply converter (if not an equivalence)\n\t\t\t\tif ( conv !== true ) {\n\n\t\t\t\t\t// Unless errors are allowed to bubble, catch and return them\n\t\t\t\t\tif ( conv && s.throws ) {\n\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t\t} catch ( e ) {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tstate: \"parsererror\",\n\t\t\t\t\t\t\t\terror: conv ? e : \"No conversion from \" + prev + \" to \" + current\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { state: \"success\", data: response };\n}\n\njQuery.extend( {\n\n\t// Counter for holding the number of active queries\n\tactive: 0,\n\n\t// Last-Modified header cache for next request\n\tlastModified: {},\n\tetag: {},\n\n\tajaxSettings: {\n\t\turl: location.href,\n\t\ttype: \"GET\",\n\t\tisLocal: rlocalProtocol.test( location.protocol ),\n\t\tglobal: true,\n\t\tprocessData: true,\n\t\tasync: true,\n\t\tcontentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\n\n\t\t/*\n\t\ttimeout: 0,\n\t\tdata: null,\n\t\tdataType: null,\n\t\tusername: null,\n\t\tpassword: null,\n\t\tcache: null,\n\t\tthrows: false,\n\t\ttraditional: false,\n\t\theaders: {},\n\t\t*/\n\n\t\taccepts: {\n\t\t\t\"*\": allTypes,\n\t\t\ttext: \"text/plain\",\n\t\t\thtml: \"text/html\",\n\t\t\txml: \"application/xml, text/xml\",\n\t\t\tjson: \"application/json, text/javascript\"\n\t\t},\n\n\t\tcontents: {\n\t\t\txml: /\\bxml\\b/,\n\t\t\thtml: /\\bhtml/,\n\t\t\tjson: /\\bjson\\b/\n\t\t},\n\n\t\tresponseFields: {\n\t\t\txml: \"responseXML\",\n\t\t\ttext: \"responseText\",\n\t\t\tjson: \"responseJSON\"\n\t\t},\n\n\t\t// Data converters\n\t\t// Keys separate source (or catchall \"*\") and destination types with a single space\n\t\tconverters: {\n\n\t\t\t// Convert anything to text\n\t\t\t\"* text\": String,\n\n\t\t\t// Text to html (true = no transformation)\n\t\t\t\"text html\": true,\n\n\t\t\t// Evaluate text as a json expression\n\t\t\t\"text json\": JSON.parse,\n\n\t\t\t// Parse text as xml\n\t\t\t\"text xml\": jQuery.parseXML\n\t\t},\n\n\t\t// For options that shouldn't be deep extended:\n\t\t// you can add your own custom options here if\n\t\t// and when you create one that shouldn't be\n\t\t// deep extended (see ajaxExtend)\n\t\tflatOptions: {\n\t\t\turl: true,\n\t\t\tcontext: true\n\t\t}\n\t},\n\n\t// Creates a full fledged settings object into target\n\t// with both ajaxSettings and settings fields.\n\t// If target is omitted, writes into ajaxSettings.\n\tajaxSetup: function( target, settings ) {\n\t\treturn settings ?\n\n\t\t\t// Building a settings object\n\t\t\tajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :\n\n\t\t\t// Extending ajaxSettings\n\t\t\tajaxExtend( jQuery.ajaxSettings, target );\n\t},\n\n\tajaxPrefilter: addToPrefiltersOrTransports( prefilters ),\n\tajaxTransport: addToPrefiltersOrTransports( transports ),\n\n\t// Main method\n\tajax: function( url, options ) {\n\n\t\t// If url is an object, simulate pre-1.5 signature\n\t\tif ( typeof url === \"object\" ) {\n\t\t\toptions = url;\n\t\t\turl = undefined;\n\t\t}\n\n\t\t// Force options to be an object\n\t\toptions = options || {};\n\n\t\tvar transport,\n\n\t\t\t// URL without anti-cache param\n\t\t\tcacheURL,\n\n\t\t\t// Response headers\n\t\t\tresponseHeadersString,\n\t\t\tresponseHeaders,\n\n\t\t\t// timeout handle\n\t\t\ttimeoutTimer,\n\n\t\t\t// Url cleanup var\n\t\t\turlAnchor,\n\n\t\t\t// Request state (becomes false upon send and true upon completion)\n\t\t\tcompleted,\n\n\t\t\t// To know if global events are to be dispatched\n\t\t\tfireGlobals,\n\n\t\t\t// Loop variable\n\t\t\ti,\n\n\t\t\t// uncached part of the url\n\t\t\tuncached,\n\n\t\t\t// Create the final options object\n\t\t\ts = jQuery.ajaxSetup( {}, options ),\n\n\t\t\t// Callbacks context\n\t\t\tcallbackContext = s.context || s,\n\n\t\t\t// Context for global events is callbackContext if it is a DOM node or jQuery collection\n\t\t\tglobalEventContext = s.context &&\n\t\t\t\t( callbackContext.nodeType || callbackContext.jquery ) ?\n\t\t\t\t\tjQuery( callbackContext ) :\n\t\t\t\t\tjQuery.event,\n\n\t\t\t// Deferreds\n\t\t\tdeferred = jQuery.Deferred(),\n\t\t\tcompleteDeferred = jQuery.Callbacks( \"once memory\" ),\n\n\t\t\t// Status-dependent callbacks\n\t\t\tstatusCode = s.statusCode || {},\n\n\t\t\t// Headers (they are sent all at once)\n\t\t\trequestHeaders = {},\n\t\t\trequestHeadersNames = {},\n\n\t\t\t// Default abort message\n\t\t\tstrAbort = \"canceled\",\n\n\t\t\t// Fake xhr\n\t\t\tjqXHR = {\n\t\t\t\treadyState: 0,\n\n\t\t\t\t// Builds headers hashtable if needed\n\t\t\t\tgetResponseHeader: function( key ) {\n\t\t\t\t\tvar match;\n\t\t\t\t\tif ( completed ) {\n\t\t\t\t\t\tif ( !responseHeaders ) {\n\t\t\t\t\t\t\tresponseHeaders = {};\n\t\t\t\t\t\t\twhile ( ( match = rheaders.exec( responseHeadersString ) ) ) {\n\t\t\t\t\t\t\t\tresponseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmatch = responseHeaders[ key.toLowerCase() ];\n\t\t\t\t\t}\n\t\t\t\t\treturn match == null ? null : match;\n\t\t\t\t},\n\n\t\t\t\t// Raw string\n\t\t\t\tgetAllResponseHeaders: function() {\n\t\t\t\t\treturn completed ? responseHeadersString : null;\n\t\t\t\t},\n\n\t\t\t\t// Caches the header\n\t\t\t\tsetRequestHeader: function( name, value ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\tname = requestHeadersNames[ name.toLowerCase() ] =\n\t\t\t\t\t\t\trequestHeadersNames[ name.toLowerCase() ] || name;\n\t\t\t\t\t\trequestHeaders[ name ] = value;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Overrides response content-type header\n\t\t\t\toverrideMimeType: function( type ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\ts.mimeType = type;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Status-dependent callbacks\n\t\t\t\tstatusCode: function( map ) {\n\t\t\t\t\tvar code;\n\t\t\t\t\tif ( map ) {\n\t\t\t\t\t\tif ( completed ) {\n\n\t\t\t\t\t\t\t// Execute the appropriate callbacks\n\t\t\t\t\t\t\tjqXHR.always( map[ jqXHR.status ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Lazy-add the new callbacks in a way that preserves old ones\n\t\t\t\t\t\t\tfor ( code in map ) {\n\t\t\t\t\t\t\t\tstatusCode[ code ] = [ statusCode[ code ], map[ code ] ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Cancel the request\n\t\t\t\tabort: function( statusText ) {\n\t\t\t\t\tvar finalText = statusText || strAbort;\n\t\t\t\t\tif ( transport ) {\n\t\t\t\t\t\ttransport.abort( finalText );\n\t\t\t\t\t}\n\t\t\t\t\tdone( 0, finalText );\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t};\n\n\t\t// Attach deferreds\n\t\tdeferred.promise( jqXHR );\n\n\t\t// Add protocol if not provided (prefilters might expect it)\n\t\t// Handle falsy url in the settings object (#10093: consistency with old signature)\n\t\t// We also use the url parameter if available\n\t\ts.url = ( ( url || s.url || location.href ) + \"\" )\n\t\t\t.replace( rprotocol, location.protocol + \"//\" );\n\n\t\t// Alias method option to type as per ticket #12004\n\t\ts.type = options.method || options.type || s.method || s.type;\n\n\t\t// Extract dataTypes list\n\t\ts.dataTypes = ( s.dataType || \"*\" ).toLowerCase().match( rnothtmlwhite ) || [ \"\" ];\n\n\t\t// A cross-domain request is in order when the origin doesn't match the current origin.\n\t\tif ( s.crossDomain == null ) {\n\t\t\turlAnchor = document.createElement( \"a\" );\n\n\t\t\t// Support: IE <=8 - 11, Edge 12 - 13\n\t\t\t// IE throws exception on accessing the href property if url is malformed,\n\t\t\t// e.g. http://example.com:80x/\n\t\t\ttry {\n\t\t\t\turlAnchor.href = s.url;\n\n\t\t\t\t// Support: IE <=8 - 11 only\n\t\t\t\t// Anchor's host property isn't correctly set when s.url is relative\n\t\t\t\turlAnchor.href = urlAnchor.href;\n\t\t\t\ts.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !==\n\t\t\t\t\turlAnchor.protocol + \"//\" + urlAnchor.host;\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// If there is an error parsing the URL, assume it is crossDomain,\n\t\t\t\t// it can be rejected by the transport if it is invalid\n\t\t\t\ts.crossDomain = true;\n\t\t\t}\n\t\t}\n\n\t\t// Convert data if not already a string\n\t\tif ( s.data && s.processData && typeof s.data !== \"string\" ) {\n\t\t\ts.data = jQuery.param( s.data, s.traditional );\n\t\t}\n\n\t\t// Apply prefilters\n\t\tinspectPrefiltersOrTransports( prefilters, s, options, jqXHR );\n\n\t\t// If request was aborted inside a prefilter, stop there\n\t\tif ( completed ) {\n\t\t\treturn jqXHR;\n\t\t}\n\n\t\t// We can fire global events as of now if asked to\n\t\t// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)\n\t\tfireGlobals = jQuery.event && s.global;\n\n\t\t// Watch for a new set of requests\n\t\tif ( fireGlobals && jQuery.active++ === 0 ) {\n\t\t\tjQuery.event.trigger( \"ajaxStart\" );\n\t\t}\n\n\t\t// Uppercase the type\n\t\ts.type = s.type.toUpperCase();\n\n\t\t// Determine if request has content\n\t\ts.hasContent = !rnoContent.test( s.type );\n\n\t\t// Save the URL in case we're toying with the If-Modified-Since\n\t\t// and/or If-None-Match header later on\n\t\t// Remove hash to simplify url manipulation\n\t\tcacheURL = s.url.replace( rhash, \"\" );\n\n\t\t// More options handling for requests with no content\n\t\tif ( !s.hasContent ) {\n\n\t\t\t// Remember the hash so we can put it back\n\t\t\tuncached = s.url.slice( cacheURL.length );\n\n\t\t\t// If data is available, append data to url\n\t\t\tif ( s.data ) {\n\t\t\t\tcacheURL += ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + s.data;\n\n\t\t\t\t// #9682: remove data so that it's not used in an eventual retry\n\t\t\t\tdelete s.data;\n\t\t\t}\n\n\t\t\t// Add or update anti-cache param if needed\n\t\t\tif ( s.cache === false ) {\n\t\t\t\tcacheURL = cacheURL.replace( rantiCache, \"$1\" );\n\t\t\t\tuncached = ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + \"_=\" + ( nonce++ ) + uncached;\n\t\t\t}\n\n\t\t\t// Put hash and anti-cache on the URL that will be requested (gh-1732)\n\t\t\ts.url = cacheURL + uncached;\n\n\t\t// Change '%20' to '+' if this is encoded form body content (gh-2658)\n\t\t} else if ( s.data && s.processData &&\n\t\t\t( s.contentType || \"\" ).indexOf( \"application/x-www-form-urlencoded\" ) === 0 ) {\n\t\t\ts.data = s.data.replace( r20, \"+\" );\n\t\t}\n\n\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\tif ( s.ifModified ) {\n\t\t\tif ( jQuery.lastModified[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-Modified-Since\", jQuery.lastModified[ cacheURL ] );\n\t\t\t}\n\t\t\tif ( jQuery.etag[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-None-Match\", jQuery.etag[ cacheURL ] );\n\t\t\t}\n\t\t}\n\n\t\t// Set the correct header, if data is being sent\n\t\tif ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {\n\t\t\tjqXHR.setRequestHeader( \"Content-Type\", s.contentType );\n\t\t}\n\n\t\t// Set the Accepts header for the server, depending on the dataType\n\t\tjqXHR.setRequestHeader(\n\t\t\t\"Accept\",\n\t\t\ts.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?\n\t\t\t\ts.accepts[ s.dataTypes[ 0 ] ] +\n\t\t\t\t\t( s.dataTypes[ 0 ] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\" ) :\n\t\t\t\ts.accepts[ \"*\" ]\n\t\t);\n\n\t\t// Check for headers option\n\t\tfor ( i in s.headers ) {\n\t\t\tjqXHR.setRequestHeader( i, s.headers[ i ] );\n\t\t}\n\n\t\t// Allow custom headers/mimetypes and early abort\n\t\tif ( s.beforeSend &&\n\t\t\t( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {\n\n\t\t\t// Abort if not done already and return\n\t\t\treturn jqXHR.abort();\n\t\t}\n\n\t\t// Aborting is no longer a cancellation\n\t\tstrAbort = \"abort\";\n\n\t\t// Install callbacks on deferreds\n\t\tcompleteDeferred.add( s.complete );\n\t\tjqXHR.done( s.success );\n\t\tjqXHR.fail( s.error );\n\n\t\t// Get transport\n\t\ttransport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );\n\n\t\t// If no transport, we auto-abort\n\t\tif ( !transport ) {\n\t\t\tdone( -1, \"No Transport\" );\n\t\t} else {\n\t\t\tjqXHR.readyState = 1;\n\n\t\t\t// Send global event\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxSend\", [ jqXHR, s ] );\n\t\t\t}\n\n\t\t\t// If request was aborted inside ajaxSend, stop there\n\t\t\tif ( completed ) {\n\t\t\t\treturn jqXHR;\n\t\t\t}\n\n\t\t\t// Timeout\n\t\t\tif ( s.async && s.timeout > 0 ) {\n\t\t\t\ttimeoutTimer = window.setTimeout( function() {\n\t\t\t\t\tjqXHR.abort( \"timeout\" );\n\t\t\t\t}, s.timeout );\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tcompleted = false;\n\t\t\t\ttransport.send( requestHeaders, done );\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// Rethrow post-completion exceptions\n\t\t\t\tif ( completed ) {\n\t\t\t\t\tthrow e;\n\t\t\t\t}\n\n\t\t\t\t// Propagate others as results\n\t\t\t\tdone( -1, e );\n\t\t\t}\n\t\t}\n\n\t\t// Callback for when everything is done\n\t\tfunction done( status, nativeStatusText, responses, headers ) {\n\t\t\tvar isSuccess, success, error, response, modified,\n\t\t\t\tstatusText = nativeStatusText;\n\n\t\t\t// Ignore repeat invocations\n\t\t\tif ( completed ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tcompleted = true;\n\n\t\t\t// Clear timeout if it exists\n\t\t\tif ( timeoutTimer ) {\n\t\t\t\twindow.clearTimeout( timeoutTimer );\n\t\t\t}\n\n\t\t\t// Dereference transport for early garbage collection\n\t\t\t// (no matter how long the jqXHR object will be used)\n\t\t\ttransport = undefined;\n\n\t\t\t// Cache response headers\n\t\t\tresponseHeadersString = headers || \"\";\n\n\t\t\t// Set readyState\n\t\t\tjqXHR.readyState = status > 0 ? 4 : 0;\n\n\t\t\t// Determine if successful\n\t\t\tisSuccess = status >= 200 && status < 300 || status === 304;\n\n\t\t\t// Get response data\n\t\t\tif ( responses ) {\n\t\t\t\tresponse = ajaxHandleResponses( s, jqXHR, responses );\n\t\t\t}\n\n\t\t\t// Convert no matter what (that way responseXXX fields are always set)\n\t\t\tresponse = ajaxConvert( s, response, jqXHR, isSuccess );\n\n\t\t\t// If successful, handle type chaining\n\t\t\tif ( isSuccess ) {\n\n\t\t\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\t\t\tif ( s.ifModified ) {\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"Last-Modified\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.lastModified[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"etag\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.etag[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// if no content\n\t\t\t\tif ( status === 204 || s.type === \"HEAD\" ) {\n\t\t\t\t\tstatusText = \"nocontent\";\n\n\t\t\t\t// if not modified\n\t\t\t\t} else if ( status === 304 ) {\n\t\t\t\t\tstatusText = \"notmodified\";\n\n\t\t\t\t// If we have data, let's convert it\n\t\t\t\t} else {\n\t\t\t\t\tstatusText = response.state;\n\t\t\t\t\tsuccess = response.data;\n\t\t\t\t\terror = response.error;\n\t\t\t\t\tisSuccess = !error;\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Extract error from statusText and normalize for non-aborts\n\t\t\t\terror = statusText;\n\t\t\t\tif ( status || !statusText ) {\n\t\t\t\t\tstatusText = \"error\";\n\t\t\t\t\tif ( status < 0 ) {\n\t\t\t\t\t\tstatus = 0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Set data for the fake xhr object\n\t\t\tjqXHR.status = status;\n\t\t\tjqXHR.statusText = ( nativeStatusText || statusText ) + \"\";\n\n\t\t\t// Success/Error\n\t\t\tif ( isSuccess ) {\n\t\t\t\tdeferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );\n\t\t\t} else {\n\t\t\t\tdeferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );\n\t\t\t}\n\n\t\t\t// Status-dependent callbacks\n\t\t\tjqXHR.statusCode( statusCode );\n\t\t\tstatusCode = undefined;\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( isSuccess ? \"ajaxSuccess\" : \"ajaxError\",\n\t\t\t\t\t[ jqXHR, s, isSuccess ? success : error ] );\n\t\t\t}\n\n\t\t\t// Complete\n\t\t\tcompleteDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxComplete\", [ jqXHR, s ] );\n\n\t\t\t\t// Handle the global AJAX counter\n\t\t\t\tif ( !( --jQuery.active ) ) {\n\t\t\t\t\tjQuery.event.trigger( \"ajaxStop\" );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn jqXHR;\n\t},\n\n\tgetJSON: function( url, data, callback ) {\n\t\treturn jQuery.get( url, data, callback, \"json\" );\n\t},\n\n\tgetScript: function( url, callback ) {\n\t\treturn jQuery.get( url, undefined, callback, \"script\" );\n\t}\n} );\n\njQuery.each( [ \"get\", \"post\" ], function( i, method ) {\n\tjQuery[ method ] = function( url, data, callback, type ) {\n\n\t\t// Shift arguments if data argument was omitted\n\t\tif ( jQuery.isFunction( data ) ) {\n\t\t\ttype = type || callback;\n\t\t\tcallback = data;\n\t\t\tdata = undefined;\n\t\t}\n\n\t\t// The url can be an options object (which then must have .url)\n\t\treturn jQuery.ajax( jQuery.extend( {\n\t\t\turl: url,\n\t\t\ttype: method,\n\t\t\tdataType: type,\n\t\t\tdata: data,\n\t\t\tsuccess: callback\n\t\t}, jQuery.isPlainObject( url ) && url ) );\n\t};\n} );\n\n\njQuery._evalUrl = function( url ) {\n\treturn jQuery.ajax( {\n\t\turl: url,\n\n\t\t// Make this explicit, since user can override this through ajaxSetup (#11264)\n\t\ttype: \"GET\",\n\t\tdataType: \"script\",\n\t\tcache: true,\n\t\tasync: false,\n\t\tglobal: false,\n\t\t\"throws\": true\n\t} );\n};\n\n\njQuery.fn.extend( {\n\twrapAll: function( html ) {\n\t\tvar wrap;\n\n\t\tif ( this[ 0 ] ) {\n\t\t\tif ( jQuery.isFunction( html ) ) {\n\t\t\t\thtml = html.call( this[ 0 ] );\n\t\t\t}\n\n\t\t\t// The elements to wrap the target around\n\t\t\twrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );\n\n\t\t\tif ( this[ 0 ].parentNode ) {\n\t\t\t\twrap.insertBefore( this[ 0 ] );\n\t\t\t}\n\n\t\t\twrap.map( function() {\n\t\t\t\tvar elem = this;\n\n\t\t\t\twhile ( elem.firstElementChild ) {\n\t\t\t\t\telem = elem.firstElementChild;\n\t\t\t\t}\n\n\t\t\t\treturn elem;\n\t\t\t} ).append( this );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\twrapInner: function( html ) {\n\t\tif ( jQuery.isFunction( html ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).wrapInner( html.call( this, i ) );\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar self = jQuery( this ),\n\t\t\t\tcontents = self.contents();\n\n\t\t\tif ( contents.length ) {\n\t\t\t\tcontents.wrapAll( html );\n\n\t\t\t} else {\n\t\t\t\tself.append( html );\n\t\t\t}\n\t\t} );\n\t},\n\n\twrap: function( html ) {\n\t\tvar isFunction = jQuery.isFunction( html );\n\n\t\treturn this.each( function( i ) {\n\t\t\tjQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html );\n\t\t} );\n\t},\n\n\tunwrap: function( selector ) {\n\t\tthis.parent( selector ).not( \"body\" ).each( function() {\n\t\t\tjQuery( this ).replaceWith( this.childNodes );\n\t\t} );\n\t\treturn this;\n\t}\n} );\n\n\njQuery.expr.pseudos.hidden = function( elem ) {\n\treturn !jQuery.expr.pseudos.visible( elem );\n};\njQuery.expr.pseudos.visible = function( elem ) {\n\treturn !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );\n};\n\n\n\n\njQuery.ajaxSettings.xhr = function() {\n\ttry {\n\t\treturn new window.XMLHttpRequest();\n\t} catch ( e ) {}\n};\n\nvar xhrSuccessStatus = {\n\n\t\t// File protocol always yields status code 0, assume 200\n\t\t0: 200,\n\n\t\t// Support: IE <=9 only\n\t\t// #1450: sometimes IE returns 1223 when it should be 204\n\t\t1223: 204\n\t},\n\txhrSupported = jQuery.ajaxSettings.xhr();\n\nsupport.cors = !!xhrSupported && ( \"withCredentials\" in xhrSupported );\nsupport.ajax = xhrSupported = !!xhrSupported;\n\njQuery.ajaxTransport( function( options ) {\n\tvar callback, errorCallback;\n\n\t// Cross domain only allowed if supported through XMLHttpRequest\n\tif ( support.cors || xhrSupported && !options.crossDomain ) {\n\t\treturn {\n\t\t\tsend: function( headers, complete ) {\n\t\t\t\tvar i,\n\t\t\t\t\txhr = options.xhr();\n\n\t\t\t\txhr.open(\n\t\t\t\t\toptions.type,\n\t\t\t\t\toptions.url,\n\t\t\t\t\toptions.async,\n\t\t\t\t\toptions.username,\n\t\t\t\t\toptions.password\n\t\t\t\t);\n\n\t\t\t\t// Apply custom fields if provided\n\t\t\t\tif ( options.xhrFields ) {\n\t\t\t\t\tfor ( i in options.xhrFields ) {\n\t\t\t\t\t\txhr[ i ] = options.xhrFields[ i ];\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Override mime type if needed\n\t\t\t\tif ( options.mimeType && xhr.overrideMimeType ) {\n\t\t\t\t\txhr.overrideMimeType( options.mimeType );\n\t\t\t\t}\n\n\t\t\t\t// X-Requested-With header\n\t\t\t\t// For cross-domain requests, seeing as conditions for a preflight are\n\t\t\t\t// akin to a jigsaw puzzle, we simply never set it to be sure.\n\t\t\t\t// (it can always be set on a per-request basis or even using ajaxSetup)\n\t\t\t\t// For same-domain requests, won't change header if already provided.\n\t\t\t\tif ( !options.crossDomain && !headers[ \"X-Requested-With\" ] ) {\n\t\t\t\t\theaders[ \"X-Requested-With\" ] = \"XMLHttpRequest\";\n\t\t\t\t}\n\n\t\t\t\t// Set headers\n\t\t\t\tfor ( i in headers ) {\n\t\t\t\t\txhr.setRequestHeader( i, headers[ i ] );\n\t\t\t\t}\n\n\t\t\t\t// Callback\n\t\t\t\tcallback = function( type ) {\n\t\t\t\t\treturn function() {\n\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\tcallback = errorCallback = xhr.onload =\n\t\t\t\t\t\t\t\txhr.onerror = xhr.onabort = xhr.onreadystatechange = null;\n\n\t\t\t\t\t\t\tif ( type === \"abort\" ) {\n\t\t\t\t\t\t\t\txhr.abort();\n\t\t\t\t\t\t\t} else if ( type === \"error\" ) {\n\n\t\t\t\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t\t\t\t// On a manual native abort, IE9 throws\n\t\t\t\t\t\t\t\t// errors on any property access that is not readyState\n\t\t\t\t\t\t\t\tif ( typeof xhr.status !== \"number\" ) {\n\t\t\t\t\t\t\t\t\tcomplete( 0, \"error\" );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tcomplete(\n\n\t\t\t\t\t\t\t\t\t\t// File: protocol always yields status 0; see #8605, #14207\n\t\t\t\t\t\t\t\t\t\txhr.status,\n\t\t\t\t\t\t\t\t\t\txhr.statusText\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tcomplete(\n\t\t\t\t\t\t\t\t\txhrSuccessStatus[ xhr.status ] || xhr.status,\n\t\t\t\t\t\t\t\t\txhr.statusText,\n\n\t\t\t\t\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t\t\t\t\t// IE9 has no XHR2 but throws on binary (trac-11426)\n\t\t\t\t\t\t\t\t\t// For XHR2 non-text, let the caller handle it (gh-2498)\n\t\t\t\t\t\t\t\t\t( xhr.responseType || \"text\" ) !== \"text\"  ||\n\t\t\t\t\t\t\t\t\ttypeof xhr.responseText !== \"string\" ?\n\t\t\t\t\t\t\t\t\t\t{ binary: xhr.response } :\n\t\t\t\t\t\t\t\t\t\t{ text: xhr.responseText },\n\t\t\t\t\t\t\t\t\txhr.getAllResponseHeaders()\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t};\n\n\t\t\t\t// Listen to events\n\t\t\t\txhr.onload = callback();\n\t\t\t\terrorCallback = xhr.onerror = callback( \"error\" );\n\n\t\t\t\t// Support: IE 9 only\n\t\t\t\t// Use onreadystatechange to replace onabort\n\t\t\t\t// to handle uncaught aborts\n\t\t\t\tif ( xhr.onabort !== undefined ) {\n\t\t\t\t\txhr.onabort = errorCallback;\n\t\t\t\t} else {\n\t\t\t\t\txhr.onreadystatechange = function() {\n\n\t\t\t\t\t\t// Check readyState before timeout as it changes\n\t\t\t\t\t\tif ( xhr.readyState === 4 ) {\n\n\t\t\t\t\t\t\t// Allow onerror to be called first,\n\t\t\t\t\t\t\t// but that will not handle a native abort\n\t\t\t\t\t\t\t// Also, save errorCallback to a variable\n\t\t\t\t\t\t\t// as xhr.onerror cannot be accessed\n\t\t\t\t\t\t\twindow.setTimeout( function() {\n\t\t\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\t\t\terrorCallback();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\t// Create the abort callback\n\t\t\t\tcallback = callback( \"abort\" );\n\n\t\t\t\ttry {\n\n\t\t\t\t\t// Do send the request (this may raise an exception)\n\t\t\t\t\txhr.send( options.hasContent && options.data || null );\n\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t// #14683: Only rethrow if this hasn't been notified as an error yet\n\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\tthrow e;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\n// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)\njQuery.ajaxPrefilter( function( s ) {\n\tif ( s.crossDomain ) {\n\t\ts.contents.script = false;\n\t}\n} );\n\n// Install script dataType\njQuery.ajaxSetup( {\n\taccepts: {\n\t\tscript: \"text/javascript, application/javascript, \" +\n\t\t\t\"application/ecmascript, application/x-ecmascript\"\n\t},\n\tcontents: {\n\t\tscript: /\\b(?:java|ecma)script\\b/\n\t},\n\tconverters: {\n\t\t\"text script\": function( text ) {\n\t\t\tjQuery.globalEval( text );\n\t\t\treturn text;\n\t\t}\n\t}\n} );\n\n// Handle cache's special case and crossDomain\njQuery.ajaxPrefilter( \"script\", function( s ) {\n\tif ( s.cache === undefined ) {\n\t\ts.cache = false;\n\t}\n\tif ( s.crossDomain ) {\n\t\ts.type = \"GET\";\n\t}\n} );\n\n// Bind script tag hack transport\njQuery.ajaxTransport( \"script\", function( s ) {\n\n\t// This transport only deals with cross domain requests\n\tif ( s.crossDomain ) {\n\t\tvar script, callback;\n\t\treturn {\n\t\t\tsend: function( _, complete ) {\n\t\t\t\tscript = jQuery( \"<script>\" ).prop( {\n\t\t\t\t\tcharset: s.scriptCharset,\n\t\t\t\t\tsrc: s.url\n\t\t\t\t} ).on(\n\t\t\t\t\t\"load error\",\n\t\t\t\t\tcallback = function( evt ) {\n\t\t\t\t\t\tscript.remove();\n\t\t\t\t\t\tcallback = null;\n\t\t\t\t\t\tif ( evt ) {\n\t\t\t\t\t\t\tcomplete( evt.type === \"error\" ? 404 : 200, evt.type );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t);\n\n\t\t\t\t// Use native DOM manipulation to avoid our domManip AJAX trickery\n\t\t\t\tdocument.head.appendChild( script[ 0 ] );\n\t\t\t},\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\nvar oldCallbacks = [],\n\trjsonp = /(=)\\?(?=&|$)|\\?\\?/;\n\n// Default jsonp settings\njQuery.ajaxSetup( {\n\tjsonp: \"callback\",\n\tjsonpCallback: function() {\n\t\tvar callback = oldCallbacks.pop() || ( jQuery.expando + \"_\" + ( nonce++ ) );\n\t\tthis[ callback ] = true;\n\t\treturn callback;\n\t}\n} );\n\n// Detect, normalize options and install callbacks for jsonp requests\njQuery.ajaxPrefilter( \"json jsonp\", function( s, originalSettings, jqXHR ) {\n\n\tvar callbackName, overwritten, responseContainer,\n\t\tjsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?\n\t\t\t\"url\" :\n\t\t\ttypeof s.data === \"string\" &&\n\t\t\t\t( s.contentType || \"\" )\n\t\t\t\t\t.indexOf( \"application/x-www-form-urlencoded\" ) === 0 &&\n\t\t\t\trjsonp.test( s.data ) && \"data\"\n\t\t);\n\n\t// Handle iff the expected data type is \"jsonp\" or we have a parameter to set\n\tif ( jsonProp || s.dataTypes[ 0 ] === \"jsonp\" ) {\n\n\t\t// Get callback name, remembering preexisting value associated with it\n\t\tcallbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?\n\t\t\ts.jsonpCallback() :\n\t\t\ts.jsonpCallback;\n\n\t\t// Insert callback into url or form data\n\t\tif ( jsonProp ) {\n\t\t\ts[ jsonProp ] = s[ jsonProp ].replace( rjsonp, \"$1\" + callbackName );\n\t\t} else if ( s.jsonp !== false ) {\n\t\t\ts.url += ( rquery.test( s.url ) ? \"&\" : \"?\" ) + s.jsonp + \"=\" + callbackName;\n\t\t}\n\n\t\t// Use data converter to retrieve json after script execution\n\t\ts.converters[ \"script json\" ] = function() {\n\t\t\tif ( !responseContainer ) {\n\t\t\t\tjQuery.error( callbackName + \" was not called\" );\n\t\t\t}\n\t\t\treturn responseContainer[ 0 ];\n\t\t};\n\n\t\t// Force json dataType\n\t\ts.dataTypes[ 0 ] = \"json\";\n\n\t\t// Install callback\n\t\toverwritten = window[ callbackName ];\n\t\twindow[ callbackName ] = function() {\n\t\t\tresponseContainer = arguments;\n\t\t};\n\n\t\t// Clean-up function (fires after converters)\n\t\tjqXHR.always( function() {\n\n\t\t\t// If previous value didn't exist - remove it\n\t\t\tif ( overwritten === undefined ) {\n\t\t\t\tjQuery( window ).removeProp( callbackName );\n\n\t\t\t// Otherwise restore preexisting value\n\t\t\t} else {\n\t\t\t\twindow[ callbackName ] = overwritten;\n\t\t\t}\n\n\t\t\t// Save back as free\n\t\t\tif ( s[ callbackName ] ) {\n\n\t\t\t\t// Make sure that re-using the options doesn't screw things around\n\t\t\t\ts.jsonpCallback = originalSettings.jsonpCallback;\n\n\t\t\t\t// Save the callback name for future use\n\t\t\t\toldCallbacks.push( callbackName );\n\t\t\t}\n\n\t\t\t// Call if it was a function and we have a response\n\t\t\tif ( responseContainer && jQuery.isFunction( overwritten ) ) {\n\t\t\t\toverwritten( responseContainer[ 0 ] );\n\t\t\t}\n\n\t\t\tresponseContainer = overwritten = undefined;\n\t\t} );\n\n\t\t// Delegate to script\n\t\treturn \"script\";\n\t}\n} );\n\n\n\n\n// Support: Safari 8 only\n// In Safari 8 documents created via document.implementation.createHTMLDocument\n// collapse sibling forms: the second one becomes a child of the first one.\n// Because of that, this security measure has to be disabled in Safari 8.\n// https://bugs.webkit.org/show_bug.cgi?id=137337\nsupport.createHTMLDocument = ( function() {\n\tvar body = document.implementation.createHTMLDocument( \"\" ).body;\n\tbody.innerHTML = \"<form></form><form></form>\";\n\treturn body.childNodes.length === 2;\n} )();\n\n\n// Argument \"data\" should be string of html\n// context (optional): If specified, the fragment will be created in this context,\n// defaults to document\n// keepScripts (optional): If true, will include scripts passed in the html string\njQuery.parseHTML = function( data, context, keepScripts ) {\n\tif ( typeof data !== \"string\" ) {\n\t\treturn [];\n\t}\n\tif ( typeof context === \"boolean\" ) {\n\t\tkeepScripts = context;\n\t\tcontext = false;\n\t}\n\n\tvar base, parsed, scripts;\n\n\tif ( !context ) {\n\n\t\t// Stop scripts or inline event handlers from being executed immediately\n\t\t// by using document.implementation\n\t\tif ( support.createHTMLDocument ) {\n\t\t\tcontext = document.implementation.createHTMLDocument( \"\" );\n\n\t\t\t// Set the base href for the created document\n\t\t\t// so any parsed elements with URLs\n\t\t\t// are based on the document's URL (gh-2965)\n\t\t\tbase = context.createElement( \"base\" );\n\t\t\tbase.href = document.location.href;\n\t\t\tcontext.head.appendChild( base );\n\t\t} else {\n\t\t\tcontext = document;\n\t\t}\n\t}\n\n\tparsed = rsingleTag.exec( data );\n\tscripts = !keepScripts && [];\n\n\t// Single tag\n\tif ( parsed ) {\n\t\treturn [ context.createElement( parsed[ 1 ] ) ];\n\t}\n\n\tparsed = buildFragment( [ data ], context, scripts );\n\n\tif ( scripts && scripts.length ) {\n\t\tjQuery( scripts ).remove();\n\t}\n\n\treturn jQuery.merge( [], parsed.childNodes );\n};\n\n\n/**\n * Load a url into a page\n */\njQuery.fn.load = function( url, params, callback ) {\n\tvar selector, type, response,\n\t\tself = this,\n\t\toff = url.indexOf( \" \" );\n\n\tif ( off > -1 ) {\n\t\tselector = stripAndCollapse( url.slice( off ) );\n\t\turl = url.slice( 0, off );\n\t}\n\n\t// If it's a function\n\tif ( jQuery.isFunction( params ) ) {\n\n\t\t// We assume that it's the callback\n\t\tcallback = params;\n\t\tparams = undefined;\n\n\t// Otherwise, build a param string\n\t} else if ( params && typeof params === \"object\" ) {\n\t\ttype = \"POST\";\n\t}\n\n\t// If we have elements to modify, make the request\n\tif ( self.length > 0 ) {\n\t\tjQuery.ajax( {\n\t\t\turl: url,\n\n\t\t\t// If \"type\" variable is undefined, then \"GET\" method will be used.\n\t\t\t// Make value of this field explicit since\n\t\t\t// user can override it through ajaxSetup method\n\t\t\ttype: type || \"GET\",\n\t\t\tdataType: \"html\",\n\t\t\tdata: params\n\t\t} ).done( function( responseText ) {\n\n\t\t\t// Save response for use in complete callback\n\t\t\tresponse = arguments;\n\n\t\t\tself.html( selector ?\n\n\t\t\t\t// If a selector was specified, locate the right elements in a dummy div\n\t\t\t\t// Exclude scripts to avoid IE 'Permission Denied' errors\n\t\t\t\tjQuery( \"<div>\" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :\n\n\t\t\t\t// Otherwise use the full result\n\t\t\t\tresponseText );\n\n\t\t// If the request succeeds, this function gets \"data\", \"status\", \"jqXHR\"\n\t\t// but they are ignored because response was set above.\n\t\t// If it fails, this function gets \"jqXHR\", \"status\", \"error\"\n\t\t} ).always( callback && function( jqXHR, status ) {\n\t\t\tself.each( function() {\n\t\t\t\tcallback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );\n\t\t\t} );\n\t\t} );\n\t}\n\n\treturn this;\n};\n\n\n\n\n// Attach a bunch of functions for handling common AJAX events\njQuery.each( [\n\t\"ajaxStart\",\n\t\"ajaxStop\",\n\t\"ajaxComplete\",\n\t\"ajaxError\",\n\t\"ajaxSuccess\",\n\t\"ajaxSend\"\n], function( i, type ) {\n\tjQuery.fn[ type ] = function( fn ) {\n\t\treturn this.on( type, fn );\n\t};\n} );\n\n\n\n\njQuery.expr.pseudos.animated = function( elem ) {\n\treturn jQuery.grep( jQuery.timers, function( fn ) {\n\t\treturn elem === fn.elem;\n\t} ).length;\n};\n\n\n\n\njQuery.offset = {\n\tsetOffset: function( elem, options, i ) {\n\t\tvar curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,\n\t\t\tposition = jQuery.css( elem, \"position\" ),\n\t\t\tcurElem = jQuery( elem ),\n\t\t\tprops = {};\n\n\t\t// Set position first, in-case top/left are set even on static elem\n\t\tif ( position === \"static\" ) {\n\t\t\telem.style.position = \"relative\";\n\t\t}\n\n\t\tcurOffset = curElem.offset();\n\t\tcurCSSTop = jQuery.css( elem, \"top\" );\n\t\tcurCSSLeft = jQuery.css( elem, \"left\" );\n\t\tcalculatePosition = ( position === \"absolute\" || position === \"fixed\" ) &&\n\t\t\t( curCSSTop + curCSSLeft ).indexOf( \"auto\" ) > -1;\n\n\t\t// Need to be able to calculate position if either\n\t\t// top or left is auto and position is either absolute or fixed\n\t\tif ( calculatePosition ) {\n\t\t\tcurPosition = curElem.position();\n\t\t\tcurTop = curPosition.top;\n\t\t\tcurLeft = curPosition.left;\n\n\t\t} else {\n\t\t\tcurTop = parseFloat( curCSSTop ) || 0;\n\t\t\tcurLeft = parseFloat( curCSSLeft ) || 0;\n\t\t}\n\n\t\tif ( jQuery.isFunction( options ) ) {\n\n\t\t\t// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)\n\t\t\toptions = options.call( elem, i, jQuery.extend( {}, curOffset ) );\n\t\t}\n\n\t\tif ( options.top != null ) {\n\t\t\tprops.top = ( options.top - curOffset.top ) + curTop;\n\t\t}\n\t\tif ( options.left != null ) {\n\t\t\tprops.left = ( options.left - curOffset.left ) + curLeft;\n\t\t}\n\n\t\tif ( \"using\" in options ) {\n\t\t\toptions.using.call( elem, props );\n\n\t\t} else {\n\t\t\tcurElem.css( props );\n\t\t}\n\t}\n};\n\njQuery.fn.extend( {\n\toffset: function( options ) {\n\n\t\t// Preserve chaining for setter\n\t\tif ( arguments.length ) {\n\t\t\treturn options === undefined ?\n\t\t\t\tthis :\n\t\t\t\tthis.each( function( i ) {\n\t\t\t\t\tjQuery.offset.setOffset( this, options, i );\n\t\t\t\t} );\n\t\t}\n\n\t\tvar doc, docElem, rect, win,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !elem ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Return zeros for disconnected and hidden (display: none) elements (gh-2310)\n\t\t// Support: IE <=11 only\n\t\t// Running getBoundingClientRect on a\n\t\t// disconnected node in IE throws an error\n\t\tif ( !elem.getClientRects().length ) {\n\t\t\treturn { top: 0, left: 0 };\n\t\t}\n\n\t\trect = elem.getBoundingClientRect();\n\n\t\tdoc = elem.ownerDocument;\n\t\tdocElem = doc.documentElement;\n\t\twin = doc.defaultView;\n\n\t\treturn {\n\t\t\ttop: rect.top + win.pageYOffset - docElem.clientTop,\n\t\t\tleft: rect.left + win.pageXOffset - docElem.clientLeft\n\t\t};\n\t},\n\n\tposition: function() {\n\t\tif ( !this[ 0 ] ) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar offsetParent, offset,\n\t\t\telem = this[ 0 ],\n\t\t\tparentOffset = { top: 0, left: 0 };\n\n\t\t// Fixed elements are offset from window (parentOffset = {top:0, left: 0},\n\t\t// because it is its only offset parent\n\t\tif ( jQuery.css( elem, \"position\" ) === \"fixed\" ) {\n\n\t\t\t// Assume getBoundingClientRect is there when computed position is fixed\n\t\t\toffset = elem.getBoundingClientRect();\n\n\t\t} else {\n\n\t\t\t// Get *real* offsetParent\n\t\t\toffsetParent = this.offsetParent();\n\n\t\t\t// Get correct offsets\n\t\t\toffset = this.offset();\n\t\t\tif ( !nodeName( offsetParent[ 0 ], \"html\" ) ) {\n\t\t\t\tparentOffset = offsetParent.offset();\n\t\t\t}\n\n\t\t\t// Add offsetParent borders\n\t\t\tparentOffset = {\n\t\t\t\ttop: parentOffset.top + jQuery.css( offsetParent[ 0 ], \"borderTopWidth\", true ),\n\t\t\t\tleft: parentOffset.left + jQuery.css( offsetParent[ 0 ], \"borderLeftWidth\", true )\n\t\t\t};\n\t\t}\n\n\t\t// Subtract parent offsets and element margins\n\t\treturn {\n\t\t\ttop: offset.top - parentOffset.top - jQuery.css( elem, \"marginTop\", true ),\n\t\t\tleft: offset.left - parentOffset.left - jQuery.css( elem, \"marginLeft\", true )\n\t\t};\n\t},\n\n\t// This method will return documentElement in the following cases:\n\t// 1) For the element inside the iframe without offsetParent, this method will return\n\t//    documentElement of the parent window\n\t// 2) For the hidden or detached element\n\t// 3) For body or html element, i.e. in case of the html node - it will return itself\n\t//\n\t// but those exceptions were never presented as a real life use-cases\n\t// and might be considered as more preferable results.\n\t//\n\t// This logic, however, is not guaranteed and can change at any point in the future\n\toffsetParent: function() {\n\t\treturn this.map( function() {\n\t\t\tvar offsetParent = this.offsetParent;\n\n\t\t\twhile ( offsetParent && jQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\t\t\t\toffsetParent = offsetParent.offsetParent;\n\t\t\t}\n\n\t\t\treturn offsetParent || documentElement;\n\t\t} );\n\t}\n} );\n\n// Create scrollLeft and scrollTop methods\njQuery.each( { scrollLeft: \"pageXOffset\", scrollTop: \"pageYOffset\" }, function( method, prop ) {\n\tvar top = \"pageYOffset\" === prop;\n\n\tjQuery.fn[ method ] = function( val ) {\n\t\treturn access( this, function( elem, method, val ) {\n\n\t\t\t// Coalesce documents and windows\n\t\t\tvar win;\n\t\t\tif ( jQuery.isWindow( elem ) ) {\n\t\t\t\twin = elem;\n\t\t\t} else if ( elem.nodeType === 9 ) {\n\t\t\t\twin = elem.defaultView;\n\t\t\t}\n\n\t\t\tif ( val === undefined ) {\n\t\t\t\treturn win ? win[ prop ] : elem[ method ];\n\t\t\t}\n\n\t\t\tif ( win ) {\n\t\t\t\twin.scrollTo(\n\t\t\t\t\t!top ? val : win.pageXOffset,\n\t\t\t\t\ttop ? val : win.pageYOffset\n\t\t\t\t);\n\n\t\t\t} else {\n\t\t\t\telem[ method ] = val;\n\t\t\t}\n\t\t}, method, val, arguments.length );\n\t};\n} );\n\n// Support: Safari <=7 - 9.1, Chrome <=37 - 49\n// Add the top/left cssHooks using jQuery.fn.position\n// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084\n// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347\n// getComputedStyle returns percent when specified for top/left/bottom/right;\n// rather than make the css module depend on the offset module, just check for it here\njQuery.each( [ \"top\", \"left\" ], function( i, prop ) {\n\tjQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,\n\t\tfunction( elem, computed ) {\n\t\t\tif ( computed ) {\n\t\t\t\tcomputed = curCSS( elem, prop );\n\n\t\t\t\t// If curCSS returns percentage, fallback to offset\n\t\t\t\treturn rnumnonpx.test( computed ) ?\n\t\t\t\t\tjQuery( elem ).position()[ prop ] + \"px\" :\n\t\t\t\t\tcomputed;\n\t\t\t}\n\t\t}\n\t);\n} );\n\n\n// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\njQuery.each( { Height: \"height\", Width: \"width\" }, function( name, type ) {\n\tjQuery.each( { padding: \"inner\" + name, content: type, \"\": \"outer\" + name },\n\t\tfunction( defaultExtra, funcName ) {\n\n\t\t// Margin is only for outerHeight, outerWidth\n\t\tjQuery.fn[ funcName ] = function( margin, value ) {\n\t\t\tvar chainable = arguments.length && ( defaultExtra || typeof margin !== \"boolean\" ),\n\t\t\t\textra = defaultExtra || ( margin === true || value === true ? \"margin\" : \"border\" );\n\n\t\t\treturn access( this, function( elem, type, value ) {\n\t\t\t\tvar doc;\n\n\t\t\t\tif ( jQuery.isWindow( elem ) ) {\n\n\t\t\t\t\t// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)\n\t\t\t\t\treturn funcName.indexOf( \"outer\" ) === 0 ?\n\t\t\t\t\t\telem[ \"inner\" + name ] :\n\t\t\t\t\t\telem.document.documentElement[ \"client\" + name ];\n\t\t\t\t}\n\n\t\t\t\t// Get document width or height\n\t\t\t\tif ( elem.nodeType === 9 ) {\n\t\t\t\t\tdoc = elem.documentElement;\n\n\t\t\t\t\t// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],\n\t\t\t\t\t// whichever is greatest\n\t\t\t\t\treturn Math.max(\n\t\t\t\t\t\telem.body[ \"scroll\" + name ], doc[ \"scroll\" + name ],\n\t\t\t\t\t\telem.body[ \"offset\" + name ], doc[ \"offset\" + name ],\n\t\t\t\t\t\tdoc[ \"client\" + name ]\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\treturn value === undefined ?\n\n\t\t\t\t\t// Get width or height on the element, requesting but not forcing parseFloat\n\t\t\t\t\tjQuery.css( elem, type, extra ) :\n\n\t\t\t\t\t// Set width or height on the element\n\t\t\t\t\tjQuery.style( elem, type, value, extra );\n\t\t\t}, type, chainable ? margin : undefined, chainable );\n\t\t};\n\t} );\n} );\n\n\njQuery.fn.extend( {\n\n\tbind: function( types, data, fn ) {\n\t\treturn this.on( types, null, data, fn );\n\t},\n\tunbind: function( types, fn ) {\n\t\treturn this.off( types, null, fn );\n\t},\n\n\tdelegate: function( selector, types, data, fn ) {\n\t\treturn this.on( types, selector, data, fn );\n\t},\n\tundelegate: function( selector, types, fn ) {\n\n\t\t// ( namespace ) or ( selector, types [, fn] )\n\t\treturn arguments.length === 1 ?\n\t\t\tthis.off( selector, \"**\" ) :\n\t\t\tthis.off( types, selector || \"**\", fn );\n\t}\n} );\n\njQuery.holdReady = function( hold ) {\n\tif ( hold ) {\n\t\tjQuery.readyWait++;\n\t} else {\n\t\tjQuery.ready( true );\n\t}\n};\njQuery.isArray = Array.isArray;\njQuery.parseJSON = JSON.parse;\njQuery.nodeName = nodeName;\n\n\n\n\n// Register as a named AMD module, since jQuery can be concatenated with other\n// files that may use define, but not via a proper concatenation script that\n// understands anonymous AMD modules. A named AMD is safest and most robust\n// way to register. Lowercase jquery is used because AMD module names are\n// derived from file names, and jQuery is normally delivered in a lowercase\n// file name. Do this after creating the global so that if an AMD module wants\n// to call noConflict to hide this version of jQuery, it will work.\n\n// Note that for maximum portability, libraries that are not jQuery should\n// declare themselves as anonymous modules, and avoid setting a global if an\n// AMD loader is present. jQuery is a special case. For more information, see\n// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon\n\nif ( typeof define === \"function\" && define.amd ) {\n\tdefine( \"jquery\", [], function() {\n\t\treturn jQuery;\n\t} );\n}\n\n\n\n\nvar\n\n\t// Map over jQuery in case of overwrite\n\t_jQuery = window.jQuery,\n\n\t// Map over the $ in case of overwrite\n\t_$ = window.$;\n\njQuery.noConflict = function( deep ) {\n\tif ( window.$ === jQuery ) {\n\t\twindow.$ = _$;\n\t}\n\n\tif ( deep && window.jQuery === jQuery ) {\n\t\twindow.jQuery = _jQuery;\n\t}\n\n\treturn jQuery;\n};\n\n// Expose jQuery and $ identifiers, even in AMD\n// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)\n// and CommonJS for browser emulators (#13566)\nif ( !noGlobal ) {\n\twindow.jQuery = window.$ = jQuery;\n}\n\n\n\n\nreturn jQuery;\n} );\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","var toInteger = require('./toInteger');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that invokes `func`, with the `this` binding and arguments\n * of the created function, while it's called less than `n` times. Subsequent\n * calls to the created function return the result of the last `func` invocation.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {number} n The number of calls at which `func` is no longer invoked.\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new restricted function.\n * @example\n *\n * jQuery(element).on('click', _.before(5, addContactToList));\n * // => Allows adding up to 4 contacts to the list.\n */\nfunction before(n, func) {\n  var result;\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  n = toInteger(n);\n  return function() {\n    if (--n > 0) {\n      result = func.apply(this, arguments);\n    }\n    if (n <= 1) {\n      func = undefined;\n    }\n    return result;\n  };\n}\n\nmodule.exports = before;\n","var isObject = require('./isObject'),\n    now = require('./now'),\n    toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nmodule.exports = debounce;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","/**\n * @license\n * Lodash <https://lodash.com/>\n * Copyright JS Foundation and other contributors <https://js.foundation/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n;(function() {\n\n  /** Used as a safe reference for `undefined` in pre-ES5 environments. */\n  var undefined;\n\n  /** Used as the semantic version number. */\n  var VERSION = '4.17.4';\n\n  /** Used as the size to enable large array optimizations. */\n  var LARGE_ARRAY_SIZE = 200;\n\n  /** Error message constants. */\n  var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',\n      FUNC_ERROR_TEXT = 'Expected a function';\n\n  /** Used to stand-in for `undefined` hash values. */\n  var HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n  /** Used as the maximum memoize cache size. */\n  var MAX_MEMOIZE_SIZE = 500;\n\n  /** Used as the internal argument placeholder. */\n  var PLACEHOLDER = '__lodash_placeholder__';\n\n  /** Used to compose bitmasks for cloning. */\n  var CLONE_DEEP_FLAG = 1,\n      CLONE_FLAT_FLAG = 2,\n      CLONE_SYMBOLS_FLAG = 4;\n\n  /** Used to compose bitmasks for value comparisons. */\n  var COMPARE_PARTIAL_FLAG = 1,\n      COMPARE_UNORDERED_FLAG = 2;\n\n  /** Used to compose bitmasks for function metadata. */\n  var WRAP_BIND_FLAG = 1,\n      WRAP_BIND_KEY_FLAG = 2,\n      WRAP_CURRY_BOUND_FLAG = 4,\n      WRAP_CURRY_FLAG = 8,\n      WRAP_CURRY_RIGHT_FLAG = 16,\n      WRAP_PARTIAL_FLAG = 32,\n      WRAP_PARTIAL_RIGHT_FLAG = 64,\n      WRAP_ARY_FLAG = 128,\n      WRAP_REARG_FLAG = 256,\n      WRAP_FLIP_FLAG = 512;\n\n  /** Used as default options for `_.truncate`. */\n  var DEFAULT_TRUNC_LENGTH = 30,\n      DEFAULT_TRUNC_OMISSION = '...';\n\n  /** Used to detect hot functions by number of calls within a span of milliseconds. */\n  var HOT_COUNT = 800,\n      HOT_SPAN = 16;\n\n  /** Used to indicate the type of lazy iteratees. */\n  var LAZY_FILTER_FLAG = 1,\n      LAZY_MAP_FLAG = 2,\n      LAZY_WHILE_FLAG = 3;\n\n  /** Used as references for various `Number` constants. */\n  var INFINITY = 1 / 0,\n      MAX_SAFE_INTEGER = 9007199254740991,\n      MAX_INTEGER = 1.7976931348623157e+308,\n      NAN = 0 / 0;\n\n  /** Used as references for the maximum length and index of an array. */\n  var MAX_ARRAY_LENGTH = 4294967295,\n      MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,\n      HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;\n\n  /** Used to associate wrap methods with their bit flags. */\n  var wrapFlags = [\n    ['ary', WRAP_ARY_FLAG],\n    ['bind', WRAP_BIND_FLAG],\n    ['bindKey', WRAP_BIND_KEY_FLAG],\n    ['curry', WRAP_CURRY_FLAG],\n    ['curryRight', WRAP_CURRY_RIGHT_FLAG],\n    ['flip', WRAP_FLIP_FLAG],\n    ['partial', WRAP_PARTIAL_FLAG],\n    ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],\n    ['rearg', WRAP_REARG_FLAG]\n  ];\n\n  /** `Object#toString` result references. */\n  var argsTag = '[object Arguments]',\n      arrayTag = '[object Array]',\n      asyncTag = '[object AsyncFunction]',\n      boolTag = '[object Boolean]',\n      dateTag = '[object Date]',\n      domExcTag = '[object DOMException]',\n      errorTag = '[object Error]',\n      funcTag = '[object Function]',\n      genTag = '[object GeneratorFunction]',\n      mapTag = '[object Map]',\n      numberTag = '[object Number]',\n      nullTag = '[object Null]',\n      objectTag = '[object Object]',\n      promiseTag = '[object Promise]',\n      proxyTag = '[object Proxy]',\n      regexpTag = '[object RegExp]',\n      setTag = '[object Set]',\n      stringTag = '[object String]',\n      symbolTag = '[object Symbol]',\n      undefinedTag = '[object Undefined]',\n      weakMapTag = '[object WeakMap]',\n      weakSetTag = '[object WeakSet]';\n\n  var arrayBufferTag = '[object ArrayBuffer]',\n      dataViewTag = '[object DataView]',\n      float32Tag = '[object Float32Array]',\n      float64Tag = '[object Float64Array]',\n      int8Tag = '[object Int8Array]',\n      int16Tag = '[object Int16Array]',\n      int32Tag = '[object Int32Array]',\n      uint8Tag = '[object Uint8Array]',\n      uint8ClampedTag = '[object Uint8ClampedArray]',\n      uint16Tag = '[object Uint16Array]',\n      uint32Tag = '[object Uint32Array]';\n\n  /** Used to match empty string literals in compiled template source. */\n  var reEmptyStringLeading = /\\b__p \\+= '';/g,\n      reEmptyStringMiddle = /\\b(__p \\+=) '' \\+/g,\n      reEmptyStringTrailing = /(__e\\(.*?\\)|\\b__t\\)) \\+\\n'';/g;\n\n  /** Used to match HTML entities and HTML characters. */\n  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,\n      reUnescapedHtml = /[&<>\"']/g,\n      reHasEscapedHtml = RegExp(reEscapedHtml.source),\n      reHasUnescapedHtml = RegExp(reUnescapedHtml.source);\n\n  /** Used to match template delimiters. */\n  var reEscape = /<%-([\\s\\S]+?)%>/g,\n      reEvaluate = /<%([\\s\\S]+?)%>/g,\n      reInterpolate = /<%=([\\s\\S]+?)%>/g;\n\n  /** Used to match property names within property paths. */\n  var reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n      reIsPlainProp = /^\\w*$/,\n      reLeadingDot = /^\\./,\n      rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n  /**\n   * Used to match `RegExp`\n   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n   */\n  var reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g,\n      reHasRegExpChar = RegExp(reRegExpChar.source);\n\n  /** Used to match leading and trailing whitespace. */\n  var reTrim = /^\\s+|\\s+$/g,\n      reTrimStart = /^\\s+/,\n      reTrimEnd = /\\s+$/;\n\n  /** Used to match wrap detail comments. */\n  var reWrapComment = /\\{(?:\\n\\/\\* \\[wrapped with .+\\] \\*\\/)?\\n?/,\n      reWrapDetails = /\\{\\n\\/\\* \\[wrapped with (.+)\\] \\*/,\n      reSplitDetails = /,? & /;\n\n  /** Used to match words composed of alphanumeric characters. */\n  var reAsciiWord = /[^\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7f]+/g;\n\n  /** Used to match backslashes in property paths. */\n  var reEscapeChar = /\\\\(\\\\)?/g;\n\n  /**\n   * Used to match\n   * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).\n   */\n  var reEsTemplate = /\\$\\{([^\\\\}]*(?:\\\\.[^\\\\}]*)*)\\}/g;\n\n  /** Used to match `RegExp` flags from their coerced string values. */\n  var reFlags = /\\w*$/;\n\n  /** Used to detect bad signed hexadecimal string values. */\n  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n  /** Used to detect binary string values. */\n  var reIsBinary = /^0b[01]+$/i;\n\n  /** Used to detect host constructors (Safari). */\n  var reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n  /** Used to detect octal string values. */\n  var reIsOctal = /^0o[0-7]+$/i;\n\n  /** Used to detect unsigned integer values. */\n  var reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n  /** Used to match Latin Unicode letters (excluding mathematical operators). */\n  var reLatin = /[\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\xff\\u0100-\\u017f]/g;\n\n  /** Used to ensure capturing order of template delimiters. */\n  var reNoMatch = /($^)/;\n\n  /** Used to match unescaped characters in compiled string literals. */\n  var reUnescapedString = /['\\n\\r\\u2028\\u2029\\\\]/g;\n\n  /** Used to compose unicode character classes. */\n  var rsAstralRange = '\\\\ud800-\\\\udfff',\n      rsComboMarksRange = '\\\\u0300-\\\\u036f',\n      reComboHalfMarksRange = '\\\\ufe20-\\\\ufe2f',\n      rsComboSymbolsRange = '\\\\u20d0-\\\\u20ff',\n      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,\n      rsDingbatRange = '\\\\u2700-\\\\u27bf',\n      rsLowerRange = 'a-z\\\\xdf-\\\\xf6\\\\xf8-\\\\xff',\n      rsMathOpRange = '\\\\xac\\\\xb1\\\\xd7\\\\xf7',\n      rsNonCharRange = '\\\\x00-\\\\x2f\\\\x3a-\\\\x40\\\\x5b-\\\\x60\\\\x7b-\\\\xbf',\n      rsPunctuationRange = '\\\\u2000-\\\\u206f',\n      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',\n      rsUpperRange = 'A-Z\\\\xc0-\\\\xd6\\\\xd8-\\\\xde',\n      rsVarRange = '\\\\ufe0e\\\\ufe0f',\n      rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;\n\n  /** Used to compose unicode capture groups. */\n  var rsApos = \"['\\u2019]\",\n      rsAstral = '[' + rsAstralRange + ']',\n      rsBreak = '[' + rsBreakRange + ']',\n      rsCombo = '[' + rsComboRange + ']',\n      rsDigits = '\\\\d+',\n      rsDingbat = '[' + rsDingbatRange + ']',\n      rsLower = '[' + rsLowerRange + ']',\n      rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',\n      rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n      rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n      rsNonAstral = '[^' + rsAstralRange + ']',\n      rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n      rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n      rsUpper = '[' + rsUpperRange + ']',\n      rsZWJ = '\\\\u200d';\n\n  /** Used to compose unicode regexes. */\n  var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',\n      rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',\n      rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',\n      rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',\n      reOptMod = rsModifier + '?',\n      rsOptVar = '[' + rsVarRange + ']?',\n      rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n      rsOrdLower = '\\\\d*(?:(?:1st|2nd|3rd|(?![123])\\\\dth)\\\\b)',\n      rsOrdUpper = '\\\\d*(?:(?:1ST|2ND|3RD|(?![123])\\\\dTH)\\\\b)',\n      rsSeq = rsOptVar + reOptMod + rsOptJoin,\n      rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,\n      rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\n\n  /** Used to match apostrophes. */\n  var reApos = RegExp(rsApos, 'g');\n\n  /**\n   * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and\n   * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).\n   */\n  var reComboMark = RegExp(rsCombo, 'g');\n\n  /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\n  var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');\n\n  /** Used to match complex or compound words. */\n  var reUnicodeWord = RegExp([\n    rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',\n    rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',\n    rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,\n    rsUpper + '+' + rsOptContrUpper,\n    rsOrdUpper,\n    rsOrdLower,\n    rsDigits,\n    rsEmoji\n  ].join('|'), 'g');\n\n  /** 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/). */\n  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');\n\n  /** Used to detect strings that need a more robust regexp to match words. */\n  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 ]/;\n\n  /** Used to assign default `context` object properties. */\n  var contextProps = [\n    'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',\n    'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',\n    'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',\n    'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',\n    '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'\n  ];\n\n  /** Used to make template sourceURLs easier to identify. */\n  var templateCounter = -1;\n\n  /** Used to identify `toStringTag` values of typed arrays. */\n  var typedArrayTags = {};\n  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\n  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\n  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\n  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\n  typedArrayTags[uint32Tag] = true;\n  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =\n  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\n  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\n  typedArrayTags[errorTag] = typedArrayTags[funcTag] =\n  typedArrayTags[mapTag] = typedArrayTags[numberTag] =\n  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =\n  typedArrayTags[setTag] = typedArrayTags[stringTag] =\n  typedArrayTags[weakMapTag] = false;\n\n  /** Used to identify `toStringTag` values supported by `_.clone`. */\n  var cloneableTags = {};\n  cloneableTags[argsTag] = cloneableTags[arrayTag] =\n  cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\n  cloneableTags[boolTag] = cloneableTags[dateTag] =\n  cloneableTags[float32Tag] = cloneableTags[float64Tag] =\n  cloneableTags[int8Tag] = cloneableTags[int16Tag] =\n  cloneableTags[int32Tag] = cloneableTags[mapTag] =\n  cloneableTags[numberTag] = cloneableTags[objectTag] =\n  cloneableTags[regexpTag] = cloneableTags[setTag] =\n  cloneableTags[stringTag] = cloneableTags[symbolTag] =\n  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\n  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\n  cloneableTags[errorTag] = cloneableTags[funcTag] =\n  cloneableTags[weakMapTag] = false;\n\n  /** Used to map Latin Unicode letters to basic Latin letters. */\n  var deburredLetters = {\n    // Latin-1 Supplement block.\n    '\\xc0': 'A',  '\\xc1': 'A', '\\xc2': 'A', '\\xc3': 'A', '\\xc4': 'A', '\\xc5': 'A',\n    '\\xe0': 'a',  '\\xe1': 'a', '\\xe2': 'a', '\\xe3': 'a', '\\xe4': 'a', '\\xe5': 'a',\n    '\\xc7': 'C',  '\\xe7': 'c',\n    '\\xd0': 'D',  '\\xf0': 'd',\n    '\\xc8': 'E',  '\\xc9': 'E', '\\xca': 'E', '\\xcb': 'E',\n    '\\xe8': 'e',  '\\xe9': 'e', '\\xea': 'e', '\\xeb': 'e',\n    '\\xcc': 'I',  '\\xcd': 'I', '\\xce': 'I', '\\xcf': 'I',\n    '\\xec': 'i',  '\\xed': 'i', '\\xee': 'i', '\\xef': 'i',\n    '\\xd1': 'N',  '\\xf1': 'n',\n    '\\xd2': 'O',  '\\xd3': 'O', '\\xd4': 'O', '\\xd5': 'O', '\\xd6': 'O', '\\xd8': 'O',\n    '\\xf2': 'o',  '\\xf3': 'o', '\\xf4': 'o', '\\xf5': 'o', '\\xf6': 'o', '\\xf8': 'o',\n    '\\xd9': 'U',  '\\xda': 'U', '\\xdb': 'U', '\\xdc': 'U',\n    '\\xf9': 'u',  '\\xfa': 'u', '\\xfb': 'u', '\\xfc': 'u',\n    '\\xdd': 'Y',  '\\xfd': 'y', '\\xff': 'y',\n    '\\xc6': 'Ae', '\\xe6': 'ae',\n    '\\xde': 'Th', '\\xfe': 'th',\n    '\\xdf': 'ss',\n    // Latin Extended-A block.\n    '\\u0100': 'A',  '\\u0102': 'A', '\\u0104': 'A',\n    '\\u0101': 'a',  '\\u0103': 'a', '\\u0105': 'a',\n    '\\u0106': 'C',  '\\u0108': 'C', '\\u010a': 'C', '\\u010c': 'C',\n    '\\u0107': 'c',  '\\u0109': 'c', '\\u010b': 'c', '\\u010d': 'c',\n    '\\u010e': 'D',  '\\u0110': 'D', '\\u010f': 'd', '\\u0111': 'd',\n    '\\u0112': 'E',  '\\u0114': 'E', '\\u0116': 'E', '\\u0118': 'E', '\\u011a': 'E',\n    '\\u0113': 'e',  '\\u0115': 'e', '\\u0117': 'e', '\\u0119': 'e', '\\u011b': 'e',\n    '\\u011c': 'G',  '\\u011e': 'G', '\\u0120': 'G', '\\u0122': 'G',\n    '\\u011d': 'g',  '\\u011f': 'g', '\\u0121': 'g', '\\u0123': 'g',\n    '\\u0124': 'H',  '\\u0126': 'H', '\\u0125': 'h', '\\u0127': 'h',\n    '\\u0128': 'I',  '\\u012a': 'I', '\\u012c': 'I', '\\u012e': 'I', '\\u0130': 'I',\n    '\\u0129': 'i',  '\\u012b': 'i', '\\u012d': 'i', '\\u012f': 'i', '\\u0131': 'i',\n    '\\u0134': 'J',  '\\u0135': 'j',\n    '\\u0136': 'K',  '\\u0137': 'k', '\\u0138': 'k',\n    '\\u0139': 'L',  '\\u013b': 'L', '\\u013d': 'L', '\\u013f': 'L', '\\u0141': 'L',\n    '\\u013a': 'l',  '\\u013c': 'l', '\\u013e': 'l', '\\u0140': 'l', '\\u0142': 'l',\n    '\\u0143': 'N',  '\\u0145': 'N', '\\u0147': 'N', '\\u014a': 'N',\n    '\\u0144': 'n',  '\\u0146': 'n', '\\u0148': 'n', '\\u014b': 'n',\n    '\\u014c': 'O',  '\\u014e': 'O', '\\u0150': 'O',\n    '\\u014d': 'o',  '\\u014f': 'o', '\\u0151': 'o',\n    '\\u0154': 'R',  '\\u0156': 'R', '\\u0158': 'R',\n    '\\u0155': 'r',  '\\u0157': 'r', '\\u0159': 'r',\n    '\\u015a': 'S',  '\\u015c': 'S', '\\u015e': 'S', '\\u0160': 'S',\n    '\\u015b': 's',  '\\u015d': 's', '\\u015f': 's', '\\u0161': 's',\n    '\\u0162': 'T',  '\\u0164': 'T', '\\u0166': 'T',\n    '\\u0163': 't',  '\\u0165': 't', '\\u0167': 't',\n    '\\u0168': 'U',  '\\u016a': 'U', '\\u016c': 'U', '\\u016e': 'U', '\\u0170': 'U', '\\u0172': 'U',\n    '\\u0169': 'u',  '\\u016b': 'u', '\\u016d': 'u', '\\u016f': 'u', '\\u0171': 'u', '\\u0173': 'u',\n    '\\u0174': 'W',  '\\u0175': 'w',\n    '\\u0176': 'Y',  '\\u0177': 'y', '\\u0178': 'Y',\n    '\\u0179': 'Z',  '\\u017b': 'Z', '\\u017d': 'Z',\n    '\\u017a': 'z',  '\\u017c': 'z', '\\u017e': 'z',\n    '\\u0132': 'IJ', '\\u0133': 'ij',\n    '\\u0152': 'Oe', '\\u0153': 'oe',\n    '\\u0149': \"'n\", '\\u017f': 's'\n  };\n\n  /** Used to map characters to HTML entities. */\n  var htmlEscapes = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;'\n  };\n\n  /** Used to map HTML entities to characters. */\n  var htmlUnescapes = {\n    '&amp;': '&',\n    '&lt;': '<',\n    '&gt;': '>',\n    '&quot;': '\"',\n    '&#39;': \"'\"\n  };\n\n  /** Used to escape characters for inclusion in compiled string literals. */\n  var stringEscapes = {\n    '\\\\': '\\\\',\n    \"'\": \"'\",\n    '\\n': 'n',\n    '\\r': 'r',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  /** Built-in method references without a dependency on `root`. */\n  var freeParseFloat = parseFloat,\n      freeParseInt = parseInt;\n\n  /** Detect free variable `global` from Node.js. */\n  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n  /** Detect free variable `self`. */\n  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n  /** Used as a reference to the global object. */\n  var root = freeGlobal || freeSelf || Function('return this')();\n\n  /** Detect free variable `exports`. */\n  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n  /** Detect free variable `module`. */\n  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n  /** Detect the popular CommonJS extension `module.exports`. */\n  var moduleExports = freeModule && freeModule.exports === freeExports;\n\n  /** Detect free variable `process` from Node.js. */\n  var freeProcess = moduleExports && freeGlobal.process;\n\n  /** Used to access faster Node.js helpers. */\n  var nodeUtil = (function() {\n    try {\n      return freeProcess && freeProcess.binding && freeProcess.binding('util');\n    } catch (e) {}\n  }());\n\n  /* Node.js helper references. */\n  var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,\n      nodeIsDate = nodeUtil && nodeUtil.isDate,\n      nodeIsMap = nodeUtil && nodeUtil.isMap,\n      nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,\n      nodeIsSet = nodeUtil && nodeUtil.isSet,\n      nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * Adds the key-value `pair` to `map`.\n   *\n   * @private\n   * @param {Object} map The map to modify.\n   * @param {Array} pair The key-value pair to add.\n   * @returns {Object} Returns `map`.\n   */\n  function addMapEntry(map, pair) {\n    // Don't return `map.set` because it's not chainable in IE 11.\n    map.set(pair[0], pair[1]);\n    return map;\n  }\n\n  /**\n   * Adds `value` to `set`.\n   *\n   * @private\n   * @param {Object} set The set to modify.\n   * @param {*} value The value to add.\n   * @returns {Object} Returns `set`.\n   */\n  function addSetEntry(set, value) {\n    // Don't return `set.add` because it's not chainable in IE 11.\n    set.add(value);\n    return set;\n  }\n\n  /**\n   * A faster alternative to `Function#apply`, this function invokes `func`\n   * with the `this` binding of `thisArg` and the arguments of `args`.\n   *\n   * @private\n   * @param {Function} func The function to invoke.\n   * @param {*} thisArg The `this` binding of `func`.\n   * @param {Array} args The arguments to invoke `func` with.\n   * @returns {*} Returns the result of `func`.\n   */\n  function apply(func, thisArg, args) {\n    switch (args.length) {\n      case 0: return func.call(thisArg);\n      case 1: return func.call(thisArg, args[0]);\n      case 2: return func.call(thisArg, args[0], args[1]);\n      case 3: return func.call(thisArg, args[0], args[1], args[2]);\n    }\n    return func.apply(thisArg, args);\n  }\n\n  /**\n   * A specialized version of `baseAggregator` for arrays.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} setter The function to set `accumulator` values.\n   * @param {Function} iteratee The iteratee to transform keys.\n   * @param {Object} accumulator The initial aggregated object.\n   * @returns {Function} Returns `accumulator`.\n   */\n  function arrayAggregator(array, setter, iteratee, accumulator) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      var value = array[index];\n      setter(accumulator, value, iteratee(value), array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.forEach` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayEach(array, iteratee) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (iteratee(array[index], index, array) === false) {\n        break;\n      }\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.forEachRight` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayEachRight(array, iteratee) {\n    var length = array == null ? 0 : array.length;\n\n    while (length--) {\n      if (iteratee(array[length], length, array) === false) {\n        break;\n      }\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.every` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {boolean} Returns `true` if all elements pass the predicate check,\n   *  else `false`.\n   */\n  function arrayEvery(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (!predicate(array[index], index, array)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * A specialized version of `_.filter` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {Array} Returns the new filtered array.\n   */\n  function arrayFilter(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length,\n        resIndex = 0,\n        result = [];\n\n    while (++index < length) {\n      var value = array[index];\n      if (predicate(value, index, array)) {\n        result[resIndex++] = value;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * A specialized version of `_.includes` for arrays without support for\n   * specifying an index to search from.\n   *\n   * @private\n   * @param {Array} [array] The array to inspect.\n   * @param {*} target The value to search for.\n   * @returns {boolean} Returns `true` if `target` is found, else `false`.\n   */\n  function arrayIncludes(array, value) {\n    var length = array == null ? 0 : array.length;\n    return !!length && baseIndexOf(array, value, 0) > -1;\n  }\n\n  /**\n   * This function is like `arrayIncludes` except that it accepts a comparator.\n   *\n   * @private\n   * @param {Array} [array] The array to inspect.\n   * @param {*} target The value to search for.\n   * @param {Function} comparator The comparator invoked per element.\n   * @returns {boolean} Returns `true` if `target` is found, else `false`.\n   */\n  function arrayIncludesWith(array, value, comparator) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (comparator(value, array[index])) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * A specialized version of `_.map` for arrays without support for iteratee\n   * shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns the new mapped array.\n   */\n  function arrayMap(array, iteratee) {\n    var index = -1,\n        length = array == null ? 0 : array.length,\n        result = Array(length);\n\n    while (++index < length) {\n      result[index] = iteratee(array[index], index, array);\n    }\n    return result;\n  }\n\n  /**\n   * Appends the elements of `values` to `array`.\n   *\n   * @private\n   * @param {Array} array The array to modify.\n   * @param {Array} values The values to append.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayPush(array, values) {\n    var index = -1,\n        length = values.length,\n        offset = array.length;\n\n    while (++index < length) {\n      array[offset + index] = values[index];\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.reduce` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} [accumulator] The initial value.\n   * @param {boolean} [initAccum] Specify using the first element of `array` as\n   *  the initial value.\n   * @returns {*} Returns the accumulated value.\n   */\n  function arrayReduce(array, iteratee, accumulator, initAccum) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    if (initAccum && length) {\n      accumulator = array[++index];\n    }\n    while (++index < length) {\n      accumulator = iteratee(accumulator, array[index], index, array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.reduceRight` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} [accumulator] The initial value.\n   * @param {boolean} [initAccum] Specify using the last element of `array` as\n   *  the initial value.\n   * @returns {*} Returns the accumulated value.\n   */\n  function arrayReduceRight(array, iteratee, accumulator, initAccum) {\n    var length = array == null ? 0 : array.length;\n    if (initAccum && length) {\n      accumulator = array[--length];\n    }\n    while (length--) {\n      accumulator = iteratee(accumulator, array[length], length, array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.some` for arrays without support for iteratee\n   * shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {boolean} Returns `true` if any element passes the predicate check,\n   *  else `false`.\n   */\n  function arraySome(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (predicate(array[index], index, array)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Gets the size of an ASCII `string`.\n   *\n   * @private\n   * @param {string} string The string inspect.\n   * @returns {number} Returns the string size.\n   */\n  var asciiSize = baseProperty('length');\n\n  /**\n   * Converts an ASCII `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function asciiToArray(string) {\n    return string.split('');\n  }\n\n  /**\n   * Splits an ASCII `string` into an array of its words.\n   *\n   * @private\n   * @param {string} The string to inspect.\n   * @returns {Array} Returns the words of `string`.\n   */\n  function asciiWords(string) {\n    return string.match(reAsciiWord) || [];\n  }\n\n  /**\n   * The base implementation of methods like `_.findKey` and `_.findLastKey`,\n   * without support for iteratee shorthands, which iterates over `collection`\n   * using `eachFunc`.\n   *\n   * @private\n   * @param {Array|Object} collection The collection to inspect.\n   * @param {Function} predicate The function invoked per iteration.\n   * @param {Function} eachFunc The function to iterate over `collection`.\n   * @returns {*} Returns the found element or its key, else `undefined`.\n   */\n  function baseFindKey(collection, predicate, eachFunc) {\n    var result;\n    eachFunc(collection, function(value, key, collection) {\n      if (predicate(value, key, collection)) {\n        result = key;\n        return false;\n      }\n    });\n    return result;\n  }\n\n  /**\n   * The base implementation of `_.findIndex` and `_.findLastIndex` without\n   * support for iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {Function} predicate The function invoked per iteration.\n   * @param {number} fromIndex The index to search from.\n   * @param {boolean} [fromRight] Specify iterating from right to left.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseFindIndex(array, predicate, fromIndex, fromRight) {\n    var length = array.length,\n        index = fromIndex + (fromRight ? 1 : -1);\n\n    while ((fromRight ? index-- : ++index < length)) {\n      if (predicate(array[index], index, array)) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseIndexOf(array, value, fromIndex) {\n    return value === value\n      ? strictIndexOf(array, value, fromIndex)\n      : baseFindIndex(array, baseIsNaN, fromIndex);\n  }\n\n  /**\n   * This function is like `baseIndexOf` except that it accepts a comparator.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @param {Function} comparator The comparator invoked per element.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseIndexOfWith(array, value, fromIndex, comparator) {\n    var index = fromIndex - 1,\n        length = array.length;\n\n    while (++index < length) {\n      if (comparator(array[index], value)) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * The base implementation of `_.isNaN` without support for number objects.\n   *\n   * @private\n   * @param {*} value The value to check.\n   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n   */\n  function baseIsNaN(value) {\n    return value !== value;\n  }\n\n  /**\n   * The base implementation of `_.mean` and `_.meanBy` without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {number} Returns the mean.\n   */\n  function baseMean(array, iteratee) {\n    var length = array == null ? 0 : array.length;\n    return length ? (baseSum(array, iteratee) / length) : NAN;\n  }\n\n  /**\n   * The base implementation of `_.property` without support for deep paths.\n   *\n   * @private\n   * @param {string} key The key of the property to get.\n   * @returns {Function} Returns the new accessor function.\n   */\n  function baseProperty(key) {\n    return function(object) {\n      return object == null ? undefined : object[key];\n    };\n  }\n\n  /**\n   * The base implementation of `_.propertyOf` without support for deep paths.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @returns {Function} Returns the new accessor function.\n   */\n  function basePropertyOf(object) {\n    return function(key) {\n      return object == null ? undefined : object[key];\n    };\n  }\n\n  /**\n   * The base implementation of `_.reduce` and `_.reduceRight`, without support\n   * for iteratee shorthands, which iterates over `collection` using `eachFunc`.\n   *\n   * @private\n   * @param {Array|Object} collection The collection to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} accumulator The initial value.\n   * @param {boolean} initAccum Specify using the first or last element of\n   *  `collection` as the initial value.\n   * @param {Function} eachFunc The function to iterate over `collection`.\n   * @returns {*} Returns the accumulated value.\n   */\n  function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {\n    eachFunc(collection, function(value, index, collection) {\n      accumulator = initAccum\n        ? (initAccum = false, value)\n        : iteratee(accumulator, value, index, collection);\n    });\n    return accumulator;\n  }\n\n  /**\n   * The base implementation of `_.sortBy` which uses `comparer` to define the\n   * sort order of `array` and replaces criteria objects with their corresponding\n   * values.\n   *\n   * @private\n   * @param {Array} array The array to sort.\n   * @param {Function} comparer The function to define sort order.\n   * @returns {Array} Returns `array`.\n   */\n  function baseSortBy(array, comparer) {\n    var length = array.length;\n\n    array.sort(comparer);\n    while (length--) {\n      array[length] = array[length].value;\n    }\n    return array;\n  }\n\n  /**\n   * The base implementation of `_.sum` and `_.sumBy` without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {number} Returns the sum.\n   */\n  function baseSum(array, iteratee) {\n    var result,\n        index = -1,\n        length = array.length;\n\n    while (++index < length) {\n      var current = iteratee(array[index]);\n      if (current !== undefined) {\n        result = result === undefined ? current : (result + current);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * The base implementation of `_.times` without support for iteratee shorthands\n   * or max array length checks.\n   *\n   * @private\n   * @param {number} n The number of times to invoke `iteratee`.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns the array of results.\n   */\n  function baseTimes(n, iteratee) {\n    var index = -1,\n        result = Array(n);\n\n    while (++index < n) {\n      result[index] = iteratee(index);\n    }\n    return result;\n  }\n\n  /**\n   * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array\n   * of key-value pairs for `object` corresponding to the property names of `props`.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @param {Array} props The property names to get values for.\n   * @returns {Object} Returns the key-value pairs.\n   */\n  function baseToPairs(object, props) {\n    return arrayMap(props, function(key) {\n      return [key, object[key]];\n    });\n  }\n\n  /**\n   * The base implementation of `_.unary` without support for storing metadata.\n   *\n   * @private\n   * @param {Function} func The function to cap arguments for.\n   * @returns {Function} Returns the new capped function.\n   */\n  function baseUnary(func) {\n    return function(value) {\n      return func(value);\n    };\n  }\n\n  /**\n   * The base implementation of `_.values` and `_.valuesIn` which creates an\n   * array of `object` property values corresponding to the property names\n   * of `props`.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @param {Array} props The property names to get values for.\n   * @returns {Object} Returns the array of property values.\n   */\n  function baseValues(object, props) {\n    return arrayMap(props, function(key) {\n      return object[key];\n    });\n  }\n\n  /**\n   * Checks if a `cache` value for `key` exists.\n   *\n   * @private\n   * @param {Object} cache The cache to query.\n   * @param {string} key The key of the entry to check.\n   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n   */\n  function cacheHas(cache, key) {\n    return cache.has(key);\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol\n   * that is not found in the character symbols.\n   *\n   * @private\n   * @param {Array} strSymbols The string symbols to inspect.\n   * @param {Array} chrSymbols The character symbols to find.\n   * @returns {number} Returns the index of the first unmatched string symbol.\n   */\n  function charsStartIndex(strSymbols, chrSymbols) {\n    var index = -1,\n        length = strSymbols.length;\n\n    while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n    return index;\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol\n   * that is not found in the character symbols.\n   *\n   * @private\n   * @param {Array} strSymbols The string symbols to inspect.\n   * @param {Array} chrSymbols The character symbols to find.\n   * @returns {number} Returns the index of the last unmatched string symbol.\n   */\n  function charsEndIndex(strSymbols, chrSymbols) {\n    var index = strSymbols.length;\n\n    while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n    return index;\n  }\n\n  /**\n   * Gets the number of `placeholder` occurrences in `array`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} placeholder The placeholder to search for.\n   * @returns {number} Returns the placeholder count.\n   */\n  function countHolders(array, placeholder) {\n    var length = array.length,\n        result = 0;\n\n    while (length--) {\n      if (array[length] === placeholder) {\n        ++result;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A\n   * letters to basic Latin letters.\n   *\n   * @private\n   * @param {string} letter The matched letter to deburr.\n   * @returns {string} Returns the deburred letter.\n   */\n  var deburrLetter = basePropertyOf(deburredLetters);\n\n  /**\n   * Used by `_.escape` to convert characters to HTML entities.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @returns {string} Returns the escaped character.\n   */\n  var escapeHtmlChar = basePropertyOf(htmlEscapes);\n\n  /**\n   * Used by `_.template` to escape characters for inclusion in compiled string literals.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @returns {string} Returns the escaped character.\n   */\n  function escapeStringChar(chr) {\n    return '\\\\' + stringEscapes[chr];\n  }\n\n  /**\n   * Gets the value at `key` of `object`.\n   *\n   * @private\n   * @param {Object} [object] The object to query.\n   * @param {string} key The key of the property to get.\n   * @returns {*} Returns the property value.\n   */\n  function getValue(object, key) {\n    return object == null ? undefined : object[key];\n  }\n\n  /**\n   * Checks if `string` contains Unicode symbols.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {boolean} Returns `true` if a symbol is found, else `false`.\n   */\n  function hasUnicode(string) {\n    return reHasUnicode.test(string);\n  }\n\n  /**\n   * Checks if `string` contains a word composed of Unicode symbols.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {boolean} Returns `true` if a word is found, else `false`.\n   */\n  function hasUnicodeWord(string) {\n    return reHasUnicodeWord.test(string);\n  }\n\n  /**\n   * Converts `iterator` to an array.\n   *\n   * @private\n   * @param {Object} iterator The iterator to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function iteratorToArray(iterator) {\n    var data,\n        result = [];\n\n    while (!(data = iterator.next()).done) {\n      result.push(data.value);\n    }\n    return result;\n  }\n\n  /**\n   * Converts `map` to its key-value pairs.\n   *\n   * @private\n   * @param {Object} map The map to convert.\n   * @returns {Array} Returns the key-value pairs.\n   */\n  function mapToArray(map) {\n    var index = -1,\n        result = Array(map.size);\n\n    map.forEach(function(value, key) {\n      result[++index] = [key, value];\n    });\n    return result;\n  }\n\n  /**\n   * Creates a unary function that invokes `func` with its argument transformed.\n   *\n   * @private\n   * @param {Function} func The function to wrap.\n   * @param {Function} transform The argument transform.\n   * @returns {Function} Returns the new function.\n   */\n  function overArg(func, transform) {\n    return function(arg) {\n      return func(transform(arg));\n    };\n  }\n\n  /**\n   * Replaces all `placeholder` elements in `array` with an internal placeholder\n   * and returns an array of their indexes.\n   *\n   * @private\n   * @param {Array} array The array to modify.\n   * @param {*} placeholder The placeholder to replace.\n   * @returns {Array} Returns the new array of placeholder indexes.\n   */\n  function replaceHolders(array, placeholder) {\n    var index = -1,\n        length = array.length,\n        resIndex = 0,\n        result = [];\n\n    while (++index < length) {\n      var value = array[index];\n      if (value === placeholder || value === PLACEHOLDER) {\n        array[index] = PLACEHOLDER;\n        result[resIndex++] = index;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Converts `set` to an array of its values.\n   *\n   * @private\n   * @param {Object} set The set to convert.\n   * @returns {Array} Returns the values.\n   */\n  function setToArray(set) {\n    var index = -1,\n        result = Array(set.size);\n\n    set.forEach(function(value) {\n      result[++index] = value;\n    });\n    return result;\n  }\n\n  /**\n   * Converts `set` to its value-value pairs.\n   *\n   * @private\n   * @param {Object} set The set to convert.\n   * @returns {Array} Returns the value-value pairs.\n   */\n  function setToPairs(set) {\n    var index = -1,\n        result = Array(set.size);\n\n    set.forEach(function(value) {\n      result[++index] = [value, value];\n    });\n    return result;\n  }\n\n  /**\n   * A specialized version of `_.indexOf` which performs strict equality\n   * comparisons of values, i.e. `===`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function strictIndexOf(array, value, fromIndex) {\n    var index = fromIndex - 1,\n        length = array.length;\n\n    while (++index < length) {\n      if (array[index] === value) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * A specialized version of `_.lastIndexOf` which performs strict equality\n   * comparisons of values, i.e. `===`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function strictLastIndexOf(array, value, fromIndex) {\n    var index = fromIndex + 1;\n    while (index--) {\n      if (array[index] === value) {\n        return index;\n      }\n    }\n    return index;\n  }\n\n  /**\n   * Gets the number of symbols in `string`.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {number} Returns the string size.\n   */\n  function stringSize(string) {\n    return hasUnicode(string)\n      ? unicodeSize(string)\n      : asciiSize(string);\n  }\n\n  /**\n   * Converts `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function stringToArray(string) {\n    return hasUnicode(string)\n      ? unicodeToArray(string)\n      : asciiToArray(string);\n  }\n\n  /**\n   * Used by `_.unescape` to convert HTML entities to characters.\n   *\n   * @private\n   * @param {string} chr The matched character to unescape.\n   * @returns {string} Returns the unescaped character.\n   */\n  var unescapeHtmlChar = basePropertyOf(htmlUnescapes);\n\n  /**\n   * Gets the size of a Unicode `string`.\n   *\n   * @private\n   * @param {string} string The string inspect.\n   * @returns {number} Returns the string size.\n   */\n  function unicodeSize(string) {\n    var result = reUnicode.lastIndex = 0;\n    while (reUnicode.test(string)) {\n      ++result;\n    }\n    return result;\n  }\n\n  /**\n   * Converts a Unicode `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function unicodeToArray(string) {\n    return string.match(reUnicode) || [];\n  }\n\n  /**\n   * Splits a Unicode `string` into an array of its words.\n   *\n   * @private\n   * @param {string} The string to inspect.\n   * @returns {Array} Returns the words of `string`.\n   */\n  function unicodeWords(string) {\n    return string.match(reUnicodeWord) || [];\n  }\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * Create a new pristine `lodash` function using the `context` object.\n   *\n   * @static\n   * @memberOf _\n   * @since 1.1.0\n   * @category Util\n   * @param {Object} [context=root] The context object.\n   * @returns {Function} Returns a new `lodash` function.\n   * @example\n   *\n   * _.mixin({ 'foo': _.constant('foo') });\n   *\n   * var lodash = _.runInContext();\n   * lodash.mixin({ 'bar': lodash.constant('bar') });\n   *\n   * _.isFunction(_.foo);\n   * // => true\n   * _.isFunction(_.bar);\n   * // => false\n   *\n   * lodash.isFunction(lodash.foo);\n   * // => false\n   * lodash.isFunction(lodash.bar);\n   * // => true\n   *\n   * // Create a suped-up `defer` in Node.js.\n   * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;\n   */\n  var runInContext = (function runInContext(context) {\n    context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));\n\n    /** Built-in constructor references. */\n    var Array = context.Array,\n        Date = context.Date,\n        Error = context.Error,\n        Function = context.Function,\n        Math = context.Math,\n        Object = context.Object,\n        RegExp = context.RegExp,\n        String = context.String,\n        TypeError = context.TypeError;\n\n    /** Used for built-in method references. */\n    var arrayProto = Array.prototype,\n        funcProto = Function.prototype,\n        objectProto = Object.prototype;\n\n    /** Used to detect overreaching core-js shims. */\n    var coreJsData = context['__core-js_shared__'];\n\n    /** Used to resolve the decompiled source of functions. */\n    var funcToString = funcProto.toString;\n\n    /** Used to check objects for own properties. */\n    var hasOwnProperty = objectProto.hasOwnProperty;\n\n    /** Used to generate unique IDs. */\n    var idCounter = 0;\n\n    /** Used to detect methods masquerading as native. */\n    var maskSrcKey = (function() {\n      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n      return uid ? ('Symbol(src)_1.' + uid) : '';\n    }());\n\n    /**\n     * Used to resolve the\n     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n     * of values.\n     */\n    var nativeObjectToString = objectProto.toString;\n\n    /** Used to infer the `Object` constructor. */\n    var objectCtorString = funcToString.call(Object);\n\n    /** Used to restore the original `_` reference in `_.noConflict`. */\n    var oldDash = root._;\n\n    /** Used to detect if a method is native. */\n    var reIsNative = RegExp('^' +\n      funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n      .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n    );\n\n    /** Built-in value references. */\n    var Buffer = moduleExports ? context.Buffer : undefined,\n        Symbol = context.Symbol,\n        Uint8Array = context.Uint8Array,\n        allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,\n        getPrototype = overArg(Object.getPrototypeOf, Object),\n        objectCreate = Object.create,\n        propertyIsEnumerable = objectProto.propertyIsEnumerable,\n        splice = arrayProto.splice,\n        spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined,\n        symIterator = Symbol ? Symbol.iterator : undefined,\n        symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n    var defineProperty = (function() {\n      try {\n        var func = getNative(Object, 'defineProperty');\n        func({}, '', {});\n        return func;\n      } catch (e) {}\n    }());\n\n    /** Mocked built-ins. */\n    var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,\n        ctxNow = Date && Date.now !== root.Date.now && Date.now,\n        ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;\n\n    /* Built-in method references for those with the same name as other `lodash` methods. */\n    var nativeCeil = Math.ceil,\n        nativeFloor = Math.floor,\n        nativeGetSymbols = Object.getOwnPropertySymbols,\n        nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n        nativeIsFinite = context.isFinite,\n        nativeJoin = arrayProto.join,\n        nativeKeys = overArg(Object.keys, Object),\n        nativeMax = Math.max,\n        nativeMin = Math.min,\n        nativeNow = Date.now,\n        nativeParseInt = context.parseInt,\n        nativeRandom = Math.random,\n        nativeReverse = arrayProto.reverse;\n\n    /* Built-in method references that are verified to be native. */\n    var DataView = getNative(context, 'DataView'),\n        Map = getNative(context, 'Map'),\n        Promise = getNative(context, 'Promise'),\n        Set = getNative(context, 'Set'),\n        WeakMap = getNative(context, 'WeakMap'),\n        nativeCreate = getNative(Object, 'create');\n\n    /** Used to store function metadata. */\n    var metaMap = WeakMap && new WeakMap;\n\n    /** Used to lookup unminified function names. */\n    var realNames = {};\n\n    /** Used to detect maps, sets, and weakmaps. */\n    var dataViewCtorString = toSource(DataView),\n        mapCtorString = toSource(Map),\n        promiseCtorString = toSource(Promise),\n        setCtorString = toSource(Set),\n        weakMapCtorString = toSource(WeakMap);\n\n    /** Used to convert symbols to primitives and strings. */\n    var symbolProto = Symbol ? Symbol.prototype : undefined,\n        symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,\n        symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` object which wraps `value` to enable implicit method\n     * chain sequences. Methods that operate on and return arrays, collections,\n     * and functions can be chained together. Methods that retrieve a single value\n     * or may return a primitive value will automatically end the chain sequence\n     * and return the unwrapped value. Otherwise, the value must be unwrapped\n     * with `_#value`.\n     *\n     * Explicit chain sequences, which must be unwrapped with `_#value`, may be\n     * enabled using `_.chain`.\n     *\n     * The execution of chained methods is lazy, that is, it's deferred until\n     * `_#value` is implicitly or explicitly called.\n     *\n     * Lazy evaluation allows several methods to support shortcut fusion.\n     * Shortcut fusion is an optimization to merge iteratee calls; this avoids\n     * the creation of intermediate arrays and can greatly reduce the number of\n     * iteratee executions. Sections of a chain sequence qualify for shortcut\n     * fusion if the section is applied to an array and iteratees accept only\n     * one argument. The heuristic for whether a section qualifies for shortcut\n     * fusion is subject to change.\n     *\n     * Chaining is supported in custom builds as long as the `_#value` method is\n     * directly or indirectly included in the build.\n     *\n     * In addition to lodash methods, wrappers have `Array` and `String` methods.\n     *\n     * The wrapper `Array` methods are:\n     * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`\n     *\n     * The wrapper `String` methods are:\n     * `replace` and `split`\n     *\n     * The wrapper methods that support shortcut fusion are:\n     * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,\n     * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,\n     * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`\n     *\n     * The chainable wrapper methods are:\n     * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,\n     * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,\n     * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,\n     * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,\n     * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,\n     * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,\n     * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,\n     * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,\n     * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,\n     * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,\n     * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,\n     * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,\n     * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,\n     * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,\n     * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,\n     * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,\n     * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,\n     * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,\n     * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,\n     * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,\n     * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,\n     * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,\n     * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,\n     * `zipObject`, `zipObjectDeep`, and `zipWith`\n     *\n     * The wrapper methods that are **not** chainable by default are:\n     * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,\n     * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,\n     * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,\n     * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,\n     * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,\n     * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,\n     * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,\n     * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,\n     * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,\n     * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,\n     * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,\n     * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,\n     * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,\n     * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,\n     * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,\n     * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,\n     * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,\n     * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,\n     * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,\n     * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,\n     * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,\n     * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,\n     * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,\n     * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,\n     * `upperFirst`, `value`, and `words`\n     *\n     * @name _\n     * @constructor\n     * @category Seq\n     * @param {*} value The value to wrap in a `lodash` instance.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var wrapped = _([1, 2, 3]);\n     *\n     * // Returns an unwrapped value.\n     * wrapped.reduce(_.add);\n     * // => 6\n     *\n     * // Returns a wrapped value.\n     * var squares = wrapped.map(square);\n     *\n     * _.isArray(squares);\n     * // => false\n     *\n     * _.isArray(squares.value());\n     * // => true\n     */\n    function lodash(value) {\n      if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {\n        if (value instanceof LodashWrapper) {\n          return value;\n        }\n        if (hasOwnProperty.call(value, '__wrapped__')) {\n          return wrapperClone(value);\n        }\n      }\n      return new LodashWrapper(value);\n    }\n\n    /**\n     * The base implementation of `_.create` without support for assigning\n     * properties to the created object.\n     *\n     * @private\n     * @param {Object} proto The object to inherit from.\n     * @returns {Object} Returns the new object.\n     */\n    var baseCreate = (function() {\n      function object() {}\n      return function(proto) {\n        if (!isObject(proto)) {\n          return {};\n        }\n        if (objectCreate) {\n          return objectCreate(proto);\n        }\n        object.prototype = proto;\n        var result = new object;\n        object.prototype = undefined;\n        return result;\n      };\n    }());\n\n    /**\n     * The function whose prototype chain sequence wrappers inherit from.\n     *\n     * @private\n     */\n    function baseLodash() {\n      // No operation performed.\n    }\n\n    /**\n     * The base constructor for creating `lodash` wrapper objects.\n     *\n     * @private\n     * @param {*} value The value to wrap.\n     * @param {boolean} [chainAll] Enable explicit method chain sequences.\n     */\n    function LodashWrapper(value, chainAll) {\n      this.__wrapped__ = value;\n      this.__actions__ = [];\n      this.__chain__ = !!chainAll;\n      this.__index__ = 0;\n      this.__values__ = undefined;\n    }\n\n    /**\n     * By default, the template delimiters used by lodash are like those in\n     * embedded Ruby (ERB) as well as ES2015 template strings. Change the\n     * following template settings to use alternative delimiters.\n     *\n     * @static\n     * @memberOf _\n     * @type {Object}\n     */\n    lodash.templateSettings = {\n\n      /**\n       * Used to detect `data` property values to be HTML-escaped.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'escape': reEscape,\n\n      /**\n       * Used to detect code to be evaluated.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'evaluate': reEvaluate,\n\n      /**\n       * Used to detect `data` property values to inject.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'interpolate': reInterpolate,\n\n      /**\n       * Used to reference the data object in the template text.\n       *\n       * @memberOf _.templateSettings\n       * @type {string}\n       */\n      'variable': '',\n\n      /**\n       * Used to import variables into the compiled template.\n       *\n       * @memberOf _.templateSettings\n       * @type {Object}\n       */\n      'imports': {\n\n        /**\n         * A reference to the `lodash` function.\n         *\n         * @memberOf _.templateSettings.imports\n         * @type {Function}\n         */\n        '_': lodash\n      }\n    };\n\n    // Ensure wrappers are instances of `baseLodash`.\n    lodash.prototype = baseLodash.prototype;\n    lodash.prototype.constructor = lodash;\n\n    LodashWrapper.prototype = baseCreate(baseLodash.prototype);\n    LodashWrapper.prototype.constructor = LodashWrapper;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.\n     *\n     * @private\n     * @constructor\n     * @param {*} value The value to wrap.\n     */\n    function LazyWrapper(value) {\n      this.__wrapped__ = value;\n      this.__actions__ = [];\n      this.__dir__ = 1;\n      this.__filtered__ = false;\n      this.__iteratees__ = [];\n      this.__takeCount__ = MAX_ARRAY_LENGTH;\n      this.__views__ = [];\n    }\n\n    /**\n     * Creates a clone of the lazy wrapper object.\n     *\n     * @private\n     * @name clone\n     * @memberOf LazyWrapper\n     * @returns {Object} Returns the cloned `LazyWrapper` object.\n     */\n    function lazyClone() {\n      var result = new LazyWrapper(this.__wrapped__);\n      result.__actions__ = copyArray(this.__actions__);\n      result.__dir__ = this.__dir__;\n      result.__filtered__ = this.__filtered__;\n      result.__iteratees__ = copyArray(this.__iteratees__);\n      result.__takeCount__ = this.__takeCount__;\n      result.__views__ = copyArray(this.__views__);\n      return result;\n    }\n\n    /**\n     * Reverses the direction of lazy iteration.\n     *\n     * @private\n     * @name reverse\n     * @memberOf LazyWrapper\n     * @returns {Object} Returns the new reversed `LazyWrapper` object.\n     */\n    function lazyReverse() {\n      if (this.__filtered__) {\n        var result = new LazyWrapper(this);\n        result.__dir__ = -1;\n        result.__filtered__ = true;\n      } else {\n        result = this.clone();\n        result.__dir__ *= -1;\n      }\n      return result;\n    }\n\n    /**\n     * Extracts the unwrapped value from its lazy wrapper.\n     *\n     * @private\n     * @name value\n     * @memberOf LazyWrapper\n     * @returns {*} Returns the unwrapped value.\n     */\n    function lazyValue() {\n      var array = this.__wrapped__.value(),\n          dir = this.__dir__,\n          isArr = isArray(array),\n          isRight = dir < 0,\n          arrLength = isArr ? array.length : 0,\n          view = getView(0, arrLength, this.__views__),\n          start = view.start,\n          end = view.end,\n          length = end - start,\n          index = isRight ? end : (start - 1),\n          iteratees = this.__iteratees__,\n          iterLength = iteratees.length,\n          resIndex = 0,\n          takeCount = nativeMin(length, this.__takeCount__);\n\n      if (!isArr || (!isRight && arrLength == length && takeCount == length)) {\n        return baseWrapperValue(array, this.__actions__);\n      }\n      var result = [];\n\n      outer:\n      while (length-- && resIndex < takeCount) {\n        index += dir;\n\n        var iterIndex = -1,\n            value = array[index];\n\n        while (++iterIndex < iterLength) {\n          var data = iteratees[iterIndex],\n              iteratee = data.iteratee,\n              type = data.type,\n              computed = iteratee(value);\n\n          if (type == LAZY_MAP_FLAG) {\n            value = computed;\n          } else if (!computed) {\n            if (type == LAZY_FILTER_FLAG) {\n              continue outer;\n            } else {\n              break outer;\n            }\n          }\n        }\n        result[resIndex++] = value;\n      }\n      return result;\n    }\n\n    // Ensure `LazyWrapper` is an instance of `baseLodash`.\n    LazyWrapper.prototype = baseCreate(baseLodash.prototype);\n    LazyWrapper.prototype.constructor = LazyWrapper;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a hash object.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function Hash(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the hash.\n     *\n     * @private\n     * @name clear\n     * @memberOf Hash\n     */\n    function hashClear() {\n      this.__data__ = nativeCreate ? nativeCreate(null) : {};\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the hash.\n     *\n     * @private\n     * @name delete\n     * @memberOf Hash\n     * @param {Object} hash The hash to modify.\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function hashDelete(key) {\n      var result = this.has(key) && delete this.__data__[key];\n      this.size -= result ? 1 : 0;\n      return result;\n    }\n\n    /**\n     * Gets the hash value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf Hash\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function hashGet(key) {\n      var data = this.__data__;\n      if (nativeCreate) {\n        var result = data[key];\n        return result === HASH_UNDEFINED ? undefined : result;\n      }\n      return hasOwnProperty.call(data, key) ? data[key] : undefined;\n    }\n\n    /**\n     * Checks if a hash value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf Hash\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function hashHas(key) {\n      var data = this.__data__;\n      return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n    }\n\n    /**\n     * Sets the hash `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf Hash\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the hash instance.\n     */\n    function hashSet(key, value) {\n      var data = this.__data__;\n      this.size += this.has(key) ? 0 : 1;\n      data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n      return this;\n    }\n\n    // Add methods to `Hash`.\n    Hash.prototype.clear = hashClear;\n    Hash.prototype['delete'] = hashDelete;\n    Hash.prototype.get = hashGet;\n    Hash.prototype.has = hashHas;\n    Hash.prototype.set = hashSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an list cache object.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function ListCache(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the list cache.\n     *\n     * @private\n     * @name clear\n     * @memberOf ListCache\n     */\n    function listCacheClear() {\n      this.__data__ = [];\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the list cache.\n     *\n     * @private\n     * @name delete\n     * @memberOf ListCache\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function listCacheDelete(key) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      if (index < 0) {\n        return false;\n      }\n      var lastIndex = data.length - 1;\n      if (index == lastIndex) {\n        data.pop();\n      } else {\n        splice.call(data, index, 1);\n      }\n      --this.size;\n      return true;\n    }\n\n    /**\n     * Gets the list cache value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf ListCache\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function listCacheGet(key) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      return index < 0 ? undefined : data[index][1];\n    }\n\n    /**\n     * Checks if a list cache value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf ListCache\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function listCacheHas(key) {\n      return assocIndexOf(this.__data__, key) > -1;\n    }\n\n    /**\n     * Sets the list cache `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf ListCache\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the list cache instance.\n     */\n    function listCacheSet(key, value) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      if (index < 0) {\n        ++this.size;\n        data.push([key, value]);\n      } else {\n        data[index][1] = value;\n      }\n      return this;\n    }\n\n    // Add methods to `ListCache`.\n    ListCache.prototype.clear = listCacheClear;\n    ListCache.prototype['delete'] = listCacheDelete;\n    ListCache.prototype.get = listCacheGet;\n    ListCache.prototype.has = listCacheHas;\n    ListCache.prototype.set = listCacheSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a map cache object to store key-value pairs.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function MapCache(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the map.\n     *\n     * @private\n     * @name clear\n     * @memberOf MapCache\n     */\n    function mapCacheClear() {\n      this.size = 0;\n      this.__data__ = {\n        'hash': new Hash,\n        'map': new (Map || ListCache),\n        'string': new Hash\n      };\n    }\n\n    /**\n     * Removes `key` and its value from the map.\n     *\n     * @private\n     * @name delete\n     * @memberOf MapCache\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function mapCacheDelete(key) {\n      var result = getMapData(this, key)['delete'](key);\n      this.size -= result ? 1 : 0;\n      return result;\n    }\n\n    /**\n     * Gets the map value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf MapCache\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function mapCacheGet(key) {\n      return getMapData(this, key).get(key);\n    }\n\n    /**\n     * Checks if a map value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf MapCache\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function mapCacheHas(key) {\n      return getMapData(this, key).has(key);\n    }\n\n    /**\n     * Sets the map `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf MapCache\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the map cache instance.\n     */\n    function mapCacheSet(key, value) {\n      var data = getMapData(this, key),\n          size = data.size;\n\n      data.set(key, value);\n      this.size += data.size == size ? 0 : 1;\n      return this;\n    }\n\n    // Add methods to `MapCache`.\n    MapCache.prototype.clear = mapCacheClear;\n    MapCache.prototype['delete'] = mapCacheDelete;\n    MapCache.prototype.get = mapCacheGet;\n    MapCache.prototype.has = mapCacheHas;\n    MapCache.prototype.set = mapCacheSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     *\n     * Creates an array cache object to store unique values.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [values] The values to cache.\n     */\n    function SetCache(values) {\n      var index = -1,\n          length = values == null ? 0 : values.length;\n\n      this.__data__ = new MapCache;\n      while (++index < length) {\n        this.add(values[index]);\n      }\n    }\n\n    /**\n     * Adds `value` to the array cache.\n     *\n     * @private\n     * @name add\n     * @memberOf SetCache\n     * @alias push\n     * @param {*} value The value to cache.\n     * @returns {Object} Returns the cache instance.\n     */\n    function setCacheAdd(value) {\n      this.__data__.set(value, HASH_UNDEFINED);\n      return this;\n    }\n\n    /**\n     * Checks if `value` is in the array cache.\n     *\n     * @private\n     * @name has\n     * @memberOf SetCache\n     * @param {*} value The value to search for.\n     * @returns {number} Returns `true` if `value` is found, else `false`.\n     */\n    function setCacheHas(value) {\n      return this.__data__.has(value);\n    }\n\n    // Add methods to `SetCache`.\n    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\n    SetCache.prototype.has = setCacheHas;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a stack cache object to store key-value pairs.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function Stack(entries) {\n      var data = this.__data__ = new ListCache(entries);\n      this.size = data.size;\n    }\n\n    /**\n     * Removes all key-value entries from the stack.\n     *\n     * @private\n     * @name clear\n     * @memberOf Stack\n     */\n    function stackClear() {\n      this.__data__ = new ListCache;\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the stack.\n     *\n     * @private\n     * @name delete\n     * @memberOf Stack\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function stackDelete(key) {\n      var data = this.__data__,\n          result = data['delete'](key);\n\n      this.size = data.size;\n      return result;\n    }\n\n    /**\n     * Gets the stack value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf Stack\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function stackGet(key) {\n      return this.__data__.get(key);\n    }\n\n    /**\n     * Checks if a stack value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf Stack\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function stackHas(key) {\n      return this.__data__.has(key);\n    }\n\n    /**\n     * Sets the stack `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf Stack\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the stack cache instance.\n     */\n    function stackSet(key, value) {\n      var data = this.__data__;\n      if (data instanceof ListCache) {\n        var pairs = data.__data__;\n        if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n          pairs.push([key, value]);\n          this.size = ++data.size;\n          return this;\n        }\n        data = this.__data__ = new MapCache(pairs);\n      }\n      data.set(key, value);\n      this.size = data.size;\n      return this;\n    }\n\n    // Add methods to `Stack`.\n    Stack.prototype.clear = stackClear;\n    Stack.prototype['delete'] = stackDelete;\n    Stack.prototype.get = stackGet;\n    Stack.prototype.has = stackHas;\n    Stack.prototype.set = stackSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an array of the enumerable property names of the array-like `value`.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @param {boolean} inherited Specify returning inherited property names.\n     * @returns {Array} Returns the array of property names.\n     */\n    function arrayLikeKeys(value, inherited) {\n      var isArr = isArray(value),\n          isArg = !isArr && isArguments(value),\n          isBuff = !isArr && !isArg && isBuffer(value),\n          isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n          skipIndexes = isArr || isArg || isBuff || isType,\n          result = skipIndexes ? baseTimes(value.length, String) : [],\n          length = result.length;\n\n      for (var key in value) {\n        if ((inherited || hasOwnProperty.call(value, key)) &&\n            !(skipIndexes && (\n               // Safari 9 has enumerable `arguments.length` in strict mode.\n               key == 'length' ||\n               // Node.js 0.10 has enumerable non-index properties on buffers.\n               (isBuff && (key == 'offset' || key == 'parent')) ||\n               // PhantomJS 2 has enumerable non-index properties on typed arrays.\n               (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n               // Skip index properties.\n               isIndex(key, length)\n            ))) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `_.sample` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to sample.\n     * @returns {*} Returns the random element.\n     */\n    function arraySample(array) {\n      var length = array.length;\n      return length ? array[baseRandom(0, length - 1)] : undefined;\n    }\n\n    /**\n     * A specialized version of `_.sampleSize` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to sample.\n     * @param {number} n The number of elements to sample.\n     * @returns {Array} Returns the random elements.\n     */\n    function arraySampleSize(array, n) {\n      return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));\n    }\n\n    /**\n     * A specialized version of `_.shuffle` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     */\n    function arrayShuffle(array) {\n      return shuffleSelf(copyArray(array));\n    }\n\n    /**\n     * This function is like `assignValue` except that it doesn't assign\n     * `undefined` values.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {string} key The key of the property to assign.\n     * @param {*} value The value to assign.\n     */\n    function assignMergeValue(object, key, value) {\n      if ((value !== undefined && !eq(object[key], value)) ||\n          (value === undefined && !(key in object))) {\n        baseAssignValue(object, key, value);\n      }\n    }\n\n    /**\n     * Assigns `value` to `key` of `object` if the existing value is not equivalent\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {string} key The key of the property to assign.\n     * @param {*} value The value to assign.\n     */\n    function assignValue(object, key, value) {\n      var objValue = object[key];\n      if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n          (value === undefined && !(key in object))) {\n        baseAssignValue(object, key, value);\n      }\n    }\n\n    /**\n     * Gets the index at which the `key` is found in `array` of key-value pairs.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {*} key The key to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     */\n    function assocIndexOf(array, key) {\n      var length = array.length;\n      while (length--) {\n        if (eq(array[length][0], key)) {\n          return length;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * Aggregates elements of `collection` on `accumulator` with keys transformed\n     * by `iteratee` and values set by `setter`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} setter The function to set `accumulator` values.\n     * @param {Function} iteratee The iteratee to transform keys.\n     * @param {Object} accumulator The initial aggregated object.\n     * @returns {Function} Returns `accumulator`.\n     */\n    function baseAggregator(collection, setter, iteratee, accumulator) {\n      baseEach(collection, function(value, key, collection) {\n        setter(accumulator, value, iteratee(value), collection);\n      });\n      return accumulator;\n    }\n\n    /**\n     * The base implementation of `_.assign` without support for multiple sources\n     * or `customizer` functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @returns {Object} Returns `object`.\n     */\n    function baseAssign(object, source) {\n      return object && copyObject(source, keys(source), object);\n    }\n\n    /**\n     * The base implementation of `_.assignIn` without support for multiple sources\n     * or `customizer` functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @returns {Object} Returns `object`.\n     */\n    function baseAssignIn(object, source) {\n      return object && copyObject(source, keysIn(source), object);\n    }\n\n    /**\n     * The base implementation of `assignValue` and `assignMergeValue` without\n     * value checks.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {string} key The key of the property to assign.\n     * @param {*} value The value to assign.\n     */\n    function baseAssignValue(object, key, value) {\n      if (key == '__proto__' && defineProperty) {\n        defineProperty(object, key, {\n          'configurable': true,\n          'enumerable': true,\n          'value': value,\n          'writable': true\n        });\n      } else {\n        object[key] = value;\n      }\n    }\n\n    /**\n     * The base implementation of `_.at` without support for individual paths.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {string[]} paths The property paths to pick.\n     * @returns {Array} Returns the picked elements.\n     */\n    function baseAt(object, paths) {\n      var index = -1,\n          length = paths.length,\n          result = Array(length),\n          skip = object == null;\n\n      while (++index < length) {\n        result[index] = skip ? undefined : get(object, paths[index]);\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.clamp` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {number} number The number to clamp.\n     * @param {number} [lower] The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the clamped number.\n     */\n    function baseClamp(number, lower, upper) {\n      if (number === number) {\n        if (upper !== undefined) {\n          number = number <= upper ? number : upper;\n        }\n        if (lower !== undefined) {\n          number = number >= lower ? number : lower;\n        }\n      }\n      return number;\n    }\n\n    /**\n     * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n     * traversed objects.\n     *\n     * @private\n     * @param {*} value The value to clone.\n     * @param {boolean} bitmask The bitmask flags.\n     *  1 - Deep clone\n     *  2 - Flatten inherited properties\n     *  4 - Clone symbols\n     * @param {Function} [customizer] The function to customize cloning.\n     * @param {string} [key] The key of `value`.\n     * @param {Object} [object] The parent object of `value`.\n     * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n     * @returns {*} Returns the cloned value.\n     */\n    function baseClone(value, bitmask, customizer, key, object, stack) {\n      var result,\n          isDeep = bitmask & CLONE_DEEP_FLAG,\n          isFlat = bitmask & CLONE_FLAT_FLAG,\n          isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n      if (customizer) {\n        result = object ? customizer(value, key, object, stack) : customizer(value);\n      }\n      if (result !== undefined) {\n        return result;\n      }\n      if (!isObject(value)) {\n        return value;\n      }\n      var isArr = isArray(value);\n      if (isArr) {\n        result = initCloneArray(value);\n        if (!isDeep) {\n          return copyArray(value, result);\n        }\n      } else {\n        var tag = getTag(value),\n            isFunc = tag == funcTag || tag == genTag;\n\n        if (isBuffer(value)) {\n          return cloneBuffer(value, isDeep);\n        }\n        if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n          result = (isFlat || isFunc) ? {} : initCloneObject(value);\n          if (!isDeep) {\n            return isFlat\n              ? copySymbolsIn(value, baseAssignIn(result, value))\n              : copySymbols(value, baseAssign(result, value));\n          }\n        } else {\n          if (!cloneableTags[tag]) {\n            return object ? value : {};\n          }\n          result = initCloneByTag(value, tag, baseClone, isDeep);\n        }\n      }\n      // Check for circular references and return its corresponding clone.\n      stack || (stack = new Stack);\n      var stacked = stack.get(value);\n      if (stacked) {\n        return stacked;\n      }\n      stack.set(value, result);\n\n      var keysFunc = isFull\n        ? (isFlat ? getAllKeysIn : getAllKeys)\n        : (isFlat ? keysIn : keys);\n\n      var props = isArr ? undefined : keysFunc(value);\n      arrayEach(props || value, function(subValue, key) {\n        if (props) {\n          key = subValue;\n          subValue = value[key];\n        }\n        // Recursively populate clone (susceptible to call stack limits).\n        assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.conforms` which doesn't clone `source`.\n     *\n     * @private\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseConforms(source) {\n      var props = keys(source);\n      return function(object) {\n        return baseConformsTo(object, source, props);\n      };\n    }\n\n    /**\n     * The base implementation of `_.conformsTo` which accepts `props` to check.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n     */\n    function baseConformsTo(object, source, props) {\n      var length = props.length;\n      if (object == null) {\n        return !length;\n      }\n      object = Object(object);\n      while (length--) {\n        var key = props[length],\n            predicate = source[key],\n            value = object[key];\n\n        if ((value === undefined && !(key in object)) || !predicate(value)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * The base implementation of `_.delay` and `_.defer` which accepts `args`\n     * to provide to `func`.\n     *\n     * @private\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @param {Array} args The arguments to provide to `func`.\n     * @returns {number|Object} Returns the timer id or timeout object.\n     */\n    function baseDelay(func, wait, args) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return setTimeout(function() { func.apply(undefined, args); }, wait);\n    }\n\n    /**\n     * The base implementation of methods like `_.difference` without support\n     * for excluding multiple arrays or iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Array} values The values to exclude.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     */\n    function baseDifference(array, values, iteratee, comparator) {\n      var index = -1,\n          includes = arrayIncludes,\n          isCommon = true,\n          length = array.length,\n          result = [],\n          valuesLength = values.length;\n\n      if (!length) {\n        return result;\n      }\n      if (iteratee) {\n        values = arrayMap(values, baseUnary(iteratee));\n      }\n      if (comparator) {\n        includes = arrayIncludesWith;\n        isCommon = false;\n      }\n      else if (values.length >= LARGE_ARRAY_SIZE) {\n        includes = cacheHas;\n        isCommon = false;\n        values = new SetCache(values);\n      }\n      outer:\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee == null ? value : iteratee(value);\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (isCommon && computed === computed) {\n          var valuesIndex = valuesLength;\n          while (valuesIndex--) {\n            if (values[valuesIndex] === computed) {\n              continue outer;\n            }\n          }\n          result.push(value);\n        }\n        else if (!includes(values, computed, comparator)) {\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.forEach` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     */\n    var baseEach = createBaseEach(baseForOwn);\n\n    /**\n     * The base implementation of `_.forEachRight` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     */\n    var baseEachRight = createBaseEach(baseForOwnRight, true);\n\n    /**\n     * The base implementation of `_.every` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`\n     */\n    function baseEvery(collection, predicate) {\n      var result = true;\n      baseEach(collection, function(value, index, collection) {\n        result = !!predicate(value, index, collection);\n        return result;\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of methods like `_.max` and `_.min` which accepts a\n     * `comparator` to determine the extremum value.\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} iteratee The iteratee invoked per iteration.\n     * @param {Function} comparator The comparator used to compare values.\n     * @returns {*} Returns the extremum value.\n     */\n    function baseExtremum(array, iteratee, comparator) {\n      var index = -1,\n          length = array.length;\n\n      while (++index < length) {\n        var value = array[index],\n            current = iteratee(value);\n\n        if (current != null && (computed === undefined\n              ? (current === current && !isSymbol(current))\n              : comparator(current, computed)\n            )) {\n          var computed = current,\n              result = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.fill` without an iteratee call guard.\n     *\n     * @private\n     * @param {Array} array The array to fill.\n     * @param {*} value The value to fill `array` with.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns `array`.\n     */\n    function baseFill(array, value, start, end) {\n      var length = array.length;\n\n      start = toInteger(start);\n      if (start < 0) {\n        start = -start > length ? 0 : (length + start);\n      }\n      end = (end === undefined || end > length) ? length : toInteger(end);\n      if (end < 0) {\n        end += length;\n      }\n      end = start > end ? 0 : toLength(end);\n      while (start < end) {\n        array[start++] = value;\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.filter` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     */\n    function baseFilter(collection, predicate) {\n      var result = [];\n      baseEach(collection, function(value, index, collection) {\n        if (predicate(value, index, collection)) {\n          result.push(value);\n        }\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.flatten` with support for restricting flattening.\n     *\n     * @private\n     * @param {Array} array The array to flatten.\n     * @param {number} depth The maximum recursion depth.\n     * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n     * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n     * @param {Array} [result=[]] The initial result value.\n     * @returns {Array} Returns the new flattened array.\n     */\n    function baseFlatten(array, depth, predicate, isStrict, result) {\n      var index = -1,\n          length = array.length;\n\n      predicate || (predicate = isFlattenable);\n      result || (result = []);\n\n      while (++index < length) {\n        var value = array[index];\n        if (depth > 0 && predicate(value)) {\n          if (depth > 1) {\n            // Recursively flatten arrays (susceptible to call stack limits).\n            baseFlatten(value, depth - 1, predicate, isStrict, result);\n          } else {\n            arrayPush(result, value);\n          }\n        } else if (!isStrict) {\n          result[result.length] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `baseForOwn` which iterates over `object`\n     * properties returned by `keysFunc` and invokes `iteratee` for each property.\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @returns {Object} Returns `object`.\n     */\n    var baseFor = createBaseFor();\n\n    /**\n     * This function is like `baseFor` except that it iterates over properties\n     * in the opposite order.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @returns {Object} Returns `object`.\n     */\n    var baseForRight = createBaseFor(true);\n\n    /**\n     * The base implementation of `_.forOwn` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForOwn(object, iteratee) {\n      return object && baseFor(object, iteratee, keys);\n    }\n\n    /**\n     * The base implementation of `_.forOwnRight` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForOwnRight(object, iteratee) {\n      return object && baseForRight(object, iteratee, keys);\n    }\n\n    /**\n     * The base implementation of `_.functions` which creates an array of\n     * `object` function property names filtered from `props`.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Array} props The property names to filter.\n     * @returns {Array} Returns the function names.\n     */\n    function baseFunctions(object, props) {\n      return arrayFilter(props, function(key) {\n        return isFunction(object[key]);\n      });\n    }\n\n    /**\n     * The base implementation of `_.get` without support for default values.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to get.\n     * @returns {*} Returns the resolved value.\n     */\n    function baseGet(object, path) {\n      path = castPath(path, object);\n\n      var index = 0,\n          length = path.length;\n\n      while (object != null && index < length) {\n        object = object[toKey(path[index++])];\n      }\n      return (index && index == length) ? object : undefined;\n    }\n\n    /**\n     * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n     * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n     * symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @param {Function} symbolsFunc The function to get the symbols of `object`.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function baseGetAllKeys(object, keysFunc, symbolsFunc) {\n      var result = keysFunc(object);\n      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n    }\n\n    /**\n     * The base implementation of `getTag` without fallbacks for buggy environments.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the `toStringTag`.\n     */\n    function baseGetTag(value) {\n      if (value == null) {\n        return value === undefined ? undefinedTag : nullTag;\n      }\n      return (symToStringTag && symToStringTag in Object(value))\n        ? getRawTag(value)\n        : objectToString(value);\n    }\n\n    /**\n     * The base implementation of `_.gt` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than `other`,\n     *  else `false`.\n     */\n    function baseGt(value, other) {\n      return value > other;\n    }\n\n    /**\n     * The base implementation of `_.has` without support for deep paths.\n     *\n     * @private\n     * @param {Object} [object] The object to query.\n     * @param {Array|string} key The key to check.\n     * @returns {boolean} Returns `true` if `key` exists, else `false`.\n     */\n    function baseHas(object, key) {\n      return object != null && hasOwnProperty.call(object, key);\n    }\n\n    /**\n     * The base implementation of `_.hasIn` without support for deep paths.\n     *\n     * @private\n     * @param {Object} [object] The object to query.\n     * @param {Array|string} key The key to check.\n     * @returns {boolean} Returns `true` if `key` exists, else `false`.\n     */\n    function baseHasIn(object, key) {\n      return object != null && key in Object(object);\n    }\n\n    /**\n     * The base implementation of `_.inRange` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {number} number The number to check.\n     * @param {number} start The start of the range.\n     * @param {number} end The end of the range.\n     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n     */\n    function baseInRange(number, start, end) {\n      return number >= nativeMin(start, end) && number < nativeMax(start, end);\n    }\n\n    /**\n     * The base implementation of methods like `_.intersection`, without support\n     * for iteratee shorthands, that accepts an array of arrays to inspect.\n     *\n     * @private\n     * @param {Array} arrays The arrays to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of shared values.\n     */\n    function baseIntersection(arrays, iteratee, comparator) {\n      var includes = comparator ? arrayIncludesWith : arrayIncludes,\n          length = arrays[0].length,\n          othLength = arrays.length,\n          othIndex = othLength,\n          caches = Array(othLength),\n          maxLength = Infinity,\n          result = [];\n\n      while (othIndex--) {\n        var array = arrays[othIndex];\n        if (othIndex && iteratee) {\n          array = arrayMap(array, baseUnary(iteratee));\n        }\n        maxLength = nativeMin(array.length, maxLength);\n        caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))\n          ? new SetCache(othIndex && array)\n          : undefined;\n      }\n      array = arrays[0];\n\n      var index = -1,\n          seen = caches[0];\n\n      outer:\n      while (++index < length && result.length < maxLength) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (!(seen\n              ? cacheHas(seen, computed)\n              : includes(result, computed, comparator)\n            )) {\n          othIndex = othLength;\n          while (--othIndex) {\n            var cache = caches[othIndex];\n            if (!(cache\n                  ? cacheHas(cache, computed)\n                  : includes(arrays[othIndex], computed, comparator))\n                ) {\n              continue outer;\n            }\n          }\n          if (seen) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.invert` and `_.invertBy` which inverts\n     * `object` with values transformed by `iteratee` and set by `setter`.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} setter The function to set `accumulator` values.\n     * @param {Function} iteratee The iteratee to transform values.\n     * @param {Object} accumulator The initial inverted object.\n     * @returns {Function} Returns `accumulator`.\n     */\n    function baseInverter(object, setter, iteratee, accumulator) {\n      baseForOwn(object, function(value, key, object) {\n        setter(accumulator, iteratee(value), key, object);\n      });\n      return accumulator;\n    }\n\n    /**\n     * The base implementation of `_.invoke` without support for individual\n     * method arguments.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {Array} args The arguments to invoke the method with.\n     * @returns {*} Returns the result of the invoked method.\n     */\n    function baseInvoke(object, path, args) {\n      path = castPath(path, object);\n      object = parent(object, path);\n      var func = object == null ? object : object[toKey(last(path))];\n      return func == null ? undefined : apply(func, object, args);\n    }\n\n    /**\n     * The base implementation of `_.isArguments`.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n     */\n    function baseIsArguments(value) {\n      return isObjectLike(value) && baseGetTag(value) == argsTag;\n    }\n\n    /**\n     * The base implementation of `_.isArrayBuffer` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n     */\n    function baseIsArrayBuffer(value) {\n      return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;\n    }\n\n    /**\n     * The base implementation of `_.isDate` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n     */\n    function baseIsDate(value) {\n      return isObjectLike(value) && baseGetTag(value) == dateTag;\n    }\n\n    /**\n     * The base implementation of `_.isEqual` which supports partial comparisons\n     * and tracks traversed objects.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @param {boolean} bitmask The bitmask flags.\n     *  1 - Unordered comparison\n     *  2 - Partial comparison\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     */\n    function baseIsEqual(value, other, bitmask, customizer, stack) {\n      if (value === other) {\n        return true;\n      }\n      if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n        return value !== value && other !== other;\n      }\n      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n    }\n\n    /**\n     * A specialized version of `baseIsEqual` for arrays and objects which performs\n     * deep comparisons and tracks traversed objects enabling objects with circular\n     * references to be compared.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n      var objIsArr = isArray(object),\n          othIsArr = isArray(other),\n          objTag = objIsArr ? arrayTag : getTag(object),\n          othTag = othIsArr ? arrayTag : getTag(other);\n\n      objTag = objTag == argsTag ? objectTag : objTag;\n      othTag = othTag == argsTag ? objectTag : othTag;\n\n      var objIsObj = objTag == objectTag,\n          othIsObj = othTag == objectTag,\n          isSameTag = objTag == othTag;\n\n      if (isSameTag && isBuffer(object)) {\n        if (!isBuffer(other)) {\n          return false;\n        }\n        objIsArr = true;\n        objIsObj = false;\n      }\n      if (isSameTag && !objIsObj) {\n        stack || (stack = new Stack);\n        return (objIsArr || isTypedArray(object))\n          ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n          : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n      }\n      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n        var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n            othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n        if (objIsWrapped || othIsWrapped) {\n          var objUnwrapped = objIsWrapped ? object.value() : object,\n              othUnwrapped = othIsWrapped ? other.value() : other;\n\n          stack || (stack = new Stack);\n          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n        }\n      }\n      if (!isSameTag) {\n        return false;\n      }\n      stack || (stack = new Stack);\n      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n    }\n\n    /**\n     * The base implementation of `_.isMap` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n     */\n    function baseIsMap(value) {\n      return isObjectLike(value) && getTag(value) == mapTag;\n    }\n\n    /**\n     * The base implementation of `_.isMatch` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @param {Array} matchData The property names, values, and compare flags to match.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     */\n    function baseIsMatch(object, source, matchData, customizer) {\n      var index = matchData.length,\n          length = index,\n          noCustomizer = !customizer;\n\n      if (object == null) {\n        return !length;\n      }\n      object = Object(object);\n      while (index--) {\n        var data = matchData[index];\n        if ((noCustomizer && data[2])\n              ? data[1] !== object[data[0]]\n              : !(data[0] in object)\n            ) {\n          return false;\n        }\n      }\n      while (++index < length) {\n        data = matchData[index];\n        var key = data[0],\n            objValue = object[key],\n            srcValue = data[1];\n\n        if (noCustomizer && data[2]) {\n          if (objValue === undefined && !(key in object)) {\n            return false;\n          }\n        } else {\n          var stack = new Stack;\n          if (customizer) {\n            var result = customizer(objValue, srcValue, key, object, source, stack);\n          }\n          if (!(result === undefined\n                ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)\n                : result\n              )) {\n            return false;\n          }\n        }\n      }\n      return true;\n    }\n\n    /**\n     * The base implementation of `_.isNative` without bad shim checks.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a native function,\n     *  else `false`.\n     */\n    function baseIsNative(value) {\n      if (!isObject(value) || isMasked(value)) {\n        return false;\n      }\n      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n      return pattern.test(toSource(value));\n    }\n\n    /**\n     * The base implementation of `_.isRegExp` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n     */\n    function baseIsRegExp(value) {\n      return isObjectLike(value) && baseGetTag(value) == regexpTag;\n    }\n\n    /**\n     * The base implementation of `_.isSet` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n     */\n    function baseIsSet(value) {\n      return isObjectLike(value) && getTag(value) == setTag;\n    }\n\n    /**\n     * The base implementation of `_.isTypedArray` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n     */\n    function baseIsTypedArray(value) {\n      return isObjectLike(value) &&\n        isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n    }\n\n    /**\n     * The base implementation of `_.iteratee`.\n     *\n     * @private\n     * @param {*} [value=_.identity] The value to convert to an iteratee.\n     * @returns {Function} Returns the iteratee.\n     */\n    function baseIteratee(value) {\n      // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.\n      // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.\n      if (typeof value == 'function') {\n        return value;\n      }\n      if (value == null) {\n        return identity;\n      }\n      if (typeof value == 'object') {\n        return isArray(value)\n          ? baseMatchesProperty(value[0], value[1])\n          : baseMatches(value);\n      }\n      return property(value);\n    }\n\n    /**\n     * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function baseKeys(object) {\n      if (!isPrototype(object)) {\n        return nativeKeys(object);\n      }\n      var result = [];\n      for (var key in Object(object)) {\n        if (hasOwnProperty.call(object, key) && key != 'constructor') {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function baseKeysIn(object) {\n      if (!isObject(object)) {\n        return nativeKeysIn(object);\n      }\n      var isProto = isPrototype(object),\n          result = [];\n\n      for (var key in object) {\n        if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.lt` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than `other`,\n     *  else `false`.\n     */\n    function baseLt(value, other) {\n      return value < other;\n    }\n\n    /**\n     * The base implementation of `_.map` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array} Returns the new mapped array.\n     */\n    function baseMap(collection, iteratee) {\n      var index = -1,\n          result = isArrayLike(collection) ? Array(collection.length) : [];\n\n      baseEach(collection, function(value, key, collection) {\n        result[++index] = iteratee(value, key, collection);\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.matches` which doesn't clone `source`.\n     *\n     * @private\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseMatches(source) {\n      var matchData = getMatchData(source);\n      if (matchData.length == 1 && matchData[0][2]) {\n        return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n      }\n      return function(object) {\n        return object === source || baseIsMatch(object, source, matchData);\n      };\n    }\n\n    /**\n     * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.\n     *\n     * @private\n     * @param {string} path The path of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseMatchesProperty(path, srcValue) {\n      if (isKey(path) && isStrictComparable(srcValue)) {\n        return matchesStrictComparable(toKey(path), srcValue);\n      }\n      return function(object) {\n        var objValue = get(object, path);\n        return (objValue === undefined && objValue === srcValue)\n          ? hasIn(object, path)\n          : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n      };\n    }\n\n    /**\n     * The base implementation of `_.merge` without support for multiple sources.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {number} srcIndex The index of `source`.\n     * @param {Function} [customizer] The function to customize merged values.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     */\n    function baseMerge(object, source, srcIndex, customizer, stack) {\n      if (object === source) {\n        return;\n      }\n      baseFor(source, function(srcValue, key) {\n        if (isObject(srcValue)) {\n          stack || (stack = new Stack);\n          baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n        }\n        else {\n          var newValue = customizer\n            ? customizer(object[key], srcValue, (key + ''), object, source, stack)\n            : undefined;\n\n          if (newValue === undefined) {\n            newValue = srcValue;\n          }\n          assignMergeValue(object, key, newValue);\n        }\n      }, keysIn);\n    }\n\n    /**\n     * A specialized version of `baseMerge` for arrays and objects which performs\n     * deep merges and tracks traversed objects enabling objects with circular\n     * references to be merged.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {string} key The key of the value to merge.\n     * @param {number} srcIndex The index of `source`.\n     * @param {Function} mergeFunc The function to merge values.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     */\n    function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n      var objValue = object[key],\n          srcValue = source[key],\n          stacked = stack.get(srcValue);\n\n      if (stacked) {\n        assignMergeValue(object, key, stacked);\n        return;\n      }\n      var newValue = customizer\n        ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      var isCommon = newValue === undefined;\n\n      if (isCommon) {\n        var isArr = isArray(srcValue),\n            isBuff = !isArr && isBuffer(srcValue),\n            isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n        newValue = srcValue;\n        if (isArr || isBuff || isTyped) {\n          if (isArray(objValue)) {\n            newValue = objValue;\n          }\n          else if (isArrayLikeObject(objValue)) {\n            newValue = copyArray(objValue);\n          }\n          else if (isBuff) {\n            isCommon = false;\n            newValue = cloneBuffer(srcValue, true);\n          }\n          else if (isTyped) {\n            isCommon = false;\n            newValue = cloneTypedArray(srcValue, true);\n          }\n          else {\n            newValue = [];\n          }\n        }\n        else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n          newValue = objValue;\n          if (isArguments(objValue)) {\n            newValue = toPlainObject(objValue);\n          }\n          else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {\n            newValue = initCloneObject(srcValue);\n          }\n        }\n        else {\n          isCommon = false;\n        }\n      }\n      if (isCommon) {\n        // Recursively merge objects and arrays (susceptible to call stack limits).\n        stack.set(srcValue, newValue);\n        mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n        stack['delete'](srcValue);\n      }\n      assignMergeValue(object, key, newValue);\n    }\n\n    /**\n     * The base implementation of `_.nth` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {Array} array The array to query.\n     * @param {number} n The index of the element to return.\n     * @returns {*} Returns the nth element of `array`.\n     */\n    function baseNth(array, n) {\n      var length = array.length;\n      if (!length) {\n        return;\n      }\n      n += n < 0 ? length : 0;\n      return isIndex(n, length) ? array[n] : undefined;\n    }\n\n    /**\n     * The base implementation of `_.orderBy` without param guards.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.\n     * @param {string[]} orders The sort orders of `iteratees`.\n     * @returns {Array} Returns the new sorted array.\n     */\n    function baseOrderBy(collection, iteratees, orders) {\n      var index = -1;\n      iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(getIteratee()));\n\n      var result = baseMap(collection, function(value, key, collection) {\n        var criteria = arrayMap(iteratees, function(iteratee) {\n          return iteratee(value);\n        });\n        return { 'criteria': criteria, 'index': ++index, 'value': value };\n      });\n\n      return baseSortBy(result, function(object, other) {\n        return compareMultiple(object, other, orders);\n      });\n    }\n\n    /**\n     * The base implementation of `_.pick` without support for individual\n     * property identifiers.\n     *\n     * @private\n     * @param {Object} object The source object.\n     * @param {string[]} paths The property paths to pick.\n     * @returns {Object} Returns the new object.\n     */\n    function basePick(object, paths) {\n      return basePickBy(object, paths, function(value, path) {\n        return hasIn(object, path);\n      });\n    }\n\n    /**\n     * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The source object.\n     * @param {string[]} paths The property paths to pick.\n     * @param {Function} predicate The function invoked per property.\n     * @returns {Object} Returns the new object.\n     */\n    function basePickBy(object, paths, predicate) {\n      var index = -1,\n          length = paths.length,\n          result = {};\n\n      while (++index < length) {\n        var path = paths[index],\n            value = baseGet(object, path);\n\n        if (predicate(value, path)) {\n          baseSet(result, castPath(path, object), value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseProperty` which supports deep paths.\n     *\n     * @private\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new accessor function.\n     */\n    function basePropertyDeep(path) {\n      return function(object) {\n        return baseGet(object, path);\n      };\n    }\n\n    /**\n     * The base implementation of `_.pullAllBy` without support for iteratee\n     * shorthands.\n     *\n     * @private\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns `array`.\n     */\n    function basePullAll(array, values, iteratee, comparator) {\n      var indexOf = comparator ? baseIndexOfWith : baseIndexOf,\n          index = -1,\n          length = values.length,\n          seen = array;\n\n      if (array === values) {\n        values = copyArray(values);\n      }\n      if (iteratee) {\n        seen = arrayMap(array, baseUnary(iteratee));\n      }\n      while (++index < length) {\n        var fromIndex = 0,\n            value = values[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {\n          if (seen !== array) {\n            splice.call(seen, fromIndex, 1);\n          }\n          splice.call(array, fromIndex, 1);\n        }\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.pullAt` without support for individual\n     * indexes or capturing the removed elements.\n     *\n     * @private\n     * @param {Array} array The array to modify.\n     * @param {number[]} indexes The indexes of elements to remove.\n     * @returns {Array} Returns `array`.\n     */\n    function basePullAt(array, indexes) {\n      var length = array ? indexes.length : 0,\n          lastIndex = length - 1;\n\n      while (length--) {\n        var index = indexes[length];\n        if (length == lastIndex || index !== previous) {\n          var previous = index;\n          if (isIndex(index)) {\n            splice.call(array, index, 1);\n          } else {\n            baseUnset(array, index);\n          }\n        }\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.random` without support for returning\n     * floating-point numbers.\n     *\n     * @private\n     * @param {number} lower The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the random number.\n     */\n    function baseRandom(lower, upper) {\n      return lower + nativeFloor(nativeRandom() * (upper - lower + 1));\n    }\n\n    /**\n     * The base implementation of `_.range` and `_.rangeRight` which doesn't\n     * coerce arguments.\n     *\n     * @private\n     * @param {number} start The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} step The value to increment or decrement by.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Array} Returns the range of numbers.\n     */\n    function baseRange(start, end, step, fromRight) {\n      var index = -1,\n          length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),\n          result = Array(length);\n\n      while (length--) {\n        result[fromRight ? length : ++index] = start;\n        start += step;\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.repeat` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {string} string The string to repeat.\n     * @param {number} n The number of times to repeat the string.\n     * @returns {string} Returns the repeated string.\n     */\n    function baseRepeat(string, n) {\n      var result = '';\n      if (!string || n < 1 || n > MAX_SAFE_INTEGER) {\n        return result;\n      }\n      // Leverage the exponentiation by squaring algorithm for a faster repeat.\n      // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.\n      do {\n        if (n % 2) {\n          result += string;\n        }\n        n = nativeFloor(n / 2);\n        if (n) {\n          string += string;\n        }\n      } while (n);\n\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n     *\n     * @private\n     * @param {Function} func The function to apply a rest parameter to.\n     * @param {number} [start=func.length-1] The start position of the rest parameter.\n     * @returns {Function} Returns the new function.\n     */\n    function baseRest(func, start) {\n      return setToString(overRest(func, start, identity), func + '');\n    }\n\n    /**\n     * The base implementation of `_.sample`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to sample.\n     * @returns {*} Returns the random element.\n     */\n    function baseSample(collection) {\n      return arraySample(values(collection));\n    }\n\n    /**\n     * The base implementation of `_.sampleSize` without param guards.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to sample.\n     * @param {number} n The number of elements to sample.\n     * @returns {Array} Returns the random elements.\n     */\n    function baseSampleSize(collection, n) {\n      var array = values(collection);\n      return shuffleSelf(array, baseClamp(n, 0, array.length));\n    }\n\n    /**\n     * The base implementation of `_.set`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @param {Function} [customizer] The function to customize path creation.\n     * @returns {Object} Returns `object`.\n     */\n    function baseSet(object, path, value, customizer) {\n      if (!isObject(object)) {\n        return object;\n      }\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length,\n          lastIndex = length - 1,\n          nested = object;\n\n      while (nested != null && ++index < length) {\n        var key = toKey(path[index]),\n            newValue = value;\n\n        if (index != lastIndex) {\n          var objValue = nested[key];\n          newValue = customizer ? customizer(objValue, key, nested) : undefined;\n          if (newValue === undefined) {\n            newValue = isObject(objValue)\n              ? objValue\n              : (isIndex(path[index + 1]) ? [] : {});\n          }\n        }\n        assignValue(nested, key, newValue);\n        nested = nested[key];\n      }\n      return object;\n    }\n\n    /**\n     * The base implementation of `setData` without support for hot loop shorting.\n     *\n     * @private\n     * @param {Function} func The function to associate metadata with.\n     * @param {*} data The metadata.\n     * @returns {Function} Returns `func`.\n     */\n    var baseSetData = !metaMap ? identity : function(func, data) {\n      metaMap.set(func, data);\n      return func;\n    };\n\n    /**\n     * The base implementation of `setToString` without support for hot loop shorting.\n     *\n     * @private\n     * @param {Function} func The function to modify.\n     * @param {Function} string The `toString` result.\n     * @returns {Function} Returns `func`.\n     */\n    var baseSetToString = !defineProperty ? identity : function(func, string) {\n      return defineProperty(func, 'toString', {\n        'configurable': true,\n        'enumerable': false,\n        'value': constant(string),\n        'writable': true\n      });\n    };\n\n    /**\n     * The base implementation of `_.shuffle`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     */\n    function baseShuffle(collection) {\n      return shuffleSelf(values(collection));\n    }\n\n    /**\n     * The base implementation of `_.slice` without an iteratee call guard.\n     *\n     * @private\n     * @param {Array} array The array to slice.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function baseSlice(array, start, end) {\n      var index = -1,\n          length = array.length;\n\n      if (start < 0) {\n        start = -start > length ? 0 : (length + start);\n      }\n      end = end > length ? length : end;\n      if (end < 0) {\n        end += length;\n      }\n      length = start > end ? 0 : ((end - start) >>> 0);\n      start >>>= 0;\n\n      var result = Array(length);\n      while (++index < length) {\n        result[index] = array[index + start];\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.some` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     */\n    function baseSome(collection, predicate) {\n      var result;\n\n      baseEach(collection, function(value, index, collection) {\n        result = predicate(value, index, collection);\n        return !result;\n      });\n      return !!result;\n    }\n\n    /**\n     * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which\n     * performs a binary search of `array` to determine the index at which `value`\n     * should be inserted into `array` in order to maintain its sort order.\n     *\n     * @private\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     */\n    function baseSortedIndex(array, value, retHighest) {\n      var low = 0,\n          high = array == null ? low : array.length;\n\n      if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {\n        while (low < high) {\n          var mid = (low + high) >>> 1,\n              computed = array[mid];\n\n          if (computed !== null && !isSymbol(computed) &&\n              (retHighest ? (computed <= value) : (computed < value))) {\n            low = mid + 1;\n          } else {\n            high = mid;\n          }\n        }\n        return high;\n      }\n      return baseSortedIndexBy(array, value, identity, retHighest);\n    }\n\n    /**\n     * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`\n     * which invokes `iteratee` for `value` and each element of `array` to compute\n     * their sort ranking. The iteratee is invoked with one argument; (value).\n     *\n     * @private\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} iteratee The iteratee invoked per element.\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     */\n    function baseSortedIndexBy(array, value, iteratee, retHighest) {\n      value = iteratee(value);\n\n      var low = 0,\n          high = array == null ? 0 : array.length,\n          valIsNaN = value !== value,\n          valIsNull = value === null,\n          valIsSymbol = isSymbol(value),\n          valIsUndefined = value === undefined;\n\n      while (low < high) {\n        var mid = nativeFloor((low + high) / 2),\n            computed = iteratee(array[mid]),\n            othIsDefined = computed !== undefined,\n            othIsNull = computed === null,\n            othIsReflexive = computed === computed,\n            othIsSymbol = isSymbol(computed);\n\n        if (valIsNaN) {\n          var setLow = retHighest || othIsReflexive;\n        } else if (valIsUndefined) {\n          setLow = othIsReflexive && (retHighest || othIsDefined);\n        } else if (valIsNull) {\n          setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);\n        } else if (valIsSymbol) {\n          setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);\n        } else if (othIsNull || othIsSymbol) {\n          setLow = false;\n        } else {\n          setLow = retHighest ? (computed <= value) : (computed < value);\n        }\n        if (setLow) {\n          low = mid + 1;\n        } else {\n          high = mid;\n        }\n      }\n      return nativeMin(high, MAX_ARRAY_INDEX);\n    }\n\n    /**\n     * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without\n     * support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     */\n    function baseSortedUniq(array, iteratee) {\n      var index = -1,\n          length = array.length,\n          resIndex = 0,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        if (!index || !eq(computed, seen)) {\n          var seen = computed;\n          result[resIndex++] = value === 0 ? 0 : value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.toNumber` which doesn't ensure correct\n     * conversions of binary, hexadecimal, or octal string values.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {number} Returns the number.\n     */\n    function baseToNumber(value) {\n      if (typeof value == 'number') {\n        return value;\n      }\n      if (isSymbol(value)) {\n        return NAN;\n      }\n      return +value;\n    }\n\n    /**\n     * The base implementation of `_.toString` which doesn't convert nullish\n     * values to empty strings.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {string} Returns the string.\n     */\n    function baseToString(value) {\n      // Exit early for strings to avoid a performance hit in some environments.\n      if (typeof value == 'string') {\n        return value;\n      }\n      if (isArray(value)) {\n        // Recursively convert values (susceptible to call stack limits).\n        return arrayMap(value, baseToString) + '';\n      }\n      if (isSymbol(value)) {\n        return symbolToString ? symbolToString.call(value) : '';\n      }\n      var result = (value + '');\n      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n    }\n\n    /**\n     * The base implementation of `_.uniqBy` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     */\n    function baseUniq(array, iteratee, comparator) {\n      var index = -1,\n          includes = arrayIncludes,\n          length = array.length,\n          isCommon = true,\n          result = [],\n          seen = result;\n\n      if (comparator) {\n        isCommon = false;\n        includes = arrayIncludesWith;\n      }\n      else if (length >= LARGE_ARRAY_SIZE) {\n        var set = iteratee ? null : createSet(array);\n        if (set) {\n          return setToArray(set);\n        }\n        isCommon = false;\n        includes = cacheHas;\n        seen = new SetCache;\n      }\n      else {\n        seen = iteratee ? [] : result;\n      }\n      outer:\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (isCommon && computed === computed) {\n          var seenIndex = seen.length;\n          while (seenIndex--) {\n            if (seen[seenIndex] === computed) {\n              continue outer;\n            }\n          }\n          if (iteratee) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n        else if (!includes(seen, computed, comparator)) {\n          if (seen !== result) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.unset`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The property path to unset.\n     * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n     */\n    function baseUnset(object, path) {\n      path = castPath(path, object);\n      object = parent(object, path);\n      return object == null || delete object[toKey(last(path))];\n    }\n\n    /**\n     * The base implementation of `_.update`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to update.\n     * @param {Function} updater The function to produce the updated value.\n     * @param {Function} [customizer] The function to customize path creation.\n     * @returns {Object} Returns `object`.\n     */\n    function baseUpdate(object, path, updater, customizer) {\n      return baseSet(object, path, updater(baseGet(object, path)), customizer);\n    }\n\n    /**\n     * The base implementation of methods like `_.dropWhile` and `_.takeWhile`\n     * without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to query.\n     * @param {Function} predicate The function invoked per iteration.\n     * @param {boolean} [isDrop] Specify dropping elements instead of taking them.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function baseWhile(array, predicate, isDrop, fromRight) {\n      var length = array.length,\n          index = fromRight ? length : -1;\n\n      while ((fromRight ? index-- : ++index < length) &&\n        predicate(array[index], index, array)) {}\n\n      return isDrop\n        ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))\n        : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));\n    }\n\n    /**\n     * The base implementation of `wrapperValue` which returns the result of\n     * performing a sequence of actions on the unwrapped `value`, where each\n     * successive action is supplied the return value of the previous.\n     *\n     * @private\n     * @param {*} value The unwrapped value.\n     * @param {Array} actions Actions to perform to resolve the unwrapped value.\n     * @returns {*} Returns the resolved value.\n     */\n    function baseWrapperValue(value, actions) {\n      var result = value;\n      if (result instanceof LazyWrapper) {\n        result = result.value();\n      }\n      return arrayReduce(actions, function(result, action) {\n        return action.func.apply(action.thisArg, arrayPush([result], action.args));\n      }, result);\n    }\n\n    /**\n     * The base implementation of methods like `_.xor`, without support for\n     * iteratee shorthands, that accepts an array of arrays to inspect.\n     *\n     * @private\n     * @param {Array} arrays The arrays to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of values.\n     */\n    function baseXor(arrays, iteratee, comparator) {\n      var length = arrays.length;\n      if (length < 2) {\n        return length ? baseUniq(arrays[0]) : [];\n      }\n      var index = -1,\n          result = Array(length);\n\n      while (++index < length) {\n        var array = arrays[index],\n            othIndex = -1;\n\n        while (++othIndex < length) {\n          if (othIndex != index) {\n            result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);\n          }\n        }\n      }\n      return baseUniq(baseFlatten(result, 1), iteratee, comparator);\n    }\n\n    /**\n     * This base implementation of `_.zipObject` which assigns values using `assignFunc`.\n     *\n     * @private\n     * @param {Array} props The property identifiers.\n     * @param {Array} values The property values.\n     * @param {Function} assignFunc The function to assign values.\n     * @returns {Object} Returns the new object.\n     */\n    function baseZipObject(props, values, assignFunc) {\n      var index = -1,\n          length = props.length,\n          valsLength = values.length,\n          result = {};\n\n      while (++index < length) {\n        var value = index < valsLength ? values[index] : undefined;\n        assignFunc(result, props[index], value);\n      }\n      return result;\n    }\n\n    /**\n     * Casts `value` to an empty array if it's not an array like object.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {Array|Object} Returns the cast array-like object.\n     */\n    function castArrayLikeObject(value) {\n      return isArrayLikeObject(value) ? value : [];\n    }\n\n    /**\n     * Casts `value` to `identity` if it's not a function.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {Function} Returns cast function.\n     */\n    function castFunction(value) {\n      return typeof value == 'function' ? value : identity;\n    }\n\n    /**\n     * Casts `value` to a path array if it's not one.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @param {Object} [object] The object to query keys on.\n     * @returns {Array} Returns the cast property path array.\n     */\n    function castPath(value, object) {\n      if (isArray(value)) {\n        return value;\n      }\n      return isKey(value, object) ? [value] : stringToPath(toString(value));\n    }\n\n    /**\n     * A `baseRest` alias which can be replaced with `identity` by module\n     * replacement plugins.\n     *\n     * @private\n     * @type {Function}\n     * @param {Function} func The function to apply a rest parameter to.\n     * @returns {Function} Returns the new function.\n     */\n    var castRest = baseRest;\n\n    /**\n     * Casts `array` to a slice if it's needed.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {number} start The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the cast slice.\n     */\n    function castSlice(array, start, end) {\n      var length = array.length;\n      end = end === undefined ? length : end;\n      return (!start && end >= length) ? array : baseSlice(array, start, end);\n    }\n\n    /**\n     * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).\n     *\n     * @private\n     * @param {number|Object} id The timer id or timeout object of the timer to clear.\n     */\n    var clearTimeout = ctxClearTimeout || function(id) {\n      return root.clearTimeout(id);\n    };\n\n    /**\n     * Creates a clone of  `buffer`.\n     *\n     * @private\n     * @param {Buffer} buffer The buffer to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Buffer} Returns the cloned buffer.\n     */\n    function cloneBuffer(buffer, isDeep) {\n      if (isDeep) {\n        return buffer.slice();\n      }\n      var length = buffer.length,\n          result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n      buffer.copy(result);\n      return result;\n    }\n\n    /**\n     * Creates a clone of `arrayBuffer`.\n     *\n     * @private\n     * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n     * @returns {ArrayBuffer} Returns the cloned array buffer.\n     */\n    function cloneArrayBuffer(arrayBuffer) {\n      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n      new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n      return result;\n    }\n\n    /**\n     * Creates a clone of `dataView`.\n     *\n     * @private\n     * @param {Object} dataView The data view to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned data view.\n     */\n    function cloneDataView(dataView, isDeep) {\n      var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n      return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n    }\n\n    /**\n     * Creates a clone of `map`.\n     *\n     * @private\n     * @param {Object} map The map to clone.\n     * @param {Function} cloneFunc The function to clone values.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned map.\n     */\n    function cloneMap(map, isDeep, cloneFunc) {\n      var array = isDeep ? cloneFunc(mapToArray(map), CLONE_DEEP_FLAG) : mapToArray(map);\n      return arrayReduce(array, addMapEntry, new map.constructor);\n    }\n\n    /**\n     * Creates a clone of `regexp`.\n     *\n     * @private\n     * @param {Object} regexp The regexp to clone.\n     * @returns {Object} Returns the cloned regexp.\n     */\n    function cloneRegExp(regexp) {\n      var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n      result.lastIndex = regexp.lastIndex;\n      return result;\n    }\n\n    /**\n     * Creates a clone of `set`.\n     *\n     * @private\n     * @param {Object} set The set to clone.\n     * @param {Function} cloneFunc The function to clone values.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned set.\n     */\n    function cloneSet(set, isDeep, cloneFunc) {\n      var array = isDeep ? cloneFunc(setToArray(set), CLONE_DEEP_FLAG) : setToArray(set);\n      return arrayReduce(array, addSetEntry, new set.constructor);\n    }\n\n    /**\n     * Creates a clone of the `symbol` object.\n     *\n     * @private\n     * @param {Object} symbol The symbol object to clone.\n     * @returns {Object} Returns the cloned symbol object.\n     */\n    function cloneSymbol(symbol) {\n      return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n    }\n\n    /**\n     * Creates a clone of `typedArray`.\n     *\n     * @private\n     * @param {Object} typedArray The typed array to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned typed array.\n     */\n    function cloneTypedArray(typedArray, isDeep) {\n      var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n      return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n    }\n\n    /**\n     * Compares values to sort them in ascending order.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {number} Returns the sort order indicator for `value`.\n     */\n    function compareAscending(value, other) {\n      if (value !== other) {\n        var valIsDefined = value !== undefined,\n            valIsNull = value === null,\n            valIsReflexive = value === value,\n            valIsSymbol = isSymbol(value);\n\n        var othIsDefined = other !== undefined,\n            othIsNull = other === null,\n            othIsReflexive = other === other,\n            othIsSymbol = isSymbol(other);\n\n        if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||\n            (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||\n            (valIsNull && othIsDefined && othIsReflexive) ||\n            (!valIsDefined && othIsReflexive) ||\n            !valIsReflexive) {\n          return 1;\n        }\n        if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||\n            (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||\n            (othIsNull && valIsDefined && valIsReflexive) ||\n            (!othIsDefined && valIsReflexive) ||\n            !othIsReflexive) {\n          return -1;\n        }\n      }\n      return 0;\n    }\n\n    /**\n     * Used by `_.orderBy` to compare multiple properties of a value to another\n     * and stable sort them.\n     *\n     * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,\n     * specify an order of \"desc\" for descending or \"asc\" for ascending sort order\n     * of corresponding values.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {boolean[]|string[]} orders The order to sort by for each property.\n     * @returns {number} Returns the sort order indicator for `object`.\n     */\n    function compareMultiple(object, other, orders) {\n      var index = -1,\n          objCriteria = object.criteria,\n          othCriteria = other.criteria,\n          length = objCriteria.length,\n          ordersLength = orders.length;\n\n      while (++index < length) {\n        var result = compareAscending(objCriteria[index], othCriteria[index]);\n        if (result) {\n          if (index >= ordersLength) {\n            return result;\n          }\n          var order = orders[index];\n          return result * (order == 'desc' ? -1 : 1);\n        }\n      }\n      // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications\n      // that causes it, under certain circumstances, to provide the same value for\n      // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247\n      // for more details.\n      //\n      // This also ensures a stable sort in V8 and other engines.\n      // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.\n      return object.index - other.index;\n    }\n\n    /**\n     * Creates an array that is the composition of partially applied arguments,\n     * placeholders, and provided arguments into a single array of arguments.\n     *\n     * @private\n     * @param {Array} args The provided arguments.\n     * @param {Array} partials The arguments to prepend to those provided.\n     * @param {Array} holders The `partials` placeholder indexes.\n     * @params {boolean} [isCurried] Specify composing for a curried function.\n     * @returns {Array} Returns the new array of composed arguments.\n     */\n    function composeArgs(args, partials, holders, isCurried) {\n      var argsIndex = -1,\n          argsLength = args.length,\n          holdersLength = holders.length,\n          leftIndex = -1,\n          leftLength = partials.length,\n          rangeLength = nativeMax(argsLength - holdersLength, 0),\n          result = Array(leftLength + rangeLength),\n          isUncurried = !isCurried;\n\n      while (++leftIndex < leftLength) {\n        result[leftIndex] = partials[leftIndex];\n      }\n      while (++argsIndex < holdersLength) {\n        if (isUncurried || argsIndex < argsLength) {\n          result[holders[argsIndex]] = args[argsIndex];\n        }\n      }\n      while (rangeLength--) {\n        result[leftIndex++] = args[argsIndex++];\n      }\n      return result;\n    }\n\n    /**\n     * This function is like `composeArgs` except that the arguments composition\n     * is tailored for `_.partialRight`.\n     *\n     * @private\n     * @param {Array} args The provided arguments.\n     * @param {Array} partials The arguments to append to those provided.\n     * @param {Array} holders The `partials` placeholder indexes.\n     * @params {boolean} [isCurried] Specify composing for a curried function.\n     * @returns {Array} Returns the new array of composed arguments.\n     */\n    function composeArgsRight(args, partials, holders, isCurried) {\n      var argsIndex = -1,\n          argsLength = args.length,\n          holdersIndex = -1,\n          holdersLength = holders.length,\n          rightIndex = -1,\n          rightLength = partials.length,\n          rangeLength = nativeMax(argsLength - holdersLength, 0),\n          result = Array(rangeLength + rightLength),\n          isUncurried = !isCurried;\n\n      while (++argsIndex < rangeLength) {\n        result[argsIndex] = args[argsIndex];\n      }\n      var offset = argsIndex;\n      while (++rightIndex < rightLength) {\n        result[offset + rightIndex] = partials[rightIndex];\n      }\n      while (++holdersIndex < holdersLength) {\n        if (isUncurried || argsIndex < argsLength) {\n          result[offset + holders[holdersIndex]] = args[argsIndex++];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Copies the values of `source` to `array`.\n     *\n     * @private\n     * @param {Array} source The array to copy values from.\n     * @param {Array} [array=[]] The array to copy values to.\n     * @returns {Array} Returns `array`.\n     */\n    function copyArray(source, array) {\n      var index = -1,\n          length = source.length;\n\n      array || (array = Array(length));\n      while (++index < length) {\n        array[index] = source[index];\n      }\n      return array;\n    }\n\n    /**\n     * Copies properties of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy properties from.\n     * @param {Array} props The property identifiers to copy.\n     * @param {Object} [object={}] The object to copy properties to.\n     * @param {Function} [customizer] The function to customize copied values.\n     * @returns {Object} Returns `object`.\n     */\n    function copyObject(source, props, object, customizer) {\n      var isNew = !object;\n      object || (object = {});\n\n      var index = -1,\n          length = props.length;\n\n      while (++index < length) {\n        var key = props[index];\n\n        var newValue = customizer\n          ? customizer(object[key], source[key], key, object, source)\n          : undefined;\n\n        if (newValue === undefined) {\n          newValue = source[key];\n        }\n        if (isNew) {\n          baseAssignValue(object, key, newValue);\n        } else {\n          assignValue(object, key, newValue);\n        }\n      }\n      return object;\n    }\n\n    /**\n     * Copies own symbols of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy symbols from.\n     * @param {Object} [object={}] The object to copy symbols to.\n     * @returns {Object} Returns `object`.\n     */\n    function copySymbols(source, object) {\n      return copyObject(source, getSymbols(source), object);\n    }\n\n    /**\n     * Copies own and inherited symbols of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy symbols from.\n     * @param {Object} [object={}] The object to copy symbols to.\n     * @returns {Object} Returns `object`.\n     */\n    function copySymbolsIn(source, object) {\n      return copyObject(source, getSymbolsIn(source), object);\n    }\n\n    /**\n     * Creates a function like `_.groupBy`.\n     *\n     * @private\n     * @param {Function} setter The function to set accumulator values.\n     * @param {Function} [initializer] The accumulator object initializer.\n     * @returns {Function} Returns the new aggregator function.\n     */\n    function createAggregator(setter, initializer) {\n      return function(collection, iteratee) {\n        var func = isArray(collection) ? arrayAggregator : baseAggregator,\n            accumulator = initializer ? initializer() : {};\n\n        return func(collection, setter, getIteratee(iteratee, 2), accumulator);\n      };\n    }\n\n    /**\n     * Creates a function like `_.assign`.\n     *\n     * @private\n     * @param {Function} assigner The function to assign values.\n     * @returns {Function} Returns the new assigner function.\n     */\n    function createAssigner(assigner) {\n      return baseRest(function(object, sources) {\n        var index = -1,\n            length = sources.length,\n            customizer = length > 1 ? sources[length - 1] : undefined,\n            guard = length > 2 ? sources[2] : undefined;\n\n        customizer = (assigner.length > 3 && typeof customizer == 'function')\n          ? (length--, customizer)\n          : undefined;\n\n        if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n          customizer = length < 3 ? undefined : customizer;\n          length = 1;\n        }\n        object = Object(object);\n        while (++index < length) {\n          var source = sources[index];\n          if (source) {\n            assigner(object, source, index, customizer);\n          }\n        }\n        return object;\n      });\n    }\n\n    /**\n     * Creates a `baseEach` or `baseEachRight` function.\n     *\n     * @private\n     * @param {Function} eachFunc The function to iterate over a collection.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new base function.\n     */\n    function createBaseEach(eachFunc, fromRight) {\n      return function(collection, iteratee) {\n        if (collection == null) {\n          return collection;\n        }\n        if (!isArrayLike(collection)) {\n          return eachFunc(collection, iteratee);\n        }\n        var length = collection.length,\n            index = fromRight ? length : -1,\n            iterable = Object(collection);\n\n        while ((fromRight ? index-- : ++index < length)) {\n          if (iteratee(iterable[index], index, iterable) === false) {\n            break;\n          }\n        }\n        return collection;\n      };\n    }\n\n    /**\n     * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new base function.\n     */\n    function createBaseFor(fromRight) {\n      return function(object, iteratee, keysFunc) {\n        var index = -1,\n            iterable = Object(object),\n            props = keysFunc(object),\n            length = props.length;\n\n        while (length--) {\n          var key = props[fromRight ? length : ++index];\n          if (iteratee(iterable[key], key, iterable) === false) {\n            break;\n          }\n        }\n        return object;\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with the optional `this`\n     * binding of `thisArg`.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createBind(func, bitmask, thisArg) {\n      var isBind = bitmask & WRAP_BIND_FLAG,\n          Ctor = createCtor(func);\n\n      function wrapper() {\n        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n        return fn.apply(isBind ? thisArg : this, arguments);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a function like `_.lowerFirst`.\n     *\n     * @private\n     * @param {string} methodName The name of the `String` case method to use.\n     * @returns {Function} Returns the new case function.\n     */\n    function createCaseFirst(methodName) {\n      return function(string) {\n        string = toString(string);\n\n        var strSymbols = hasUnicode(string)\n          ? stringToArray(string)\n          : undefined;\n\n        var chr = strSymbols\n          ? strSymbols[0]\n          : string.charAt(0);\n\n        var trailing = strSymbols\n          ? castSlice(strSymbols, 1).join('')\n          : string.slice(1);\n\n        return chr[methodName]() + trailing;\n      };\n    }\n\n    /**\n     * Creates a function like `_.camelCase`.\n     *\n     * @private\n     * @param {Function} callback The function to combine each word.\n     * @returns {Function} Returns the new compounder function.\n     */\n    function createCompounder(callback) {\n      return function(string) {\n        return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');\n      };\n    }\n\n    /**\n     * Creates a function that produces an instance of `Ctor` regardless of\n     * whether it was invoked as part of a `new` expression or by `call` or `apply`.\n     *\n     * @private\n     * @param {Function} Ctor The constructor to wrap.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createCtor(Ctor) {\n      return function() {\n        // Use a `switch` statement to work with class constructors. See\n        // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist\n        // for more details.\n        var args = arguments;\n        switch (args.length) {\n          case 0: return new Ctor;\n          case 1: return new Ctor(args[0]);\n          case 2: return new Ctor(args[0], args[1]);\n          case 3: return new Ctor(args[0], args[1], args[2]);\n          case 4: return new Ctor(args[0], args[1], args[2], args[3]);\n          case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);\n          case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);\n          case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);\n        }\n        var thisBinding = baseCreate(Ctor.prototype),\n            result = Ctor.apply(thisBinding, args);\n\n        // Mimic the constructor's `return` behavior.\n        // See https://es5.github.io/#x13.2.2 for more details.\n        return isObject(result) ? result : thisBinding;\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to enable currying.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {number} arity The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createCurry(func, bitmask, arity) {\n      var Ctor = createCtor(func);\n\n      function wrapper() {\n        var length = arguments.length,\n            args = Array(length),\n            index = length,\n            placeholder = getHolder(wrapper);\n\n        while (index--) {\n          args[index] = arguments[index];\n        }\n        var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)\n          ? []\n          : replaceHolders(args, placeholder);\n\n        length -= holders.length;\n        if (length < arity) {\n          return createRecurry(\n            func, bitmask, createHybrid, wrapper.placeholder, undefined,\n            args, holders, undefined, undefined, arity - length);\n        }\n        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n        return apply(fn, this, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a `_.find` or `_.findLast` function.\n     *\n     * @private\n     * @param {Function} findIndexFunc The function to find the collection index.\n     * @returns {Function} Returns the new find function.\n     */\n    function createFind(findIndexFunc) {\n      return function(collection, predicate, fromIndex) {\n        var iterable = Object(collection);\n        if (!isArrayLike(collection)) {\n          var iteratee = getIteratee(predicate, 3);\n          collection = keys(collection);\n          predicate = function(key) { return iteratee(iterable[key], key, iterable); };\n        }\n        var index = findIndexFunc(collection, predicate, fromIndex);\n        return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;\n      };\n    }\n\n    /**\n     * Creates a `_.flow` or `_.flowRight` function.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new flow function.\n     */\n    function createFlow(fromRight) {\n      return flatRest(function(funcs) {\n        var length = funcs.length,\n            index = length,\n            prereq = LodashWrapper.prototype.thru;\n\n        if (fromRight) {\n          funcs.reverse();\n        }\n        while (index--) {\n          var func = funcs[index];\n          if (typeof func != 'function') {\n            throw new TypeError(FUNC_ERROR_TEXT);\n          }\n          if (prereq && !wrapper && getFuncName(func) == 'wrapper') {\n            var wrapper = new LodashWrapper([], true);\n          }\n        }\n        index = wrapper ? index : length;\n        while (++index < length) {\n          func = funcs[index];\n\n          var funcName = getFuncName(func),\n              data = funcName == 'wrapper' ? getData(func) : undefined;\n\n          if (data && isLaziable(data[0]) &&\n                data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&\n                !data[4].length && data[9] == 1\n              ) {\n            wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);\n          } else {\n            wrapper = (func.length == 1 && isLaziable(func))\n              ? wrapper[funcName]()\n              : wrapper.thru(func);\n          }\n        }\n        return function() {\n          var args = arguments,\n              value = args[0];\n\n          if (wrapper && args.length == 1 && isArray(value)) {\n            return wrapper.plant(value).value();\n          }\n          var index = 0,\n              result = length ? funcs[index].apply(this, args) : value;\n\n          while (++index < length) {\n            result = funcs[index].call(this, result);\n          }\n          return result;\n        };\n      });\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with optional `this`\n     * binding of `thisArg`, partial application, and currying.\n     *\n     * @private\n     * @param {Function|string} func The function or method name to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to prepend to those provided to\n     *  the new function.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [partialsRight] The arguments to append to those provided\n     *  to the new function.\n     * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {\n      var isAry = bitmask & WRAP_ARY_FLAG,\n          isBind = bitmask & WRAP_BIND_FLAG,\n          isBindKey = bitmask & WRAP_BIND_KEY_FLAG,\n          isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),\n          isFlip = bitmask & WRAP_FLIP_FLAG,\n          Ctor = isBindKey ? undefined : createCtor(func);\n\n      function wrapper() {\n        var length = arguments.length,\n            args = Array(length),\n            index = length;\n\n        while (index--) {\n          args[index] = arguments[index];\n        }\n        if (isCurried) {\n          var placeholder = getHolder(wrapper),\n              holdersCount = countHolders(args, placeholder);\n        }\n        if (partials) {\n          args = composeArgs(args, partials, holders, isCurried);\n        }\n        if (partialsRight) {\n          args = composeArgsRight(args, partialsRight, holdersRight, isCurried);\n        }\n        length -= holdersCount;\n        if (isCurried && length < arity) {\n          var newHolders = replaceHolders(args, placeholder);\n          return createRecurry(\n            func, bitmask, createHybrid, wrapper.placeholder, thisArg,\n            args, newHolders, argPos, ary, arity - length\n          );\n        }\n        var thisBinding = isBind ? thisArg : this,\n            fn = isBindKey ? thisBinding[func] : func;\n\n        length = args.length;\n        if (argPos) {\n          args = reorder(args, argPos);\n        } else if (isFlip && length > 1) {\n          args.reverse();\n        }\n        if (isAry && ary < length) {\n          args.length = ary;\n        }\n        if (this && this !== root && this instanceof wrapper) {\n          fn = Ctor || createCtor(fn);\n        }\n        return fn.apply(thisBinding, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a function like `_.invertBy`.\n     *\n     * @private\n     * @param {Function} setter The function to set accumulator values.\n     * @param {Function} toIteratee The function to resolve iteratees.\n     * @returns {Function} Returns the new inverter function.\n     */\n    function createInverter(setter, toIteratee) {\n      return function(object, iteratee) {\n        return baseInverter(object, setter, toIteratee(iteratee), {});\n      };\n    }\n\n    /**\n     * Creates a function that performs a mathematical operation on two values.\n     *\n     * @private\n     * @param {Function} operator The function to perform the operation.\n     * @param {number} [defaultValue] The value used for `undefined` arguments.\n     * @returns {Function} Returns the new mathematical operation function.\n     */\n    function createMathOperation(operator, defaultValue) {\n      return function(value, other) {\n        var result;\n        if (value === undefined && other === undefined) {\n          return defaultValue;\n        }\n        if (value !== undefined) {\n          result = value;\n        }\n        if (other !== undefined) {\n          if (result === undefined) {\n            return other;\n          }\n          if (typeof value == 'string' || typeof other == 'string') {\n            value = baseToString(value);\n            other = baseToString(other);\n          } else {\n            value = baseToNumber(value);\n            other = baseToNumber(other);\n          }\n          result = operator(value, other);\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function like `_.over`.\n     *\n     * @private\n     * @param {Function} arrayFunc The function to iterate over iteratees.\n     * @returns {Function} Returns the new over function.\n     */\n    function createOver(arrayFunc) {\n      return flatRest(function(iteratees) {\n        iteratees = arrayMap(iteratees, baseUnary(getIteratee()));\n        return baseRest(function(args) {\n          var thisArg = this;\n          return arrayFunc(iteratees, function(iteratee) {\n            return apply(iteratee, thisArg, args);\n          });\n        });\n      });\n    }\n\n    /**\n     * Creates the padding for `string` based on `length`. The `chars` string\n     * is truncated if the number of characters exceeds `length`.\n     *\n     * @private\n     * @param {number} length The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padding for `string`.\n     */\n    function createPadding(length, chars) {\n      chars = chars === undefined ? ' ' : baseToString(chars);\n\n      var charsLength = chars.length;\n      if (charsLength < 2) {\n        return charsLength ? baseRepeat(chars, length) : chars;\n      }\n      var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));\n      return hasUnicode(chars)\n        ? castSlice(stringToArray(result), 0, length).join('')\n        : result.slice(0, length);\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with the `this` binding\n     * of `thisArg` and `partials` prepended to the arguments it receives.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {Array} partials The arguments to prepend to those provided to\n     *  the new function.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createPartial(func, bitmask, thisArg, partials) {\n      var isBind = bitmask & WRAP_BIND_FLAG,\n          Ctor = createCtor(func);\n\n      function wrapper() {\n        var argsIndex = -1,\n            argsLength = arguments.length,\n            leftIndex = -1,\n            leftLength = partials.length,\n            args = Array(leftLength + argsLength),\n            fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n\n        while (++leftIndex < leftLength) {\n          args[leftIndex] = partials[leftIndex];\n        }\n        while (argsLength--) {\n          args[leftIndex++] = arguments[++argsIndex];\n        }\n        return apply(fn, isBind ? thisArg : this, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a `_.range` or `_.rangeRight` function.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new range function.\n     */\n    function createRange(fromRight) {\n      return function(start, end, step) {\n        if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {\n          end = step = undefined;\n        }\n        // Ensure the sign of `-0` is preserved.\n        start = toFinite(start);\n        if (end === undefined) {\n          end = start;\n          start = 0;\n        } else {\n          end = toFinite(end);\n        }\n        step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);\n        return baseRange(start, end, step, fromRight);\n      };\n    }\n\n    /**\n     * Creates a function that performs a relational operation on two values.\n     *\n     * @private\n     * @param {Function} operator The function to perform the operation.\n     * @returns {Function} Returns the new relational operation function.\n     */\n    function createRelationalOperation(operator) {\n      return function(value, other) {\n        if (!(typeof value == 'string' && typeof other == 'string')) {\n          value = toNumber(value);\n          other = toNumber(other);\n        }\n        return operator(value, other);\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to continue currying.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {Function} wrapFunc The function to create the `func` wrapper.\n     * @param {*} placeholder The placeholder value.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to prepend to those provided to\n     *  the new function.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {\n      var isCurry = bitmask & WRAP_CURRY_FLAG,\n          newHolders = isCurry ? holders : undefined,\n          newHoldersRight = isCurry ? undefined : holders,\n          newPartials = isCurry ? partials : undefined,\n          newPartialsRight = isCurry ? undefined : partials;\n\n      bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);\n      bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);\n\n      if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {\n        bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);\n      }\n      var newData = [\n        func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,\n        newHoldersRight, argPos, ary, arity\n      ];\n\n      var result = wrapFunc.apply(undefined, newData);\n      if (isLaziable(func)) {\n        setData(result, newData);\n      }\n      result.placeholder = placeholder;\n      return setWrapToString(result, func, bitmask);\n    }\n\n    /**\n     * Creates a function like `_.round`.\n     *\n     * @private\n     * @param {string} methodName The name of the `Math` method to use when rounding.\n     * @returns {Function} Returns the new round function.\n     */\n    function createRound(methodName) {\n      var func = Math[methodName];\n      return function(number, precision) {\n        number = toNumber(number);\n        precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);\n        if (precision) {\n          // Shift with exponential notation to avoid floating-point issues.\n          // See [MDN](https://mdn.io/round#Examples) for more details.\n          var pair = (toString(number) + 'e').split('e'),\n              value = func(pair[0] + 'e' + (+pair[1] + precision));\n\n          pair = (toString(value) + 'e').split('e');\n          return +(pair[0] + 'e' + (+pair[1] - precision));\n        }\n        return func(number);\n      };\n    }\n\n    /**\n     * Creates a set object of `values`.\n     *\n     * @private\n     * @param {Array} values The values to add to the set.\n     * @returns {Object} Returns the new set.\n     */\n    var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {\n      return new Set(values);\n    };\n\n    /**\n     * Creates a `_.toPairs` or `_.toPairsIn` function.\n     *\n     * @private\n     * @param {Function} keysFunc The function to get the keys of a given object.\n     * @returns {Function} Returns the new pairs function.\n     */\n    function createToPairs(keysFunc) {\n      return function(object) {\n        var tag = getTag(object);\n        if (tag == mapTag) {\n          return mapToArray(object);\n        }\n        if (tag == setTag) {\n          return setToPairs(object);\n        }\n        return baseToPairs(object, keysFunc(object));\n      };\n    }\n\n    /**\n     * Creates a function that either curries or invokes `func` with optional\n     * `this` binding and partially applied arguments.\n     *\n     * @private\n     * @param {Function|string} func The function or method name to wrap.\n     * @param {number} bitmask The bitmask flags.\n     *    1 - `_.bind`\n     *    2 - `_.bindKey`\n     *    4 - `_.curry` or `_.curryRight` of a bound function\n     *    8 - `_.curry`\n     *   16 - `_.curryRight`\n     *   32 - `_.partial`\n     *   64 - `_.partialRight`\n     *  128 - `_.rearg`\n     *  256 - `_.ary`\n     *  512 - `_.flip`\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to be partially applied.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {\n      var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;\n      if (!isBindKey && typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var length = partials ? partials.length : 0;\n      if (!length) {\n        bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);\n        partials = holders = undefined;\n      }\n      ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);\n      arity = arity === undefined ? arity : toInteger(arity);\n      length -= holders ? holders.length : 0;\n\n      if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {\n        var partialsRight = partials,\n            holdersRight = holders;\n\n        partials = holders = undefined;\n      }\n      var data = isBindKey ? undefined : getData(func);\n\n      var newData = [\n        func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,\n        argPos, ary, arity\n      ];\n\n      if (data) {\n        mergeData(newData, data);\n      }\n      func = newData[0];\n      bitmask = newData[1];\n      thisArg = newData[2];\n      partials = newData[3];\n      holders = newData[4];\n      arity = newData[9] = newData[9] === undefined\n        ? (isBindKey ? 0 : func.length)\n        : nativeMax(newData[9] - length, 0);\n\n      if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {\n        bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);\n      }\n      if (!bitmask || bitmask == WRAP_BIND_FLAG) {\n        var result = createBind(func, bitmask, thisArg);\n      } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {\n        result = createCurry(func, bitmask, arity);\n      } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {\n        result = createPartial(func, bitmask, thisArg, partials);\n      } else {\n        result = createHybrid.apply(undefined, newData);\n      }\n      var setter = data ? baseSetData : setData;\n      return setWrapToString(setter(result, newData), func, bitmask);\n    }\n\n    /**\n     * Used by `_.defaults` to customize its `_.assignIn` use to assign properties\n     * of source objects to the destination object for all destination properties\n     * that resolve to `undefined`.\n     *\n     * @private\n     * @param {*} objValue The destination value.\n     * @param {*} srcValue The source value.\n     * @param {string} key The key of the property to assign.\n     * @param {Object} object The parent object of `objValue`.\n     * @returns {*} Returns the value to assign.\n     */\n    function customDefaultsAssignIn(objValue, srcValue, key, object) {\n      if (objValue === undefined ||\n          (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n        return srcValue;\n      }\n      return objValue;\n    }\n\n    /**\n     * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source\n     * objects into destination objects that are passed thru.\n     *\n     * @private\n     * @param {*} objValue The destination value.\n     * @param {*} srcValue The source value.\n     * @param {string} key The key of the property to merge.\n     * @param {Object} object The parent object of `objValue`.\n     * @param {Object} source The parent object of `srcValue`.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     * @returns {*} Returns the value to assign.\n     */\n    function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {\n      if (isObject(objValue) && isObject(srcValue)) {\n        // Recursively merge objects and arrays (susceptible to call stack limits).\n        stack.set(srcValue, objValue);\n        baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);\n        stack['delete'](srcValue);\n      }\n      return objValue;\n    }\n\n    /**\n     * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain\n     * objects.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @param {string} key The key of the property to inspect.\n     * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.\n     */\n    function customOmitClone(value) {\n      return isPlainObject(value) ? undefined : value;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for arrays with support for\n     * partial deep comparisons.\n     *\n     * @private\n     * @param {Array} array The array to compare.\n     * @param {Array} other The other array to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `array` and `other` objects.\n     * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n     */\n    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n          arrLength = array.length,\n          othLength = other.length;\n\n      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(array);\n      if (stacked && stack.get(other)) {\n        return stacked == other;\n      }\n      var index = -1,\n          result = true,\n          seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n      stack.set(array, other);\n      stack.set(other, array);\n\n      // Ignore non-index properties.\n      while (++index < arrLength) {\n        var arrValue = array[index],\n            othValue = other[index];\n\n        if (customizer) {\n          var compared = isPartial\n            ? customizer(othValue, arrValue, index, other, array, stack)\n            : customizer(arrValue, othValue, index, array, other, stack);\n        }\n        if (compared !== undefined) {\n          if (compared) {\n            continue;\n          }\n          result = false;\n          break;\n        }\n        // Recursively compare arrays (susceptible to call stack limits).\n        if (seen) {\n          if (!arraySome(other, function(othValue, othIndex) {\n                if (!cacheHas(seen, othIndex) &&\n                    (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n                  return seen.push(othIndex);\n                }\n              })) {\n            result = false;\n            break;\n          }\n        } else if (!(\n              arrValue === othValue ||\n                equalFunc(arrValue, othValue, bitmask, customizer, stack)\n            )) {\n          result = false;\n          break;\n        }\n      }\n      stack['delete'](array);\n      stack['delete'](other);\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for comparing objects of\n     * the same `toStringTag`.\n     *\n     * **Note:** This function only supports comparing values with tags of\n     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {string} tag The `toStringTag` of the objects to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n      switch (tag) {\n        case dataViewTag:\n          if ((object.byteLength != other.byteLength) ||\n              (object.byteOffset != other.byteOffset)) {\n            return false;\n          }\n          object = object.buffer;\n          other = other.buffer;\n\n        case arrayBufferTag:\n          if ((object.byteLength != other.byteLength) ||\n              !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n            return false;\n          }\n          return true;\n\n        case boolTag:\n        case dateTag:\n        case numberTag:\n          // Coerce booleans to `1` or `0` and dates to milliseconds.\n          // Invalid dates are coerced to `NaN`.\n          return eq(+object, +other);\n\n        case errorTag:\n          return object.name == other.name && object.message == other.message;\n\n        case regexpTag:\n        case stringTag:\n          // Coerce regexes to strings and treat strings, primitives and objects,\n          // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n          // for more details.\n          return object == (other + '');\n\n        case mapTag:\n          var convert = mapToArray;\n\n        case setTag:\n          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n          convert || (convert = setToArray);\n\n          if (object.size != other.size && !isPartial) {\n            return false;\n          }\n          // Assume cyclic values are equal.\n          var stacked = stack.get(object);\n          if (stacked) {\n            return stacked == other;\n          }\n          bitmask |= COMPARE_UNORDERED_FLAG;\n\n          // Recursively compare objects (susceptible to call stack limits).\n          stack.set(object, other);\n          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n          stack['delete'](object);\n          return result;\n\n        case symbolTag:\n          if (symbolValueOf) {\n            return symbolValueOf.call(object) == symbolValueOf.call(other);\n          }\n      }\n      return false;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for objects with support for\n     * partial deep comparisons.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n          objProps = getAllKeys(object),\n          objLength = objProps.length,\n          othProps = getAllKeys(other),\n          othLength = othProps.length;\n\n      if (objLength != othLength && !isPartial) {\n        return false;\n      }\n      var index = objLength;\n      while (index--) {\n        var key = objProps[index];\n        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n          return false;\n        }\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(object);\n      if (stacked && stack.get(other)) {\n        return stacked == other;\n      }\n      var result = true;\n      stack.set(object, other);\n      stack.set(other, object);\n\n      var skipCtor = isPartial;\n      while (++index < objLength) {\n        key = objProps[index];\n        var objValue = object[key],\n            othValue = other[key];\n\n        if (customizer) {\n          var compared = isPartial\n            ? customizer(othValue, objValue, key, other, object, stack)\n            : customizer(objValue, othValue, key, object, other, stack);\n        }\n        // Recursively compare objects (susceptible to call stack limits).\n        if (!(compared === undefined\n              ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n              : compared\n            )) {\n          result = false;\n          break;\n        }\n        skipCtor || (skipCtor = key == 'constructor');\n      }\n      if (result && !skipCtor) {\n        var objCtor = object.constructor,\n            othCtor = other.constructor;\n\n        // Non `Object` object instances with different constructors are not equal.\n        if (objCtor != othCtor &&\n            ('constructor' in object && 'constructor' in other) &&\n            !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n              typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n          result = false;\n        }\n      }\n      stack['delete'](object);\n      stack['delete'](other);\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseRest` which flattens the rest array.\n     *\n     * @private\n     * @param {Function} func The function to apply a rest parameter to.\n     * @returns {Function} Returns the new function.\n     */\n    function flatRest(func) {\n      return setToString(overRest(func, undefined, flatten), func + '');\n    }\n\n    /**\n     * Creates an array of own enumerable property names and symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function getAllKeys(object) {\n      return baseGetAllKeys(object, keys, getSymbols);\n    }\n\n    /**\n     * Creates an array of own and inherited enumerable property names and\n     * symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function getAllKeysIn(object) {\n      return baseGetAllKeys(object, keysIn, getSymbolsIn);\n    }\n\n    /**\n     * Gets metadata for `func`.\n     *\n     * @private\n     * @param {Function} func The function to query.\n     * @returns {*} Returns the metadata for `func`.\n     */\n    var getData = !metaMap ? noop : function(func) {\n      return metaMap.get(func);\n    };\n\n    /**\n     * Gets the name of `func`.\n     *\n     * @private\n     * @param {Function} func The function to query.\n     * @returns {string} Returns the function name.\n     */\n    function getFuncName(func) {\n      var result = (func.name + ''),\n          array = realNames[result],\n          length = hasOwnProperty.call(realNames, result) ? array.length : 0;\n\n      while (length--) {\n        var data = array[length],\n            otherFunc = data.func;\n        if (otherFunc == null || otherFunc == func) {\n          return data.name;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Gets the argument placeholder value for `func`.\n     *\n     * @private\n     * @param {Function} func The function to inspect.\n     * @returns {*} Returns the placeholder value.\n     */\n    function getHolder(func) {\n      var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;\n      return object.placeholder;\n    }\n\n    /**\n     * Gets the appropriate \"iteratee\" function. If `_.iteratee` is customized,\n     * this function returns the custom method, otherwise it returns `baseIteratee`.\n     * If arguments are provided, the chosen function is invoked with them and\n     * its result is returned.\n     *\n     * @private\n     * @param {*} [value] The value to convert to an iteratee.\n     * @param {number} [arity] The arity of the created iteratee.\n     * @returns {Function} Returns the chosen function or its result.\n     */\n    function getIteratee() {\n      var result = lodash.iteratee || iteratee;\n      result = result === iteratee ? baseIteratee : result;\n      return arguments.length ? result(arguments[0], arguments[1]) : result;\n    }\n\n    /**\n     * Gets the data for `map`.\n     *\n     * @private\n     * @param {Object} map The map to query.\n     * @param {string} key The reference key.\n     * @returns {*} Returns the map data.\n     */\n    function getMapData(map, key) {\n      var data = map.__data__;\n      return isKeyable(key)\n        ? data[typeof key == 'string' ? 'string' : 'hash']\n        : data.map;\n    }\n\n    /**\n     * Gets the property names, values, and compare flags of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the match data of `object`.\n     */\n    function getMatchData(object) {\n      var result = keys(object),\n          length = result.length;\n\n      while (length--) {\n        var key = result[length],\n            value = object[key];\n\n        result[length] = [key, value, isStrictComparable(value)];\n      }\n      return result;\n    }\n\n    /**\n     * Gets the native function at `key` of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {string} key The key of the method to get.\n     * @returns {*} Returns the function if it's native, else `undefined`.\n     */\n    function getNative(object, key) {\n      var value = getValue(object, key);\n      return baseIsNative(value) ? value : undefined;\n    }\n\n    /**\n     * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the raw `toStringTag`.\n     */\n    function getRawTag(value) {\n      var isOwn = hasOwnProperty.call(value, symToStringTag),\n          tag = value[symToStringTag];\n\n      try {\n        value[symToStringTag] = undefined;\n        var unmasked = true;\n      } catch (e) {}\n\n      var result = nativeObjectToString.call(value);\n      if (unmasked) {\n        if (isOwn) {\n          value[symToStringTag] = tag;\n        } else {\n          delete value[symToStringTag];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array of the own enumerable symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of symbols.\n     */\n    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n      if (object == null) {\n        return [];\n      }\n      object = Object(object);\n      return arrayFilter(nativeGetSymbols(object), function(symbol) {\n        return propertyIsEnumerable.call(object, symbol);\n      });\n    };\n\n    /**\n     * Creates an array of the own and inherited enumerable symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of symbols.\n     */\n    var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n      var result = [];\n      while (object) {\n        arrayPush(result, getSymbols(object));\n        object = getPrototype(object);\n      }\n      return result;\n    };\n\n    /**\n     * Gets the `toStringTag` of `value`.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the `toStringTag`.\n     */\n    var getTag = baseGetTag;\n\n    // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\n    if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n        (Map && getTag(new Map) != mapTag) ||\n        (Promise && getTag(Promise.resolve()) != promiseTag) ||\n        (Set && getTag(new Set) != setTag) ||\n        (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n      getTag = function(value) {\n        var result = baseGetTag(value),\n            Ctor = result == objectTag ? value.constructor : undefined,\n            ctorString = Ctor ? toSource(Ctor) : '';\n\n        if (ctorString) {\n          switch (ctorString) {\n            case dataViewCtorString: return dataViewTag;\n            case mapCtorString: return mapTag;\n            case promiseCtorString: return promiseTag;\n            case setCtorString: return setTag;\n            case weakMapCtorString: return weakMapTag;\n          }\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Gets the view, applying any `transforms` to the `start` and `end` positions.\n     *\n     * @private\n     * @param {number} start The start of the view.\n     * @param {number} end The end of the view.\n     * @param {Array} transforms The transformations to apply to the view.\n     * @returns {Object} Returns an object containing the `start` and `end`\n     *  positions of the view.\n     */\n    function getView(start, end, transforms) {\n      var index = -1,\n          length = transforms.length;\n\n      while (++index < length) {\n        var data = transforms[index],\n            size = data.size;\n\n        switch (data.type) {\n          case 'drop':      start += size; break;\n          case 'dropRight': end -= size; break;\n          case 'take':      end = nativeMin(end, start + size); break;\n          case 'takeRight': start = nativeMax(start, end - size); break;\n        }\n      }\n      return { 'start': start, 'end': end };\n    }\n\n    /**\n     * Extracts wrapper details from the `source` body comment.\n     *\n     * @private\n     * @param {string} source The source to inspect.\n     * @returns {Array} Returns the wrapper details.\n     */\n    function getWrapDetails(source) {\n      var match = source.match(reWrapDetails);\n      return match ? match[1].split(reSplitDetails) : [];\n    }\n\n    /**\n     * Checks if `path` exists on `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @param {Function} hasFunc The function to check properties.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     */\n    function hasPath(object, path, hasFunc) {\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length,\n          result = false;\n\n      while (++index < length) {\n        var key = toKey(path[index]);\n        if (!(result = object != null && hasFunc(object, key))) {\n          break;\n        }\n        object = object[key];\n      }\n      if (result || ++index != length) {\n        return result;\n      }\n      length = object == null ? 0 : object.length;\n      return !!length && isLength(length) && isIndex(key, length) &&\n        (isArray(object) || isArguments(object));\n    }\n\n    /**\n     * Initializes an array clone.\n     *\n     * @private\n     * @param {Array} array The array to clone.\n     * @returns {Array} Returns the initialized clone.\n     */\n    function initCloneArray(array) {\n      var length = array.length,\n          result = array.constructor(length);\n\n      // Add properties assigned by `RegExp#exec`.\n      if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n        result.index = array.index;\n        result.input = array.input;\n      }\n      return result;\n    }\n\n    /**\n     * Initializes an object clone.\n     *\n     * @private\n     * @param {Object} object The object to clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneObject(object) {\n      return (typeof object.constructor == 'function' && !isPrototype(object))\n        ? baseCreate(getPrototype(object))\n        : {};\n    }\n\n    /**\n     * Initializes an object clone based on its `toStringTag`.\n     *\n     * **Note:** This function only supports cloning values with tags of\n     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n     *\n     * @private\n     * @param {Object} object The object to clone.\n     * @param {string} tag The `toStringTag` of the object to clone.\n     * @param {Function} cloneFunc The function to clone values.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneByTag(object, tag, cloneFunc, isDeep) {\n      var Ctor = object.constructor;\n      switch (tag) {\n        case arrayBufferTag:\n          return cloneArrayBuffer(object);\n\n        case boolTag:\n        case dateTag:\n          return new Ctor(+object);\n\n        case dataViewTag:\n          return cloneDataView(object, isDeep);\n\n        case float32Tag: case float64Tag:\n        case int8Tag: case int16Tag: case int32Tag:\n        case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n          return cloneTypedArray(object, isDeep);\n\n        case mapTag:\n          return cloneMap(object, isDeep, cloneFunc);\n\n        case numberTag:\n        case stringTag:\n          return new Ctor(object);\n\n        case regexpTag:\n          return cloneRegExp(object);\n\n        case setTag:\n          return cloneSet(object, isDeep, cloneFunc);\n\n        case symbolTag:\n          return cloneSymbol(object);\n      }\n    }\n\n    /**\n     * Inserts wrapper `details` in a comment at the top of the `source` body.\n     *\n     * @private\n     * @param {string} source The source to modify.\n     * @returns {Array} details The details to insert.\n     * @returns {string} Returns the modified source.\n     */\n    function insertWrapDetails(source, details) {\n      var length = details.length;\n      if (!length) {\n        return source;\n      }\n      var lastIndex = length - 1;\n      details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];\n      details = details.join(length > 2 ? ', ' : ' ');\n      return source.replace(reWrapComment, '{\\n/* [wrapped with ' + details + '] */\\n');\n    }\n\n    /**\n     * Checks if `value` is a flattenable `arguments` object or array.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n     */\n    function isFlattenable(value) {\n      return isArray(value) || isArguments(value) ||\n        !!(spreadableSymbol && value && value[spreadableSymbol]);\n    }\n\n    /**\n     * Checks if `value` is a valid array-like index.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n     * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n     */\n    function isIndex(value, length) {\n      length = length == null ? MAX_SAFE_INTEGER : length;\n      return !!length &&\n        (typeof value == 'number' || reIsUint.test(value)) &&\n        (value > -1 && value % 1 == 0 && value < length);\n    }\n\n    /**\n     * Checks if the given arguments are from an iteratee call.\n     *\n     * @private\n     * @param {*} value The potential iteratee value argument.\n     * @param {*} index The potential iteratee index or key argument.\n     * @param {*} object The potential iteratee object argument.\n     * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n     *  else `false`.\n     */\n    function isIterateeCall(value, index, object) {\n      if (!isObject(object)) {\n        return false;\n      }\n      var type = typeof index;\n      if (type == 'number'\n            ? (isArrayLike(object) && isIndex(index, object.length))\n            : (type == 'string' && index in object)\n          ) {\n        return eq(object[index], value);\n      }\n      return false;\n    }\n\n    /**\n     * Checks if `value` is a property name and not a property path.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @param {Object} [object] The object to query keys on.\n     * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n     */\n    function isKey(value, object) {\n      if (isArray(value)) {\n        return false;\n      }\n      var type = typeof value;\n      if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n          value == null || isSymbol(value)) {\n        return true;\n      }\n      return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n        (object != null && value in Object(object));\n    }\n\n    /**\n     * Checks if `value` is suitable for use as unique object key.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n     */\n    function isKeyable(value) {\n      var type = typeof value;\n      return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n        ? (value !== '__proto__')\n        : (value === null);\n    }\n\n    /**\n     * Checks if `func` has a lazy counterpart.\n     *\n     * @private\n     * @param {Function} func The function to check.\n     * @returns {boolean} Returns `true` if `func` has a lazy counterpart,\n     *  else `false`.\n     */\n    function isLaziable(func) {\n      var funcName = getFuncName(func),\n          other = lodash[funcName];\n\n      if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {\n        return false;\n      }\n      if (func === other) {\n        return true;\n      }\n      var data = getData(other);\n      return !!data && func === data[0];\n    }\n\n    /**\n     * Checks if `func` has its source masked.\n     *\n     * @private\n     * @param {Function} func The function to check.\n     * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n     */\n    function isMasked(func) {\n      return !!maskSrcKey && (maskSrcKey in func);\n    }\n\n    /**\n     * Checks if `func` is capable of being masked.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `func` is maskable, else `false`.\n     */\n    var isMaskable = coreJsData ? isFunction : stubFalse;\n\n    /**\n     * Checks if `value` is likely a prototype object.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n     */\n    function isPrototype(value) {\n      var Ctor = value && value.constructor,\n          proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n      return value === proto;\n    }\n\n    /**\n     * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` if suitable for strict\n     *  equality comparisons, else `false`.\n     */\n    function isStrictComparable(value) {\n      return value === value && !isObject(value);\n    }\n\n    /**\n     * A specialized version of `matchesProperty` for source values suitable\n     * for strict equality comparisons, i.e. `===`.\n     *\n     * @private\n     * @param {string} key The key of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function matchesStrictComparable(key, srcValue) {\n      return function(object) {\n        if (object == null) {\n          return false;\n        }\n        return object[key] === srcValue &&\n          (srcValue !== undefined || (key in Object(object)));\n      };\n    }\n\n    /**\n     * A specialized version of `_.memoize` which clears the memoized function's\n     * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n     *\n     * @private\n     * @param {Function} func The function to have its output memoized.\n     * @returns {Function} Returns the new memoized function.\n     */\n    function memoizeCapped(func) {\n      var result = memoize(func, function(key) {\n        if (cache.size === MAX_MEMOIZE_SIZE) {\n          cache.clear();\n        }\n        return key;\n      });\n\n      var cache = result.cache;\n      return result;\n    }\n\n    /**\n     * Merges the function metadata of `source` into `data`.\n     *\n     * Merging metadata reduces the number of wrappers used to invoke a function.\n     * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`\n     * may be applied regardless of execution order. Methods like `_.ary` and\n     * `_.rearg` modify function arguments, making the order in which they are\n     * executed important, preventing the merging of metadata. However, we make\n     * an exception for a safe combined case where curried functions have `_.ary`\n     * and or `_.rearg` applied.\n     *\n     * @private\n     * @param {Array} data The destination metadata.\n     * @param {Array} source The source metadata.\n     * @returns {Array} Returns `data`.\n     */\n    function mergeData(data, source) {\n      var bitmask = data[1],\n          srcBitmask = source[1],\n          newBitmask = bitmask | srcBitmask,\n          isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);\n\n      var isCombo =\n        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||\n        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||\n        ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));\n\n      // Exit early if metadata can't be merged.\n      if (!(isCommon || isCombo)) {\n        return data;\n      }\n      // Use source `thisArg` if available.\n      if (srcBitmask & WRAP_BIND_FLAG) {\n        data[2] = source[2];\n        // Set when currying a bound function.\n        newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;\n      }\n      // Compose partial arguments.\n      var value = source[3];\n      if (value) {\n        var partials = data[3];\n        data[3] = partials ? composeArgs(partials, value, source[4]) : value;\n        data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];\n      }\n      // Compose partial right arguments.\n      value = source[5];\n      if (value) {\n        partials = data[5];\n        data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;\n        data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];\n      }\n      // Use source `argPos` if available.\n      value = source[7];\n      if (value) {\n        data[7] = value;\n      }\n      // Use source `ary` if it's smaller.\n      if (srcBitmask & WRAP_ARY_FLAG) {\n        data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);\n      }\n      // Use source `arity` if one is not provided.\n      if (data[9] == null) {\n        data[9] = source[9];\n      }\n      // Use source `func` and merge bitmasks.\n      data[0] = source[0];\n      data[1] = newBitmask;\n\n      return data;\n    }\n\n    /**\n     * This function is like\n     * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n     * except that it includes inherited enumerable properties.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function nativeKeysIn(object) {\n      var result = [];\n      if (object != null) {\n        for (var key in Object(object)) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Converts `value` to a string using `Object.prototype.toString`.\n     *\n     * @private\n     * @param {*} value The value to convert.\n     * @returns {string} Returns the converted string.\n     */\n    function objectToString(value) {\n      return nativeObjectToString.call(value);\n    }\n\n    /**\n     * A specialized version of `baseRest` which transforms the rest array.\n     *\n     * @private\n     * @param {Function} func The function to apply a rest parameter to.\n     * @param {number} [start=func.length-1] The start position of the rest parameter.\n     * @param {Function} transform The rest array transform.\n     * @returns {Function} Returns the new function.\n     */\n    function overRest(func, start, transform) {\n      start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n      return function() {\n        var args = arguments,\n            index = -1,\n            length = nativeMax(args.length - start, 0),\n            array = Array(length);\n\n        while (++index < length) {\n          array[index] = args[start + index];\n        }\n        index = -1;\n        var otherArgs = Array(start + 1);\n        while (++index < start) {\n          otherArgs[index] = args[index];\n        }\n        otherArgs[start] = transform(array);\n        return apply(func, this, otherArgs);\n      };\n    }\n\n    /**\n     * Gets the parent value at `path` of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array} path The path to get the parent value of.\n     * @returns {*} Returns the parent value.\n     */\n    function parent(object, path) {\n      return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));\n    }\n\n    /**\n     * Reorder `array` according to the specified indexes where the element at\n     * the first index is assigned as the first element, the element at\n     * the second index is assigned as the second element, and so on.\n     *\n     * @private\n     * @param {Array} array The array to reorder.\n     * @param {Array} indexes The arranged array indexes.\n     * @returns {Array} Returns `array`.\n     */\n    function reorder(array, indexes) {\n      var arrLength = array.length,\n          length = nativeMin(indexes.length, arrLength),\n          oldArray = copyArray(array);\n\n      while (length--) {\n        var index = indexes[length];\n        array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;\n      }\n      return array;\n    }\n\n    /**\n     * Sets metadata for `func`.\n     *\n     * **Note:** If this function becomes hot, i.e. is invoked a lot in a short\n     * period of time, it will trip its breaker and transition to an identity\n     * function to avoid garbage collection pauses in V8. See\n     * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)\n     * for more details.\n     *\n     * @private\n     * @param {Function} func The function to associate metadata with.\n     * @param {*} data The metadata.\n     * @returns {Function} Returns `func`.\n     */\n    var setData = shortOut(baseSetData);\n\n    /**\n     * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).\n     *\n     * @private\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @returns {number|Object} Returns the timer id or timeout object.\n     */\n    var setTimeout = ctxSetTimeout || function(func, wait) {\n      return root.setTimeout(func, wait);\n    };\n\n    /**\n     * Sets the `toString` method of `func` to return `string`.\n     *\n     * @private\n     * @param {Function} func The function to modify.\n     * @param {Function} string The `toString` result.\n     * @returns {Function} Returns `func`.\n     */\n    var setToString = shortOut(baseSetToString);\n\n    /**\n     * Sets the `toString` method of `wrapper` to mimic the source of `reference`\n     * with wrapper details in a comment at the top of the source body.\n     *\n     * @private\n     * @param {Function} wrapper The function to modify.\n     * @param {Function} reference The reference function.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @returns {Function} Returns `wrapper`.\n     */\n    function setWrapToString(wrapper, reference, bitmask) {\n      var source = (reference + '');\n      return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));\n    }\n\n    /**\n     * Creates a function that'll short out and invoke `identity` instead\n     * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n     * milliseconds.\n     *\n     * @private\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new shortable function.\n     */\n    function shortOut(func) {\n      var count = 0,\n          lastCalled = 0;\n\n      return function() {\n        var stamp = nativeNow(),\n            remaining = HOT_SPAN - (stamp - lastCalled);\n\n        lastCalled = stamp;\n        if (remaining > 0) {\n          if (++count >= HOT_COUNT) {\n            return arguments[0];\n          }\n        } else {\n          count = 0;\n        }\n        return func.apply(undefined, arguments);\n      };\n    }\n\n    /**\n     * A specialized version of `_.shuffle` which mutates and sets the size of `array`.\n     *\n     * @private\n     * @param {Array} array The array to shuffle.\n     * @param {number} [size=array.length] The size of `array`.\n     * @returns {Array} Returns `array`.\n     */\n    function shuffleSelf(array, size) {\n      var index = -1,\n          length = array.length,\n          lastIndex = length - 1;\n\n      size = size === undefined ? length : size;\n      while (++index < size) {\n        var rand = baseRandom(index, lastIndex),\n            value = array[rand];\n\n        array[rand] = array[index];\n        array[index] = value;\n      }\n      array.length = size;\n      return array;\n    }\n\n    /**\n     * Converts `string` to a property path array.\n     *\n     * @private\n     * @param {string} string The string to convert.\n     * @returns {Array} Returns the property path array.\n     */\n    var stringToPath = memoizeCapped(function(string) {\n      var result = [];\n      if (reLeadingDot.test(string)) {\n        result.push('');\n      }\n      string.replace(rePropName, function(match, number, quote, string) {\n        result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));\n      });\n      return result;\n    });\n\n    /**\n     * Converts `value` to a string key if it's not a string or symbol.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {string|symbol} Returns the key.\n     */\n    function toKey(value) {\n      if (typeof value == 'string' || isSymbol(value)) {\n        return value;\n      }\n      var result = (value + '');\n      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n    }\n\n    /**\n     * Converts `func` to its source code.\n     *\n     * @private\n     * @param {Function} func The function to convert.\n     * @returns {string} Returns the source code.\n     */\n    function toSource(func) {\n      if (func != null) {\n        try {\n          return funcToString.call(func);\n        } catch (e) {}\n        try {\n          return (func + '');\n        } catch (e) {}\n      }\n      return '';\n    }\n\n    /**\n     * Updates wrapper `details` based on `bitmask` flags.\n     *\n     * @private\n     * @returns {Array} details The details to modify.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @returns {Array} Returns `details`.\n     */\n    function updateWrapDetails(details, bitmask) {\n      arrayEach(wrapFlags, function(pair) {\n        var value = '_.' + pair[0];\n        if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {\n          details.push(value);\n        }\n      });\n      return details.sort();\n    }\n\n    /**\n     * Creates a clone of `wrapper`.\n     *\n     * @private\n     * @param {Object} wrapper The wrapper to clone.\n     * @returns {Object} Returns the cloned wrapper.\n     */\n    function wrapperClone(wrapper) {\n      if (wrapper instanceof LazyWrapper) {\n        return wrapper.clone();\n      }\n      var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);\n      result.__actions__ = copyArray(wrapper.__actions__);\n      result.__index__  = wrapper.__index__;\n      result.__values__ = wrapper.__values__;\n      return result;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an array of elements split into groups the length of `size`.\n     * If `array` can't be split evenly, the final chunk will be the remaining\n     * elements.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to process.\n     * @param {number} [size=1] The length of each chunk\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the new array of chunks.\n     * @example\n     *\n     * _.chunk(['a', 'b', 'c', 'd'], 2);\n     * // => [['a', 'b'], ['c', 'd']]\n     *\n     * _.chunk(['a', 'b', 'c', 'd'], 3);\n     * // => [['a', 'b', 'c'], ['d']]\n     */\n    function chunk(array, size, guard) {\n      if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {\n        size = 1;\n      } else {\n        size = nativeMax(toInteger(size), 0);\n      }\n      var length = array == null ? 0 : array.length;\n      if (!length || size < 1) {\n        return [];\n      }\n      var index = 0,\n          resIndex = 0,\n          result = Array(nativeCeil(length / size));\n\n      while (index < length) {\n        result[resIndex++] = baseSlice(array, index, (index += size));\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array with all falsey values removed. The values `false`, `null`,\n     * `0`, `\"\"`, `undefined`, and `NaN` are falsey.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to compact.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.compact([0, 1, false, 2, '', 3]);\n     * // => [1, 2, 3]\n     */\n    function compact(array) {\n      var index = -1,\n          length = array == null ? 0 : array.length,\n          resIndex = 0,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index];\n        if (value) {\n          result[resIndex++] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates a new array concatenating `array` with any additional arrays\n     * and/or values.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to concatenate.\n     * @param {...*} [values] The values to concatenate.\n     * @returns {Array} Returns the new concatenated array.\n     * @example\n     *\n     * var array = [1];\n     * var other = _.concat(array, 2, [3], [[4]]);\n     *\n     * console.log(other);\n     * // => [1, 2, 3, [4]]\n     *\n     * console.log(array);\n     * // => [1]\n     */\n    function concat() {\n      var length = arguments.length;\n      if (!length) {\n        return [];\n      }\n      var args = Array(length - 1),\n          array = arguments[0],\n          index = length;\n\n      while (index--) {\n        args[index - 1] = arguments[index];\n      }\n      return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));\n    }\n\n    /**\n     * Creates an array of `array` values not included in the other given arrays\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. The order and references of result values are\n     * determined by the first array.\n     *\n     * **Note:** Unlike `_.pullAll`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.without, _.xor\n     * @example\n     *\n     * _.difference([2, 1], [2, 3]);\n     * // => [1]\n     */\n    var difference = baseRest(function(array, values) {\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))\n        : [];\n    });\n\n    /**\n     * This method is like `_.difference` except that it accepts `iteratee` which\n     * is invoked for each element of `array` and `values` to generate the criterion\n     * by which they're compared. The order and references of result values are\n     * determined by the first array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * **Note:** Unlike `_.pullAllBy`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');\n     * // => [{ 'x': 2 }]\n     */\n    var differenceBy = baseRest(function(array, values) {\n      var iteratee = last(values);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))\n        : [];\n    });\n\n    /**\n     * This method is like `_.difference` except that it accepts `comparator`\n     * which is invoked to compare elements of `array` to `values`. The order and\n     * references of result values are determined by the first array. The comparator\n     * is invoked with two arguments: (arrVal, othVal).\n     *\n     * **Note:** Unlike `_.pullAllWith`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     *\n     * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);\n     * // => [{ 'x': 2, 'y': 1 }]\n     */\n    var differenceWith = baseRest(function(array, values) {\n      var comparator = last(values);\n      if (isArrayLikeObject(comparator)) {\n        comparator = undefined;\n      }\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)\n        : [];\n    });\n\n    /**\n     * Creates a slice of `array` with `n` elements dropped from the beginning.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to drop.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.drop([1, 2, 3]);\n     * // => [2, 3]\n     *\n     * _.drop([1, 2, 3], 2);\n     * // => [3]\n     *\n     * _.drop([1, 2, 3], 5);\n     * // => []\n     *\n     * _.drop([1, 2, 3], 0);\n     * // => [1, 2, 3]\n     */\n    function drop(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      return baseSlice(array, n < 0 ? 0 : n, length);\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements dropped from the end.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to drop.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.dropRight([1, 2, 3]);\n     * // => [1, 2]\n     *\n     * _.dropRight([1, 2, 3], 2);\n     * // => [1]\n     *\n     * _.dropRight([1, 2, 3], 5);\n     * // => []\n     *\n     * _.dropRight([1, 2, 3], 0);\n     * // => [1, 2, 3]\n     */\n    function dropRight(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      n = length - n;\n      return baseSlice(array, 0, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` excluding elements dropped from the end.\n     * Elements are dropped until `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.dropRightWhile(users, function(o) { return !o.active; });\n     * // => objects for ['barney']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.dropRightWhile(users, ['active', false]);\n     * // => objects for ['barney']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.dropRightWhile(users, 'active');\n     * // => objects for ['barney', 'fred', 'pebbles']\n     */\n    function dropRightWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), true, true)\n        : [];\n    }\n\n    /**\n     * Creates a slice of `array` excluding elements dropped from the beginning.\n     * Elements are dropped until `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.dropWhile(users, function(o) { return !o.active; });\n     * // => objects for ['pebbles']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.dropWhile(users, { 'user': 'barney', 'active': false });\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.dropWhile(users, ['active', false]);\n     * // => objects for ['pebbles']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.dropWhile(users, 'active');\n     * // => objects for ['barney', 'fred', 'pebbles']\n     */\n    function dropWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), true)\n        : [];\n    }\n\n    /**\n     * Fills elements of `array` with `value` from `start` up to, but not\n     * including, `end`.\n     *\n     * **Note:** This method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Array\n     * @param {Array} array The array to fill.\n     * @param {*} value The value to fill `array` with.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _.fill(array, 'a');\n     * console.log(array);\n     * // => ['a', 'a', 'a']\n     *\n     * _.fill(Array(3), 2);\n     * // => [2, 2, 2]\n     *\n     * _.fill([4, 6, 8, 10], '*', 1, 3);\n     * // => [4, '*', '*', 10]\n     */\n    function fill(array, value, start, end) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {\n        start = 0;\n        end = length;\n      }\n      return baseFill(array, value, start, end);\n    }\n\n    /**\n     * This method is like `_.find` except that it returns the index of the first\n     * element `predicate` returns truthy for instead of the element itself.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {number} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.findIndex(users, function(o) { return o.user == 'barney'; });\n     * // => 0\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findIndex(users, { 'user': 'fred', 'active': false });\n     * // => 1\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findIndex(users, ['active', false]);\n     * // => 0\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findIndex(users, 'active');\n     * // => 2\n     */\n    function findIndex(array, predicate, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = fromIndex == null ? 0 : toInteger(fromIndex);\n      if (index < 0) {\n        index = nativeMax(length + index, 0);\n      }\n      return baseFindIndex(array, getIteratee(predicate, 3), index);\n    }\n\n    /**\n     * This method is like `_.findIndex` except that it iterates over elements\n     * of `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=array.length-1] The index to search from.\n     * @returns {number} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });\n     * // => 2\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findLastIndex(users, { 'user': 'barney', 'active': true });\n     * // => 0\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findLastIndex(users, ['active', false]);\n     * // => 2\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findLastIndex(users, 'active');\n     * // => 0\n     */\n    function findLastIndex(array, predicate, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = length - 1;\n      if (fromIndex !== undefined) {\n        index = toInteger(fromIndex);\n        index = fromIndex < 0\n          ? nativeMax(length + index, 0)\n          : nativeMin(index, length - 1);\n      }\n      return baseFindIndex(array, getIteratee(predicate, 3), index, true);\n    }\n\n    /**\n     * Flattens `array` a single level deep.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * _.flatten([1, [2, [3, [4]], 5]]);\n     * // => [1, 2, [3, [4]], 5]\n     */\n    function flatten(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseFlatten(array, 1) : [];\n    }\n\n    /**\n     * Recursively flattens `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * _.flattenDeep([1, [2, [3, [4]], 5]]);\n     * // => [1, 2, 3, 4, 5]\n     */\n    function flattenDeep(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseFlatten(array, INFINITY) : [];\n    }\n\n    /**\n     * Recursively flatten `array` up to `depth` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.4.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @param {number} [depth=1] The maximum recursion depth.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * var array = [1, [2, [3, [4]], 5]];\n     *\n     * _.flattenDepth(array, 1);\n     * // => [1, 2, [3, [4]], 5]\n     *\n     * _.flattenDepth(array, 2);\n     * // => [1, 2, 3, [4], 5]\n     */\n    function flattenDepth(array, depth) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      depth = depth === undefined ? 1 : toInteger(depth);\n      return baseFlatten(array, depth);\n    }\n\n    /**\n     * The inverse of `_.toPairs`; this method returns an object composed\n     * from key-value `pairs`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} pairs The key-value pairs.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.fromPairs([['a', 1], ['b', 2]]);\n     * // => { 'a': 1, 'b': 2 }\n     */\n    function fromPairs(pairs) {\n      var index = -1,\n          length = pairs == null ? 0 : pairs.length,\n          result = {};\n\n      while (++index < length) {\n        var pair = pairs[index];\n        result[pair[0]] = pair[1];\n      }\n      return result;\n    }\n\n    /**\n     * Gets the first element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @alias first\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {*} Returns the first element of `array`.\n     * @example\n     *\n     * _.head([1, 2, 3]);\n     * // => 1\n     *\n     * _.head([]);\n     * // => undefined\n     */\n    function head(array) {\n      return (array && array.length) ? array[0] : undefined;\n    }\n\n    /**\n     * Gets the index at which the first occurrence of `value` is found in `array`\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. If `fromIndex` is negative, it's used as the\n     * offset from the end of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.indexOf([1, 2, 1, 2], 2);\n     * // => 1\n     *\n     * // Search from the `fromIndex`.\n     * _.indexOf([1, 2, 1, 2], 2, 2);\n     * // => 3\n     */\n    function indexOf(array, value, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = fromIndex == null ? 0 : toInteger(fromIndex);\n      if (index < 0) {\n        index = nativeMax(length + index, 0);\n      }\n      return baseIndexOf(array, value, index);\n    }\n\n    /**\n     * Gets all but the last element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.initial([1, 2, 3]);\n     * // => [1, 2]\n     */\n    function initial(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseSlice(array, 0, -1) : [];\n    }\n\n    /**\n     * Creates an array of unique values that are included in all given arrays\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. The order and references of result values are\n     * determined by the first array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * _.intersection([2, 1], [2, 3]);\n     * // => [2]\n     */\n    var intersection = baseRest(function(arrays) {\n      var mapped = arrayMap(arrays, castArrayLikeObject);\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped)\n        : [];\n    });\n\n    /**\n     * This method is like `_.intersection` except that it accepts `iteratee`\n     * which is invoked for each element of each `arrays` to generate the criterion\n     * by which they're compared. The order and references of result values are\n     * determined by the first array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [2.1]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }]\n     */\n    var intersectionBy = baseRest(function(arrays) {\n      var iteratee = last(arrays),\n          mapped = arrayMap(arrays, castArrayLikeObject);\n\n      if (iteratee === last(mapped)) {\n        iteratee = undefined;\n      } else {\n        mapped.pop();\n      }\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped, getIteratee(iteratee, 2))\n        : [];\n    });\n\n    /**\n     * This method is like `_.intersection` except that it accepts `comparator`\n     * which is invoked to compare elements of `arrays`. The order and references\n     * of result values are determined by the first array. The comparator is\n     * invoked with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.intersectionWith(objects, others, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }]\n     */\n    var intersectionWith = baseRest(function(arrays) {\n      var comparator = last(arrays),\n          mapped = arrayMap(arrays, castArrayLikeObject);\n\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      if (comparator) {\n        mapped.pop();\n      }\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped, undefined, comparator)\n        : [];\n    });\n\n    /**\n     * Converts all elements in `array` into a string separated by `separator`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to convert.\n     * @param {string} [separator=','] The element separator.\n     * @returns {string} Returns the joined string.\n     * @example\n     *\n     * _.join(['a', 'b', 'c'], '~');\n     * // => 'a~b~c'\n     */\n    function join(array, separator) {\n      return array == null ? '' : nativeJoin.call(array, separator);\n    }\n\n    /**\n     * Gets the last element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {*} Returns the last element of `array`.\n     * @example\n     *\n     * _.last([1, 2, 3]);\n     * // => 3\n     */\n    function last(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? array[length - 1] : undefined;\n    }\n\n    /**\n     * This method is like `_.indexOf` except that it iterates over elements of\n     * `array` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=array.length-1] The index to search from.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.lastIndexOf([1, 2, 1, 2], 2);\n     * // => 3\n     *\n     * // Search from the `fromIndex`.\n     * _.lastIndexOf([1, 2, 1, 2], 2, 2);\n     * // => 1\n     */\n    function lastIndexOf(array, value, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = length;\n      if (fromIndex !== undefined) {\n        index = toInteger(fromIndex);\n        index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);\n      }\n      return value === value\n        ? strictLastIndexOf(array, value, index)\n        : baseFindIndex(array, baseIsNaN, index, true);\n    }\n\n    /**\n     * Gets the element at index `n` of `array`. If `n` is negative, the nth\n     * element from the end is returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.11.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=0] The index of the element to return.\n     * @returns {*} Returns the nth element of `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'd'];\n     *\n     * _.nth(array, 1);\n     * // => 'b'\n     *\n     * _.nth(array, -2);\n     * // => 'c';\n     */\n    function nth(array, n) {\n      return (array && array.length) ? baseNth(array, toInteger(n)) : undefined;\n    }\n\n    /**\n     * Removes all given values from `array` using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`\n     * to remove elements from an array by predicate.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {...*} [values] The values to remove.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n     *\n     * _.pull(array, 'a', 'c');\n     * console.log(array);\n     * // => ['b', 'b']\n     */\n    var pull = baseRest(pullAll);\n\n    /**\n     * This method is like `_.pull` except that it accepts an array of values to remove.\n     *\n     * **Note:** Unlike `_.difference`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n     *\n     * _.pullAll(array, ['a', 'c']);\n     * console.log(array);\n     * // => ['b', 'b']\n     */\n    function pullAll(array, values) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values)\n        : array;\n    }\n\n    /**\n     * This method is like `_.pullAll` except that it accepts `iteratee` which is\n     * invoked for each element of `array` and `values` to generate the criterion\n     * by which they're compared. The iteratee is invoked with one argument: (value).\n     *\n     * **Note:** Unlike `_.differenceBy`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];\n     *\n     * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');\n     * console.log(array);\n     * // => [{ 'x': 2 }]\n     */\n    function pullAllBy(array, values, iteratee) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values, getIteratee(iteratee, 2))\n        : array;\n    }\n\n    /**\n     * This method is like `_.pullAll` except that it accepts `comparator` which\n     * is invoked to compare elements of `array` to `values`. The comparator is\n     * invoked with two arguments: (arrVal, othVal).\n     *\n     * **Note:** Unlike `_.differenceWith`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];\n     *\n     * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);\n     * console.log(array);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]\n     */\n    function pullAllWith(array, values, comparator) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values, undefined, comparator)\n        : array;\n    }\n\n    /**\n     * Removes elements from `array` corresponding to `indexes` and returns an\n     * array of removed elements.\n     *\n     * **Note:** Unlike `_.at`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {...(number|number[])} [indexes] The indexes of elements to remove.\n     * @returns {Array} Returns the new array of removed elements.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'd'];\n     * var pulled = _.pullAt(array, [1, 3]);\n     *\n     * console.log(array);\n     * // => ['a', 'c']\n     *\n     * console.log(pulled);\n     * // => ['b', 'd']\n     */\n    var pullAt = flatRest(function(array, indexes) {\n      var length = array == null ? 0 : array.length,\n          result = baseAt(array, indexes);\n\n      basePullAt(array, arrayMap(indexes, function(index) {\n        return isIndex(index, length) ? +index : index;\n      }).sort(compareAscending));\n\n      return result;\n    });\n\n    /**\n     * Removes all elements from `array` that `predicate` returns truthy for\n     * and returns an array of the removed elements. The predicate is invoked\n     * with three arguments: (value, index, array).\n     *\n     * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`\n     * to pull elements from an array by value.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new array of removed elements.\n     * @example\n     *\n     * var array = [1, 2, 3, 4];\n     * var evens = _.remove(array, function(n) {\n     *   return n % 2 == 0;\n     * });\n     *\n     * console.log(array);\n     * // => [1, 3]\n     *\n     * console.log(evens);\n     * // => [2, 4]\n     */\n    function remove(array, predicate) {\n      var result = [];\n      if (!(array && array.length)) {\n        return result;\n      }\n      var index = -1,\n          indexes = [],\n          length = array.length;\n\n      predicate = getIteratee(predicate, 3);\n      while (++index < length) {\n        var value = array[index];\n        if (predicate(value, index, array)) {\n          result.push(value);\n          indexes.push(index);\n        }\n      }\n      basePullAt(array, indexes);\n      return result;\n    }\n\n    /**\n     * Reverses `array` so that the first element becomes the last, the second\n     * element becomes the second to last, and so on.\n     *\n     * **Note:** This method mutates `array` and is based on\n     * [`Array#reverse`](https://mdn.io/Array/reverse).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _.reverse(array);\n     * // => [3, 2, 1]\n     *\n     * console.log(array);\n     * // => [3, 2, 1]\n     */\n    function reverse(array) {\n      return array == null ? array : nativeReverse.call(array);\n    }\n\n    /**\n     * Creates a slice of `array` from `start` up to, but not including, `end`.\n     *\n     * **Note:** This method is used instead of\n     * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are\n     * returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to slice.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function slice(array, start, end) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {\n        start = 0;\n        end = length;\n      }\n      else {\n        start = start == null ? 0 : toInteger(start);\n        end = end === undefined ? length : toInteger(end);\n      }\n      return baseSlice(array, start, end);\n    }\n\n    /**\n     * Uses a binary search to determine the lowest index at which `value`\n     * should be inserted into `array` in order to maintain its sort order.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedIndex([30, 50], 40);\n     * // => 1\n     */\n    function sortedIndex(array, value) {\n      return baseSortedIndex(array, value);\n    }\n\n    /**\n     * This method is like `_.sortedIndex` except that it accepts `iteratee`\n     * which is invoked for `value` and each element of `array` to compute their\n     * sort ranking. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * var objects = [{ 'x': 4 }, { 'x': 5 }];\n     *\n     * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n     * // => 0\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sortedIndexBy(objects, { 'x': 4 }, 'x');\n     * // => 0\n     */\n    function sortedIndexBy(array, value, iteratee) {\n      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));\n    }\n\n    /**\n     * This method is like `_.indexOf` except that it performs a binary\n     * search on a sorted `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.sortedIndexOf([4, 5, 5, 5, 6], 5);\n     * // => 1\n     */\n    function sortedIndexOf(array, value) {\n      var length = array == null ? 0 : array.length;\n      if (length) {\n        var index = baseSortedIndex(array, value);\n        if (index < length && eq(array[index], value)) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * This method is like `_.sortedIndex` except that it returns the highest\n     * index at which `value` should be inserted into `array` in order to\n     * maintain its sort order.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedLastIndex([4, 5, 5, 5, 6], 5);\n     * // => 4\n     */\n    function sortedLastIndex(array, value) {\n      return baseSortedIndex(array, value, true);\n    }\n\n    /**\n     * This method is like `_.sortedLastIndex` except that it accepts `iteratee`\n     * which is invoked for `value` and each element of `array` to compute their\n     * sort ranking. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * var objects = [{ 'x': 4 }, { 'x': 5 }];\n     *\n     * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n     * // => 1\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');\n     * // => 1\n     */\n    function sortedLastIndexBy(array, value, iteratee) {\n      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);\n    }\n\n    /**\n     * This method is like `_.lastIndexOf` except that it performs a binary\n     * search on a sorted `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);\n     * // => 3\n     */\n    function sortedLastIndexOf(array, value) {\n      var length = array == null ? 0 : array.length;\n      if (length) {\n        var index = baseSortedIndex(array, value, true) - 1;\n        if (eq(array[index], value)) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * This method is like `_.uniq` except that it's designed and optimized\n     * for sorted arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.sortedUniq([1, 1, 2]);\n     * // => [1, 2]\n     */\n    function sortedUniq(array) {\n      return (array && array.length)\n        ? baseSortedUniq(array)\n        : [];\n    }\n\n    /**\n     * This method is like `_.uniqBy` except that it's designed and optimized\n     * for sorted arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);\n     * // => [1.1, 2.3]\n     */\n    function sortedUniqBy(array, iteratee) {\n      return (array && array.length)\n        ? baseSortedUniq(array, getIteratee(iteratee, 2))\n        : [];\n    }\n\n    /**\n     * Gets all but the first element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.tail([1, 2, 3]);\n     * // => [2, 3]\n     */\n    function tail(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseSlice(array, 1, length) : [];\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements taken from the beginning.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to take.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.take([1, 2, 3]);\n     * // => [1]\n     *\n     * _.take([1, 2, 3], 2);\n     * // => [1, 2]\n     *\n     * _.take([1, 2, 3], 5);\n     * // => [1, 2, 3]\n     *\n     * _.take([1, 2, 3], 0);\n     * // => []\n     */\n    function take(array, n, guard) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      return baseSlice(array, 0, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements taken from the end.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to take.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.takeRight([1, 2, 3]);\n     * // => [3]\n     *\n     * _.takeRight([1, 2, 3], 2);\n     * // => [2, 3]\n     *\n     * _.takeRight([1, 2, 3], 5);\n     * // => [1, 2, 3]\n     *\n     * _.takeRight([1, 2, 3], 0);\n     * // => []\n     */\n    function takeRight(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      n = length - n;\n      return baseSlice(array, n < 0 ? 0 : n, length);\n    }\n\n    /**\n     * Creates a slice of `array` with elements taken from the end. Elements are\n     * taken until `predicate` returns falsey. The predicate is invoked with\n     * three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.takeRightWhile(users, function(o) { return !o.active; });\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });\n     * // => objects for ['pebbles']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.takeRightWhile(users, ['active', false]);\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.takeRightWhile(users, 'active');\n     * // => []\n     */\n    function takeRightWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), false, true)\n        : [];\n    }\n\n    /**\n     * Creates a slice of `array` with elements taken from the beginning. Elements\n     * are taken until `predicate` returns falsey. The predicate is invoked with\n     * three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.takeWhile(users, function(o) { return !o.active; });\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.takeWhile(users, { 'user': 'barney', 'active': false });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.takeWhile(users, ['active', false]);\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.takeWhile(users, 'active');\n     * // => []\n     */\n    function takeWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3))\n        : [];\n    }\n\n    /**\n     * Creates an array of unique values, in order, from all given arrays using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * _.union([2], [1, 2]);\n     * // => [2, 1]\n     */\n    var union = baseRest(function(arrays) {\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));\n    });\n\n    /**\n     * This method is like `_.union` except that it accepts `iteratee` which is\n     * invoked for each element of each `arrays` to generate the criterion by\n     * which uniqueness is computed. Result values are chosen from the first\n     * array in which the value occurs. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * _.unionBy([2.1], [1.2, 2.3], Math.floor);\n     * // => [2.1, 1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }, { 'x': 2 }]\n     */\n    var unionBy = baseRest(function(arrays) {\n      var iteratee = last(arrays);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));\n    });\n\n    /**\n     * This method is like `_.union` except that it accepts `comparator` which\n     * is invoked to compare elements of `arrays`. Result values are chosen from\n     * the first array in which the value occurs. The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.unionWith(objects, others, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n     */\n    var unionWith = baseRest(function(arrays) {\n      var comparator = last(arrays);\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);\n    });\n\n    /**\n     * Creates a duplicate-free version of an array, using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons, in which only the first occurrence of each element\n     * is kept. The order of result values is determined by the order they occur\n     * in the array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.uniq([2, 1, 2]);\n     * // => [2, 1]\n     */\n    function uniq(array) {\n      return (array && array.length) ? baseUniq(array) : [];\n    }\n\n    /**\n     * This method is like `_.uniq` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * uniqueness is computed. The order of result values is determined by the\n     * order they occur in the array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.uniqBy([2.1, 1.2, 2.3], Math.floor);\n     * // => [2.1, 1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }, { 'x': 2 }]\n     */\n    function uniqBy(array, iteratee) {\n      return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];\n    }\n\n    /**\n     * This method is like `_.uniq` except that it accepts `comparator` which\n     * is invoked to compare elements of `array`. The order of result values is\n     * determined by the order they occur in the array.The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.uniqWith(objects, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]\n     */\n    function uniqWith(array, comparator) {\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return (array && array.length) ? baseUniq(array, undefined, comparator) : [];\n    }\n\n    /**\n     * This method is like `_.zip` except that it accepts an array of grouped\n     * elements and creates an array regrouping the elements to their pre-zip\n     * configuration.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.2.0\n     * @category Array\n     * @param {Array} array The array of grouped elements to process.\n     * @returns {Array} Returns the new array of regrouped elements.\n     * @example\n     *\n     * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);\n     * // => [['a', 1, true], ['b', 2, false]]\n     *\n     * _.unzip(zipped);\n     * // => [['a', 'b'], [1, 2], [true, false]]\n     */\n    function unzip(array) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      var length = 0;\n      array = arrayFilter(array, function(group) {\n        if (isArrayLikeObject(group)) {\n          length = nativeMax(group.length, length);\n          return true;\n        }\n      });\n      return baseTimes(length, function(index) {\n        return arrayMap(array, baseProperty(index));\n      });\n    }\n\n    /**\n     * This method is like `_.unzip` except that it accepts `iteratee` to specify\n     * how regrouped values should be combined. The iteratee is invoked with the\n     * elements of each group: (...group).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Array\n     * @param {Array} array The array of grouped elements to process.\n     * @param {Function} [iteratee=_.identity] The function to combine\n     *  regrouped values.\n     * @returns {Array} Returns the new array of regrouped elements.\n     * @example\n     *\n     * var zipped = _.zip([1, 2], [10, 20], [100, 200]);\n     * // => [[1, 10, 100], [2, 20, 200]]\n     *\n     * _.unzipWith(zipped, _.add);\n     * // => [3, 30, 300]\n     */\n    function unzipWith(array, iteratee) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      var result = unzip(array);\n      if (iteratee == null) {\n        return result;\n      }\n      return arrayMap(result, function(group) {\n        return apply(iteratee, undefined, group);\n      });\n    }\n\n    /**\n     * Creates an array excluding all given values using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * **Note:** Unlike `_.pull`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...*} [values] The values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.difference, _.xor\n     * @example\n     *\n     * _.without([2, 1, 2, 3], 1, 2);\n     * // => [3]\n     */\n    var without = baseRest(function(array, values) {\n      return isArrayLikeObject(array)\n        ? baseDifference(array, values)\n        : [];\n    });\n\n    /**\n     * Creates an array of unique values that is the\n     * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)\n     * of the given arrays. The order of result values is determined by the order\n     * they occur in the arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.difference, _.without\n     * @example\n     *\n     * _.xor([2, 1], [2, 3]);\n     * // => [1, 3]\n     */\n    var xor = baseRest(function(arrays) {\n      return baseXor(arrayFilter(arrays, isArrayLikeObject));\n    });\n\n    /**\n     * This method is like `_.xor` except that it accepts `iteratee` which is\n     * invoked for each element of each `arrays` to generate the criterion by\n     * which by which they're compared. The order of result values is determined\n     * by the order they occur in the arrays. The iteratee is invoked with one\n     * argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [1.2, 3.4]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 2 }]\n     */\n    var xorBy = baseRest(function(arrays) {\n      var iteratee = last(arrays);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));\n    });\n\n    /**\n     * This method is like `_.xor` except that it accepts `comparator` which is\n     * invoked to compare elements of `arrays`. The order of result values is\n     * determined by the order they occur in the arrays. The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.xorWith(objects, others, _.isEqual);\n     * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n     */\n    var xorWith = baseRest(function(arrays) {\n      var comparator = last(arrays);\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator);\n    });\n\n    /**\n     * Creates an array of grouped elements, the first of which contains the\n     * first elements of the given arrays, the second of which contains the\n     * second elements of the given arrays, and so on.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to process.\n     * @returns {Array} Returns the new array of grouped elements.\n     * @example\n     *\n     * _.zip(['a', 'b'], [1, 2], [true, false]);\n     * // => [['a', 1, true], ['b', 2, false]]\n     */\n    var zip = baseRest(unzip);\n\n    /**\n     * This method is like `_.fromPairs` except that it accepts two arrays,\n     * one of property identifiers and one of corresponding values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.4.0\n     * @category Array\n     * @param {Array} [props=[]] The property identifiers.\n     * @param {Array} [values=[]] The property values.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.zipObject(['a', 'b'], [1, 2]);\n     * // => { 'a': 1, 'b': 2 }\n     */\n    function zipObject(props, values) {\n      return baseZipObject(props || [], values || [], assignValue);\n    }\n\n    /**\n     * This method is like `_.zipObject` except that it supports property paths.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.1.0\n     * @category Array\n     * @param {Array} [props=[]] The property identifiers.\n     * @param {Array} [values=[]] The property values.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);\n     * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }\n     */\n    function zipObjectDeep(props, values) {\n      return baseZipObject(props || [], values || [], baseSet);\n    }\n\n    /**\n     * This method is like `_.zip` except that it accepts `iteratee` to specify\n     * how grouped values should be combined. The iteratee is invoked with the\n     * elements of each group: (...group).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to process.\n     * @param {Function} [iteratee=_.identity] The function to combine\n     *  grouped values.\n     * @returns {Array} Returns the new array of grouped elements.\n     * @example\n     *\n     * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {\n     *   return a + b + c;\n     * });\n     * // => [111, 222]\n     */\n    var zipWith = baseRest(function(arrays) {\n      var length = arrays.length,\n          iteratee = length > 1 ? arrays[length - 1] : undefined;\n\n      iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined;\n      return unzipWith(arrays, iteratee);\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` wrapper instance that wraps `value` with explicit method\n     * chain sequences enabled. The result of such sequences must be unwrapped\n     * with `_#value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.3.0\n     * @category Seq\n     * @param {*} value The value to wrap.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36 },\n     *   { 'user': 'fred',    'age': 40 },\n     *   { 'user': 'pebbles', 'age': 1 }\n     * ];\n     *\n     * var youngest = _\n     *   .chain(users)\n     *   .sortBy('age')\n     *   .map(function(o) {\n     *     return o.user + ' is ' + o.age;\n     *   })\n     *   .head()\n     *   .value();\n     * // => 'pebbles is 1'\n     */\n    function chain(value) {\n      var result = lodash(value);\n      result.__chain__ = true;\n      return result;\n    }\n\n    /**\n     * This method invokes `interceptor` and returns `value`. The interceptor\n     * is invoked with one argument; (value). The purpose of this method is to\n     * \"tap into\" a method chain sequence in order to modify intermediate results.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @param {*} value The value to provide to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * _([1, 2, 3])\n     *  .tap(function(array) {\n     *    // Mutate input array.\n     *    array.pop();\n     *  })\n     *  .reverse()\n     *  .value();\n     * // => [2, 1]\n     */\n    function tap(value, interceptor) {\n      interceptor(value);\n      return value;\n    }\n\n    /**\n     * This method is like `_.tap` except that it returns the result of `interceptor`.\n     * The purpose of this method is to \"pass thru\" values replacing intermediate\n     * results in a method chain sequence.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Seq\n     * @param {*} value The value to provide to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @returns {*} Returns the result of `interceptor`.\n     * @example\n     *\n     * _('  abc  ')\n     *  .chain()\n     *  .trim()\n     *  .thru(function(value) {\n     *    return [value];\n     *  })\n     *  .value();\n     * // => ['abc']\n     */\n    function thru(value, interceptor) {\n      return interceptor(value);\n    }\n\n    /**\n     * This method is the wrapper version of `_.at`.\n     *\n     * @name at\n     * @memberOf _\n     * @since 1.0.0\n     * @category Seq\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n     *\n     * _(object).at(['a[0].b.c', 'a[1]']).value();\n     * // => [3, 4]\n     */\n    var wrapperAt = flatRest(function(paths) {\n      var length = paths.length,\n          start = length ? paths[0] : 0,\n          value = this.__wrapped__,\n          interceptor = function(object) { return baseAt(object, paths); };\n\n      if (length > 1 || this.__actions__.length ||\n          !(value instanceof LazyWrapper) || !isIndex(start)) {\n        return this.thru(interceptor);\n      }\n      value = value.slice(start, +start + (length ? 1 : 0));\n      value.__actions__.push({\n        'func': thru,\n        'args': [interceptor],\n        'thisArg': undefined\n      });\n      return new LodashWrapper(value, this.__chain__).thru(function(array) {\n        if (length && !array.length) {\n          array.push(undefined);\n        }\n        return array;\n      });\n    });\n\n    /**\n     * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.\n     *\n     * @name chain\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 }\n     * ];\n     *\n     * // A sequence without explicit chaining.\n     * _(users).head();\n     * // => { 'user': 'barney', 'age': 36 }\n     *\n     * // A sequence with explicit chaining.\n     * _(users)\n     *   .chain()\n     *   .head()\n     *   .pick('user')\n     *   .value();\n     * // => { 'user': 'barney' }\n     */\n    function wrapperChain() {\n      return chain(this);\n    }\n\n    /**\n     * Executes the chain sequence and returns the wrapped result.\n     *\n     * @name commit\n     * @memberOf _\n     * @since 3.2.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2];\n     * var wrapped = _(array).push(3);\n     *\n     * console.log(array);\n     * // => [1, 2]\n     *\n     * wrapped = wrapped.commit();\n     * console.log(array);\n     * // => [1, 2, 3]\n     *\n     * wrapped.last();\n     * // => 3\n     *\n     * console.log(array);\n     * // => [1, 2, 3]\n     */\n    function wrapperCommit() {\n      return new LodashWrapper(this.value(), this.__chain__);\n    }\n\n    /**\n     * Gets the next value on a wrapped object following the\n     * [iterator protocol](https://mdn.io/iteration_protocols#iterator).\n     *\n     * @name next\n     * @memberOf _\n     * @since 4.0.0\n     * @category Seq\n     * @returns {Object} Returns the next iterator value.\n     * @example\n     *\n     * var wrapped = _([1, 2]);\n     *\n     * wrapped.next();\n     * // => { 'done': false, 'value': 1 }\n     *\n     * wrapped.next();\n     * // => { 'done': false, 'value': 2 }\n     *\n     * wrapped.next();\n     * // => { 'done': true, 'value': undefined }\n     */\n    function wrapperNext() {\n      if (this.__values__ === undefined) {\n        this.__values__ = toArray(this.value());\n      }\n      var done = this.__index__ >= this.__values__.length,\n          value = done ? undefined : this.__values__[this.__index__++];\n\n      return { 'done': done, 'value': value };\n    }\n\n    /**\n     * Enables the wrapper to be iterable.\n     *\n     * @name Symbol.iterator\n     * @memberOf _\n     * @since 4.0.0\n     * @category Seq\n     * @returns {Object} Returns the wrapper object.\n     * @example\n     *\n     * var wrapped = _([1, 2]);\n     *\n     * wrapped[Symbol.iterator]() === wrapped;\n     * // => true\n     *\n     * Array.from(wrapped);\n     * // => [1, 2]\n     */\n    function wrapperToIterator() {\n      return this;\n    }\n\n    /**\n     * Creates a clone of the chain sequence planting `value` as the wrapped value.\n     *\n     * @name plant\n     * @memberOf _\n     * @since 3.2.0\n     * @category Seq\n     * @param {*} value The value to plant.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var wrapped = _([1, 2]).map(square);\n     * var other = wrapped.plant([3, 4]);\n     *\n     * other.value();\n     * // => [9, 16]\n     *\n     * wrapped.value();\n     * // => [1, 4]\n     */\n    function wrapperPlant(value) {\n      var result,\n          parent = this;\n\n      while (parent instanceof baseLodash) {\n        var clone = wrapperClone(parent);\n        clone.__index__ = 0;\n        clone.__values__ = undefined;\n        if (result) {\n          previous.__wrapped__ = clone;\n        } else {\n          result = clone;\n        }\n        var previous = clone;\n        parent = parent.__wrapped__;\n      }\n      previous.__wrapped__ = value;\n      return result;\n    }\n\n    /**\n     * This method is the wrapper version of `_.reverse`.\n     *\n     * **Note:** This method mutates the wrapped array.\n     *\n     * @name reverse\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _(array).reverse().value()\n     * // => [3, 2, 1]\n     *\n     * console.log(array);\n     * // => [3, 2, 1]\n     */\n    function wrapperReverse() {\n      var value = this.__wrapped__;\n      if (value instanceof LazyWrapper) {\n        var wrapped = value;\n        if (this.__actions__.length) {\n          wrapped = new LazyWrapper(this);\n        }\n        wrapped = wrapped.reverse();\n        wrapped.__actions__.push({\n          'func': thru,\n          'args': [reverse],\n          'thisArg': undefined\n        });\n        return new LodashWrapper(wrapped, this.__chain__);\n      }\n      return this.thru(reverse);\n    }\n\n    /**\n     * Executes the chain sequence to resolve the unwrapped value.\n     *\n     * @name value\n     * @memberOf _\n     * @since 0.1.0\n     * @alias toJSON, valueOf\n     * @category Seq\n     * @returns {*} Returns the resolved unwrapped value.\n     * @example\n     *\n     * _([1, 2, 3]).value();\n     * // => [1, 2, 3]\n     */\n    function wrapperValue() {\n      return baseWrapperValue(this.__wrapped__, this.__actions__);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The corresponding value of\n     * each key is the number of times the key was returned by `iteratee`. The\n     * iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.countBy([6.1, 4.2, 6.3], Math.floor);\n     * // => { '4': 1, '6': 2 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.countBy(['one', 'two', 'three'], 'length');\n     * // => { '3': 2, '5': 1 }\n     */\n    var countBy = createAggregator(function(result, value, key) {\n      if (hasOwnProperty.call(result, key)) {\n        ++result[key];\n      } else {\n        baseAssignValue(result, key, 1);\n      }\n    });\n\n    /**\n     * Checks if `predicate` returns truthy for **all** elements of `collection`.\n     * Iteration is stopped once `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index|key, collection).\n     *\n     * **Note:** This method returns `true` for\n     * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because\n     * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of\n     * elements of empty collections.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`.\n     * @example\n     *\n     * _.every([true, 1, null, 'yes'], Boolean);\n     * // => false\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': false },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.every(users, { 'user': 'barney', 'active': false });\n     * // => false\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.every(users, ['active', false]);\n     * // => true\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.every(users, 'active');\n     * // => false\n     */\n    function every(collection, predicate, guard) {\n      var func = isArray(collection) ? arrayEvery : baseEvery;\n      if (guard && isIterateeCall(collection, predicate, guard)) {\n        predicate = undefined;\n      }\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Iterates over elements of `collection`, returning an array of all elements\n     * `predicate` returns truthy for. The predicate is invoked with three\n     * arguments: (value, index|key, collection).\n     *\n     * **Note:** Unlike `_.remove`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     * @see _.reject\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * _.filter(users, function(o) { return !o.active; });\n     * // => objects for ['fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.filter(users, { 'age': 36, 'active': true });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.filter(users, ['active', false]);\n     * // => objects for ['fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.filter(users, 'active');\n     * // => objects for ['barney']\n     */\n    function filter(collection, predicate) {\n      var func = isArray(collection) ? arrayFilter : baseFilter;\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Iterates over elements of `collection`, returning the first element\n     * `predicate` returns truthy for. The predicate is invoked with three\n     * arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36, 'active': true },\n     *   { 'user': 'fred',    'age': 40, 'active': false },\n     *   { 'user': 'pebbles', 'age': 1,  'active': true }\n     * ];\n     *\n     * _.find(users, function(o) { return o.age < 40; });\n     * // => object for 'barney'\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.find(users, { 'age': 1, 'active': true });\n     * // => object for 'pebbles'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.find(users, ['active', false]);\n     * // => object for 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.find(users, 'active');\n     * // => object for 'barney'\n     */\n    var find = createFind(findIndex);\n\n    /**\n     * This method is like `_.find` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=collection.length-1] The index to search from.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * _.findLast([1, 2, 3, 4], function(n) {\n     *   return n % 2 == 1;\n     * });\n     * // => 3\n     */\n    var findLast = createFind(findLastIndex);\n\n    /**\n     * Creates a flattened array of values by running each element in `collection`\n     * thru `iteratee` and flattening the mapped results. The iteratee is invoked\n     * with three arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [n, n];\n     * }\n     *\n     * _.flatMap([1, 2], duplicate);\n     * // => [1, 1, 2, 2]\n     */\n    function flatMap(collection, iteratee) {\n      return baseFlatten(map(collection, iteratee), 1);\n    }\n\n    /**\n     * This method is like `_.flatMap` except that it recursively flattens the\n     * mapped results.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [[[n, n]]];\n     * }\n     *\n     * _.flatMapDeep([1, 2], duplicate);\n     * // => [1, 1, 2, 2]\n     */\n    function flatMapDeep(collection, iteratee) {\n      return baseFlatten(map(collection, iteratee), INFINITY);\n    }\n\n    /**\n     * This method is like `_.flatMap` except that it recursively flattens the\n     * mapped results up to `depth` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {number} [depth=1] The maximum recursion depth.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [[[n, n]]];\n     * }\n     *\n     * _.flatMapDepth([1, 2], duplicate, 2);\n     * // => [[1, 1], [2, 2]]\n     */\n    function flatMapDepth(collection, iteratee, depth) {\n      depth = depth === undefined ? 1 : toInteger(depth);\n      return baseFlatten(map(collection, iteratee), depth);\n    }\n\n    /**\n     * Iterates over elements of `collection` and invokes `iteratee` for each element.\n     * The iteratee is invoked with three arguments: (value, index|key, collection).\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * **Note:** As with other \"Collections\" methods, objects with a \"length\"\n     * property are iterated like arrays. To avoid this behavior use `_.forIn`\n     * or `_.forOwn` for object iteration.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @alias each\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     * @see _.forEachRight\n     * @example\n     *\n     * _.forEach([1, 2], function(value) {\n     *   console.log(value);\n     * });\n     * // => Logs `1` then `2`.\n     *\n     * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n     */\n    function forEach(collection, iteratee) {\n      var func = isArray(collection) ? arrayEach : baseEach;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.forEach` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @alias eachRight\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     * @see _.forEach\n     * @example\n     *\n     * _.forEachRight([1, 2], function(value) {\n     *   console.log(value);\n     * });\n     * // => Logs `2` then `1`.\n     */\n    function forEachRight(collection, iteratee) {\n      var func = isArray(collection) ? arrayEachRight : baseEachRight;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The order of grouped values\n     * is determined by the order they occur in `collection`. The corresponding\n     * value of each key is an array of elements responsible for generating the\n     * key. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.groupBy([6.1, 4.2, 6.3], Math.floor);\n     * // => { '4': [4.2], '6': [6.1, 6.3] }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.groupBy(['one', 'two', 'three'], 'length');\n     * // => { '3': ['one', 'two'], '5': ['three'] }\n     */\n    var groupBy = createAggregator(function(result, value, key) {\n      if (hasOwnProperty.call(result, key)) {\n        result[key].push(value);\n      } else {\n        baseAssignValue(result, key, [value]);\n      }\n    });\n\n    /**\n     * Checks if `value` is in `collection`. If `collection` is a string, it's\n     * checked for a substring of `value`, otherwise\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * is used for equality comparisons. If `fromIndex` is negative, it's used as\n     * the offset from the end of `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n     * @returns {boolean} Returns `true` if `value` is found, else `false`.\n     * @example\n     *\n     * _.includes([1, 2, 3], 1);\n     * // => true\n     *\n     * _.includes([1, 2, 3], 1, 2);\n     * // => false\n     *\n     * _.includes({ 'a': 1, 'b': 2 }, 1);\n     * // => true\n     *\n     * _.includes('abcd', 'bc');\n     * // => true\n     */\n    function includes(collection, value, fromIndex, guard) {\n      collection = isArrayLike(collection) ? collection : values(collection);\n      fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;\n\n      var length = collection.length;\n      if (fromIndex < 0) {\n        fromIndex = nativeMax(length + fromIndex, 0);\n      }\n      return isString(collection)\n        ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)\n        : (!!length && baseIndexOf(collection, value, fromIndex) > -1);\n    }\n\n    /**\n     * Invokes the method at `path` of each element in `collection`, returning\n     * an array of the results of each invoked method. Any additional arguments\n     * are provided to each invoked method. If `path` is a function, it's invoked\n     * for, and `this` bound to, each element in `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Array|Function|string} path The path of the method to invoke or\n     *  the function invoked per iteration.\n     * @param {...*} [args] The arguments to invoke each method with.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');\n     * // => [[1, 5, 7], [1, 2, 3]]\n     *\n     * _.invokeMap([123, 456], String.prototype.split, '');\n     * // => [['1', '2', '3'], ['4', '5', '6']]\n     */\n    var invokeMap = baseRest(function(collection, path, args) {\n      var index = -1,\n          isFunc = typeof path == 'function',\n          result = isArrayLike(collection) ? Array(collection.length) : [];\n\n      baseEach(collection, function(value) {\n        result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);\n      });\n      return result;\n    });\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The corresponding value of\n     * each key is the last element responsible for generating the key. The\n     * iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * var array = [\n     *   { 'dir': 'left', 'code': 97 },\n     *   { 'dir': 'right', 'code': 100 }\n     * ];\n     *\n     * _.keyBy(array, function(o) {\n     *   return String.fromCharCode(o.code);\n     * });\n     * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }\n     *\n     * _.keyBy(array, 'dir');\n     * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }\n     */\n    var keyBy = createAggregator(function(result, value, key) {\n      baseAssignValue(result, key, value);\n    });\n\n    /**\n     * Creates an array of values by running each element in `collection` thru\n     * `iteratee`. The iteratee is invoked with three arguments:\n     * (value, index|key, collection).\n     *\n     * Many lodash methods are guarded to work as iteratees for methods like\n     * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.\n     *\n     * The guarded methods are:\n     * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,\n     * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,\n     * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,\n     * `template`, `trim`, `trimEnd`, `trimStart`, and `words`\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new mapped array.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * _.map([4, 8], square);\n     * // => [16, 64]\n     *\n     * _.map({ 'a': 4, 'b': 8 }, square);\n     * // => [16, 64] (iteration order is not guaranteed)\n     *\n     * var users = [\n     *   { 'user': 'barney' },\n     *   { 'user': 'fred' }\n     * ];\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.map(users, 'user');\n     * // => ['barney', 'fred']\n     */\n    function map(collection, iteratee) {\n      var func = isArray(collection) ? arrayMap : baseMap;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.sortBy` except that it allows specifying the sort\n     * orders of the iteratees to sort by. If `orders` is unspecified, all values\n     * are sorted in ascending order. Otherwise, specify an order of \"desc\" for\n     * descending or \"asc\" for ascending sort order of corresponding values.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]\n     *  The iteratees to sort by.\n     * @param {string[]} [orders] The sort orders of `iteratees`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'fred',   'age': 48 },\n     *   { 'user': 'barney', 'age': 34 },\n     *   { 'user': 'fred',   'age': 40 },\n     *   { 'user': 'barney', 'age': 36 }\n     * ];\n     *\n     * // Sort by `user` in ascending order and by `age` in descending order.\n     * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);\n     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n     */\n    function orderBy(collection, iteratees, orders, guard) {\n      if (collection == null) {\n        return [];\n      }\n      if (!isArray(iteratees)) {\n        iteratees = iteratees == null ? [] : [iteratees];\n      }\n      orders = guard ? undefined : orders;\n      if (!isArray(orders)) {\n        orders = orders == null ? [] : [orders];\n      }\n      return baseOrderBy(collection, iteratees, orders);\n    }\n\n    /**\n     * Creates an array of elements split into two groups, the first of which\n     * contains elements `predicate` returns truthy for, the second of which\n     * contains elements `predicate` returns falsey for. The predicate is\n     * invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the array of grouped elements.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36, 'active': false },\n     *   { 'user': 'fred',    'age': 40, 'active': true },\n     *   { 'user': 'pebbles', 'age': 1,  'active': false }\n     * ];\n     *\n     * _.partition(users, function(o) { return o.active; });\n     * // => objects for [['fred'], ['barney', 'pebbles']]\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.partition(users, { 'age': 1, 'active': false });\n     * // => objects for [['pebbles'], ['barney', 'fred']]\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.partition(users, ['active', false]);\n     * // => objects for [['barney', 'pebbles'], ['fred']]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.partition(users, 'active');\n     * // => objects for [['fred'], ['barney', 'pebbles']]\n     */\n    var partition = createAggregator(function(result, value, key) {\n      result[key ? 0 : 1].push(value);\n    }, function() { return [[], []]; });\n\n    /**\n     * Reduces `collection` to a value which is the accumulated result of running\n     * each element in `collection` thru `iteratee`, where each successive\n     * invocation is supplied the return value of the previous. If `accumulator`\n     * is not given, the first element of `collection` is used as the initial\n     * value. The iteratee is invoked with four arguments:\n     * (accumulator, value, index|key, collection).\n     *\n     * Many lodash methods are guarded to work as iteratees for methods like\n     * `_.reduce`, `_.reduceRight`, and `_.transform`.\n     *\n     * The guarded methods are:\n     * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,\n     * and `sortBy`\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @returns {*} Returns the accumulated value.\n     * @see _.reduceRight\n     * @example\n     *\n     * _.reduce([1, 2], function(sum, n) {\n     *   return sum + n;\n     * }, 0);\n     * // => 3\n     *\n     * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n     *   (result[value] || (result[value] = [])).push(key);\n     *   return result;\n     * }, {});\n     * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)\n     */\n    function reduce(collection, iteratee, accumulator) {\n      var func = isArray(collection) ? arrayReduce : baseReduce,\n          initAccum = arguments.length < 3;\n\n      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);\n    }\n\n    /**\n     * This method is like `_.reduce` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @returns {*} Returns the accumulated value.\n     * @see _.reduce\n     * @example\n     *\n     * var array = [[0, 1], [2, 3], [4, 5]];\n     *\n     * _.reduceRight(array, function(flattened, other) {\n     *   return flattened.concat(other);\n     * }, []);\n     * // => [4, 5, 2, 3, 0, 1]\n     */\n    function reduceRight(collection, iteratee, accumulator) {\n      var func = isArray(collection) ? arrayReduceRight : baseReduce,\n          initAccum = arguments.length < 3;\n\n      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);\n    }\n\n    /**\n     * The opposite of `_.filter`; this method returns the elements of `collection`\n     * that `predicate` does **not** return truthy for.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     * @see _.filter\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': false },\n     *   { 'user': 'fred',   'age': 40, 'active': true }\n     * ];\n     *\n     * _.reject(users, function(o) { return !o.active; });\n     * // => objects for ['fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.reject(users, { 'age': 40, 'active': true });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.reject(users, ['active', false]);\n     * // => objects for ['fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.reject(users, 'active');\n     * // => objects for ['barney']\n     */\n    function reject(collection, predicate) {\n      var func = isArray(collection) ? arrayFilter : baseFilter;\n      return func(collection, negate(getIteratee(predicate, 3)));\n    }\n\n    /**\n     * Gets a random element from `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to sample.\n     * @returns {*} Returns the random element.\n     * @example\n     *\n     * _.sample([1, 2, 3, 4]);\n     * // => 2\n     */\n    function sample(collection) {\n      var func = isArray(collection) ? arraySample : baseSample;\n      return func(collection);\n    }\n\n    /**\n     * Gets `n` random elements at unique keys from `collection` up to the\n     * size of `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to sample.\n     * @param {number} [n=1] The number of elements to sample.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the random elements.\n     * @example\n     *\n     * _.sampleSize([1, 2, 3], 2);\n     * // => [3, 1]\n     *\n     * _.sampleSize([1, 2, 3], 4);\n     * // => [2, 3, 1]\n     */\n    function sampleSize(collection, n, guard) {\n      if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) {\n        n = 1;\n      } else {\n        n = toInteger(n);\n      }\n      var func = isArray(collection) ? arraySampleSize : baseSampleSize;\n      return func(collection, n);\n    }\n\n    /**\n     * Creates an array of shuffled values, using a version of the\n     * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     * @example\n     *\n     * _.shuffle([1, 2, 3, 4]);\n     * // => [4, 1, 3, 2]\n     */\n    function shuffle(collection) {\n      var func = isArray(collection) ? arrayShuffle : baseShuffle;\n      return func(collection);\n    }\n\n    /**\n     * Gets the size of `collection` by returning its length for array-like\n     * values or the number of own enumerable string keyed properties for objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to inspect.\n     * @returns {number} Returns the collection size.\n     * @example\n     *\n     * _.size([1, 2, 3]);\n     * // => 3\n     *\n     * _.size({ 'a': 1, 'b': 2 });\n     * // => 2\n     *\n     * _.size('pebbles');\n     * // => 7\n     */\n    function size(collection) {\n      if (collection == null) {\n        return 0;\n      }\n      if (isArrayLike(collection)) {\n        return isString(collection) ? stringSize(collection) : collection.length;\n      }\n      var tag = getTag(collection);\n      if (tag == mapTag || tag == setTag) {\n        return collection.size;\n      }\n      return baseKeys(collection).length;\n    }\n\n    /**\n     * Checks if `predicate` returns truthy for **any** element of `collection`.\n     * Iteration is stopped once `predicate` returns truthy. The predicate is\n     * invoked with three arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     * @example\n     *\n     * _.some([null, 0, 'yes', false], Boolean);\n     * // => true\n     *\n     * var users = [\n     *   { 'user': 'barney', 'active': true },\n     *   { 'user': 'fred',   'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.some(users, { 'user': 'barney', 'active': false });\n     * // => false\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.some(users, ['active', false]);\n     * // => true\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.some(users, 'active');\n     * // => true\n     */\n    function some(collection, predicate, guard) {\n      var func = isArray(collection) ? arraySome : baseSome;\n      if (guard && isIterateeCall(collection, predicate, guard)) {\n        predicate = undefined;\n      }\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Creates an array of elements, sorted in ascending order by the results of\n     * running each element in a collection thru each iteratee. This method\n     * performs a stable sort, that is, it preserves the original sort order of\n     * equal elements. The iteratees are invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {...(Function|Function[])} [iteratees=[_.identity]]\n     *  The iteratees to sort by.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'fred',   'age': 48 },\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 },\n     *   { 'user': 'barney', 'age': 34 }\n     * ];\n     *\n     * _.sortBy(users, [function(o) { return o.user; }]);\n     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n     *\n     * _.sortBy(users, ['user', 'age']);\n     * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]\n     */\n    var sortBy = baseRest(function(collection, iteratees) {\n      if (collection == null) {\n        return [];\n      }\n      var length = iteratees.length;\n      if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {\n        iteratees = [];\n      } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {\n        iteratees = [iteratees[0]];\n      }\n      return baseOrderBy(collection, baseFlatten(iteratees, 1), []);\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Gets the timestamp of the number of milliseconds that have elapsed since\n     * the Unix epoch (1 January 1970 00:00:00 UTC).\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Date\n     * @returns {number} Returns the timestamp.\n     * @example\n     *\n     * _.defer(function(stamp) {\n     *   console.log(_.now() - stamp);\n     * }, _.now());\n     * // => Logs the number of milliseconds it took for the deferred invocation.\n     */\n    var now = ctxNow || function() {\n      return root.Date.now();\n    };\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The opposite of `_.before`; this method creates a function that invokes\n     * `func` once it's called `n` or more times.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {number} n The number of calls before `func` is invoked.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var saves = ['profile', 'settings'];\n     *\n     * var done = _.after(saves.length, function() {\n     *   console.log('done saving!');\n     * });\n     *\n     * _.forEach(saves, function(type) {\n     *   asyncSave({ 'type': type, 'complete': done });\n     * });\n     * // => Logs 'done saving!' after the two async saves have completed.\n     */\n    function after(n, func) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      n = toInteger(n);\n      return function() {\n        if (--n < 1) {\n          return func.apply(this, arguments);\n        }\n      };\n    }\n\n    /**\n     * Creates a function that invokes `func`, with up to `n` arguments,\n     * ignoring any additional arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to cap arguments for.\n     * @param {number} [n=func.length] The arity cap.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new capped function.\n     * @example\n     *\n     * _.map(['6', '8', '10'], _.ary(parseInt, 1));\n     * // => [6, 8, 10]\n     */\n    function ary(func, n, guard) {\n      n = guard ? undefined : n;\n      n = (func && n == null) ? func.length : n;\n      return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);\n    }\n\n    /**\n     * Creates a function that invokes `func`, with the `this` binding and arguments\n     * of the created function, while it's called less than `n` times. Subsequent\n     * calls to the created function return the result of the last `func` invocation.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {number} n The number of calls at which `func` is no longer invoked.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * jQuery(element).on('click', _.before(5, addContactToList));\n     * // => Allows adding up to 4 contacts to the list.\n     */\n    function before(n, func) {\n      var result;\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      n = toInteger(n);\n      return function() {\n        if (--n > 0) {\n          result = func.apply(this, arguments);\n        }\n        if (n <= 1) {\n          func = undefined;\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of `thisArg`\n     * and `partials` prepended to the arguments it receives.\n     *\n     * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,\n     * may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** Unlike native `Function#bind`, this method doesn't set the \"length\"\n     * property of bound functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to bind.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * function greet(greeting, punctuation) {\n     *   return greeting + ' ' + this.user + punctuation;\n     * }\n     *\n     * var object = { 'user': 'fred' };\n     *\n     * var bound = _.bind(greet, object, 'hi');\n     * bound('!');\n     * // => 'hi fred!'\n     *\n     * // Bound with placeholders.\n     * var bound = _.bind(greet, object, _, '!');\n     * bound('hi');\n     * // => 'hi fred!'\n     */\n    var bind = baseRest(function(func, thisArg, partials) {\n      var bitmask = WRAP_BIND_FLAG;\n      if (partials.length) {\n        var holders = replaceHolders(partials, getHolder(bind));\n        bitmask |= WRAP_PARTIAL_FLAG;\n      }\n      return createWrap(func, bitmask, thisArg, partials, holders);\n    });\n\n    /**\n     * Creates a function that invokes the method at `object[key]` with `partials`\n     * prepended to the arguments it receives.\n     *\n     * This method differs from `_.bind` by allowing bound functions to reference\n     * methods that may be redefined or don't yet exist. See\n     * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)\n     * for more details.\n     *\n     * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.10.0\n     * @category Function\n     * @param {Object} object The object to invoke the method on.\n     * @param {string} key The key of the method.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * var object = {\n     *   'user': 'fred',\n     *   'greet': function(greeting, punctuation) {\n     *     return greeting + ' ' + this.user + punctuation;\n     *   }\n     * };\n     *\n     * var bound = _.bindKey(object, 'greet', 'hi');\n     * bound('!');\n     * // => 'hi fred!'\n     *\n     * object.greet = function(greeting, punctuation) {\n     *   return greeting + 'ya ' + this.user + punctuation;\n     * };\n     *\n     * bound('!');\n     * // => 'hiya fred!'\n     *\n     * // Bound with placeholders.\n     * var bound = _.bindKey(object, 'greet', _, '!');\n     * bound('hi');\n     * // => 'hiya fred!'\n     */\n    var bindKey = baseRest(function(object, key, partials) {\n      var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;\n      if (partials.length) {\n        var holders = replaceHolders(partials, getHolder(bindKey));\n        bitmask |= WRAP_PARTIAL_FLAG;\n      }\n      return createWrap(key, bitmask, object, partials, holders);\n    });\n\n    /**\n     * Creates a function that accepts arguments of `func` and either invokes\n     * `func` returning its result, if at least `arity` number of arguments have\n     * been provided, or returns a function that accepts the remaining `func`\n     * arguments, and so on. The arity of `func` may be specified if `func.length`\n     * is not sufficient.\n     *\n     * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,\n     * may be used as a placeholder for provided arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of curried functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Function\n     * @param {Function} func The function to curry.\n     * @param {number} [arity=func.length] The arity of `func`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new curried function.\n     * @example\n     *\n     * var abc = function(a, b, c) {\n     *   return [a, b, c];\n     * };\n     *\n     * var curried = _.curry(abc);\n     *\n     * curried(1)(2)(3);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2)(3);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2, 3);\n     * // => [1, 2, 3]\n     *\n     * // Curried with placeholders.\n     * curried(1)(_, 3)(2);\n     * // => [1, 2, 3]\n     */\n    function curry(func, arity, guard) {\n      arity = guard ? undefined : arity;\n      var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n      result.placeholder = curry.placeholder;\n      return result;\n    }\n\n    /**\n     * This method is like `_.curry` except that arguments are applied to `func`\n     * in the manner of `_.partialRight` instead of `_.partial`.\n     *\n     * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for provided arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of curried functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to curry.\n     * @param {number} [arity=func.length] The arity of `func`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new curried function.\n     * @example\n     *\n     * var abc = function(a, b, c) {\n     *   return [a, b, c];\n     * };\n     *\n     * var curried = _.curryRight(abc);\n     *\n     * curried(3)(2)(1);\n     * // => [1, 2, 3]\n     *\n     * curried(2, 3)(1);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2, 3);\n     * // => [1, 2, 3]\n     *\n     * // Curried with placeholders.\n     * curried(3)(1, _)(2);\n     * // => [1, 2, 3]\n     */\n    function curryRight(func, arity, guard) {\n      arity = guard ? undefined : arity;\n      var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n      result.placeholder = curryRight.placeholder;\n      return result;\n    }\n\n    /**\n     * Creates a debounced function that delays invoking `func` until after `wait`\n     * milliseconds have elapsed since the last time the debounced function was\n     * invoked. The debounced function comes with a `cancel` method to cancel\n     * delayed `func` invocations and a `flush` method to immediately invoke them.\n     * Provide `options` to indicate whether `func` should be invoked on the\n     * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n     * with the last arguments provided to the debounced function. Subsequent\n     * calls to the debounced function return the result of the last `func`\n     * invocation.\n     *\n     * **Note:** If `leading` and `trailing` options are `true`, `func` is\n     * invoked on the trailing edge of the timeout only if the debounced function\n     * is invoked more than once during the `wait` timeout.\n     *\n     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n     * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n     *\n     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n     * for details over the differences between `_.debounce` and `_.throttle`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to debounce.\n     * @param {number} [wait=0] The number of milliseconds to delay.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.leading=false]\n     *  Specify invoking on the leading edge of the timeout.\n     * @param {number} [options.maxWait]\n     *  The maximum time `func` is allowed to be delayed before it's invoked.\n     * @param {boolean} [options.trailing=true]\n     *  Specify invoking on the trailing edge of the timeout.\n     * @returns {Function} Returns the new debounced function.\n     * @example\n     *\n     * // Avoid costly calculations while the window size is in flux.\n     * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n     *\n     * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n     * jQuery(element).on('click', _.debounce(sendMail, 300, {\n     *   'leading': true,\n     *   'trailing': false\n     * }));\n     *\n     * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n     * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n     * var source = new EventSource('/stream');\n     * jQuery(source).on('message', debounced);\n     *\n     * // Cancel the trailing debounced invocation.\n     * jQuery(window).on('popstate', debounced.cancel);\n     */\n    function debounce(func, wait, options) {\n      var lastArgs,\n          lastThis,\n          maxWait,\n          result,\n          timerId,\n          lastCallTime,\n          lastInvokeTime = 0,\n          leading = false,\n          maxing = false,\n          trailing = true;\n\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      wait = toNumber(wait) || 0;\n      if (isObject(options)) {\n        leading = !!options.leading;\n        maxing = 'maxWait' in options;\n        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n        trailing = 'trailing' in options ? !!options.trailing : trailing;\n      }\n\n      function invokeFunc(time) {\n        var args = lastArgs,\n            thisArg = lastThis;\n\n        lastArgs = lastThis = undefined;\n        lastInvokeTime = time;\n        result = func.apply(thisArg, args);\n        return result;\n      }\n\n      function leadingEdge(time) {\n        // Reset any `maxWait` timer.\n        lastInvokeTime = time;\n        // Start the timer for the trailing edge.\n        timerId = setTimeout(timerExpired, wait);\n        // Invoke the leading edge.\n        return leading ? invokeFunc(time) : result;\n      }\n\n      function remainingWait(time) {\n        var timeSinceLastCall = time - lastCallTime,\n            timeSinceLastInvoke = time - lastInvokeTime,\n            result = wait - timeSinceLastCall;\n\n        return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n      }\n\n      function shouldInvoke(time) {\n        var timeSinceLastCall = time - lastCallTime,\n            timeSinceLastInvoke = time - lastInvokeTime;\n\n        // Either this is the first call, activity has stopped and we're at the\n        // trailing edge, the system time has gone backwards and we're treating\n        // it as the trailing edge, or we've hit the `maxWait` limit.\n        return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n          (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n      }\n\n      function timerExpired() {\n        var time = now();\n        if (shouldInvoke(time)) {\n          return trailingEdge(time);\n        }\n        // Restart the timer.\n        timerId = setTimeout(timerExpired, remainingWait(time));\n      }\n\n      function trailingEdge(time) {\n        timerId = undefined;\n\n        // Only invoke if we have `lastArgs` which means `func` has been\n        // debounced at least once.\n        if (trailing && lastArgs) {\n          return invokeFunc(time);\n        }\n        lastArgs = lastThis = undefined;\n        return result;\n      }\n\n      function cancel() {\n        if (timerId !== undefined) {\n          clearTimeout(timerId);\n        }\n        lastInvokeTime = 0;\n        lastArgs = lastCallTime = lastThis = timerId = undefined;\n      }\n\n      function flush() {\n        return timerId === undefined ? result : trailingEdge(now());\n      }\n\n      function debounced() {\n        var time = now(),\n            isInvoking = shouldInvoke(time);\n\n        lastArgs = arguments;\n        lastThis = this;\n        lastCallTime = time;\n\n        if (isInvoking) {\n          if (timerId === undefined) {\n            return leadingEdge(lastCallTime);\n          }\n          if (maxing) {\n            // Handle invocations in a tight loop.\n            timerId = setTimeout(timerExpired, wait);\n            return invokeFunc(lastCallTime);\n          }\n        }\n        if (timerId === undefined) {\n          timerId = setTimeout(timerExpired, wait);\n        }\n        return result;\n      }\n      debounced.cancel = cancel;\n      debounced.flush = flush;\n      return debounced;\n    }\n\n    /**\n     * Defers invoking the `func` until the current call stack has cleared. Any\n     * additional arguments are provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to defer.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {number} Returns the timer id.\n     * @example\n     *\n     * _.defer(function(text) {\n     *   console.log(text);\n     * }, 'deferred');\n     * // => Logs 'deferred' after one millisecond.\n     */\n    var defer = baseRest(function(func, args) {\n      return baseDelay(func, 1, args);\n    });\n\n    /**\n     * Invokes `func` after `wait` milliseconds. Any additional arguments are\n     * provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {number} Returns the timer id.\n     * @example\n     *\n     * _.delay(function(text) {\n     *   console.log(text);\n     * }, 1000, 'later');\n     * // => Logs 'later' after one second.\n     */\n    var delay = baseRest(function(func, wait, args) {\n      return baseDelay(func, toNumber(wait) || 0, args);\n    });\n\n    /**\n     * Creates a function that invokes `func` with arguments reversed.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to flip arguments for.\n     * @returns {Function} Returns the new flipped function.\n     * @example\n     *\n     * var flipped = _.flip(function() {\n     *   return _.toArray(arguments);\n     * });\n     *\n     * flipped('a', 'b', 'c', 'd');\n     * // => ['d', 'c', 'b', 'a']\n     */\n    function flip(func) {\n      return createWrap(func, WRAP_FLIP_FLAG);\n    }\n\n    /**\n     * Creates a function that memoizes the result of `func`. If `resolver` is\n     * provided, it determines the cache key for storing the result based on the\n     * arguments provided to the memoized function. By default, the first argument\n     * provided to the memoized function is used as the map cache key. The `func`\n     * is invoked with the `this` binding of the memoized function.\n     *\n     * **Note:** The cache is exposed as the `cache` property on the memoized\n     * function. Its creation may be customized by replacing the `_.memoize.Cache`\n     * constructor with one whose instances implement the\n     * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n     * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to have its output memoized.\n     * @param {Function} [resolver] The function to resolve the cache key.\n     * @returns {Function} Returns the new memoized function.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     * var other = { 'c': 3, 'd': 4 };\n     *\n     * var values = _.memoize(_.values);\n     * values(object);\n     * // => [1, 2]\n     *\n     * values(other);\n     * // => [3, 4]\n     *\n     * object.a = 2;\n     * values(object);\n     * // => [1, 2]\n     *\n     * // Modify the result cache.\n     * values.cache.set(object, ['a', 'b']);\n     * values(object);\n     * // => ['a', 'b']\n     *\n     * // Replace `_.memoize.Cache`.\n     * _.memoize.Cache = WeakMap;\n     */\n    function memoize(func, resolver) {\n      if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var memoized = function() {\n        var args = arguments,\n            key = resolver ? resolver.apply(this, args) : args[0],\n            cache = memoized.cache;\n\n        if (cache.has(key)) {\n          return cache.get(key);\n        }\n        var result = func.apply(this, args);\n        memoized.cache = cache.set(key, result) || cache;\n        return result;\n      };\n      memoized.cache = new (memoize.Cache || MapCache);\n      return memoized;\n    }\n\n    // Expose `MapCache`.\n    memoize.Cache = MapCache;\n\n    /**\n     * Creates a function that negates the result of the predicate `func`. The\n     * `func` predicate is invoked with the `this` binding and arguments of the\n     * created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} predicate The predicate to negate.\n     * @returns {Function} Returns the new negated function.\n     * @example\n     *\n     * function isEven(n) {\n     *   return n % 2 == 0;\n     * }\n     *\n     * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));\n     * // => [1, 3, 5]\n     */\n    function negate(predicate) {\n      if (typeof predicate != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return function() {\n        var args = arguments;\n        switch (args.length) {\n          case 0: return !predicate.call(this);\n          case 1: return !predicate.call(this, args[0]);\n          case 2: return !predicate.call(this, args[0], args[1]);\n          case 3: return !predicate.call(this, args[0], args[1], args[2]);\n        }\n        return !predicate.apply(this, args);\n      };\n    }\n\n    /**\n     * Creates a function that is restricted to invoking `func` once. Repeat calls\n     * to the function return the value of the first invocation. The `func` is\n     * invoked with the `this` binding and arguments of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var initialize = _.once(createApplication);\n     * initialize();\n     * initialize();\n     * // => `createApplication` is invoked once\n     */\n    function once(func) {\n      return before(2, func);\n    }\n\n    /**\n     * Creates a function that invokes `func` with its arguments transformed.\n     *\n     * @static\n     * @since 4.0.0\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to wrap.\n     * @param {...(Function|Function[])} [transforms=[_.identity]]\n     *  The argument transforms.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * function doubled(n) {\n     *   return n * 2;\n     * }\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var func = _.overArgs(function(x, y) {\n     *   return [x, y];\n     * }, [square, doubled]);\n     *\n     * func(9, 3);\n     * // => [81, 6]\n     *\n     * func(10, 5);\n     * // => [100, 10]\n     */\n    var overArgs = castRest(function(func, transforms) {\n      transforms = (transforms.length == 1 && isArray(transforms[0]))\n        ? arrayMap(transforms[0], baseUnary(getIteratee()))\n        : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));\n\n      var funcsLength = transforms.length;\n      return baseRest(function(args) {\n        var index = -1,\n            length = nativeMin(args.length, funcsLength);\n\n        while (++index < length) {\n          args[index] = transforms[index].call(this, args[index]);\n        }\n        return apply(func, this, args);\n      });\n    });\n\n    /**\n     * Creates a function that invokes `func` with `partials` prepended to the\n     * arguments it receives. This method is like `_.bind` except it does **not**\n     * alter the `this` binding.\n     *\n     * The `_.partial.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of partially\n     * applied functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.2.0\n     * @category Function\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * function greet(greeting, name) {\n     *   return greeting + ' ' + name;\n     * }\n     *\n     * var sayHelloTo = _.partial(greet, 'hello');\n     * sayHelloTo('fred');\n     * // => 'hello fred'\n     *\n     * // Partially applied with placeholders.\n     * var greetFred = _.partial(greet, _, 'fred');\n     * greetFred('hi');\n     * // => 'hi fred'\n     */\n    var partial = baseRest(function(func, partials) {\n      var holders = replaceHolders(partials, getHolder(partial));\n      return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);\n    });\n\n    /**\n     * This method is like `_.partial` except that partially applied arguments\n     * are appended to the arguments it receives.\n     *\n     * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of partially\n     * applied functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Function\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * function greet(greeting, name) {\n     *   return greeting + ' ' + name;\n     * }\n     *\n     * var greetFred = _.partialRight(greet, 'fred');\n     * greetFred('hi');\n     * // => 'hi fred'\n     *\n     * // Partially applied with placeholders.\n     * var sayHelloTo = _.partialRight(greet, 'hello', _);\n     * sayHelloTo('fred');\n     * // => 'hello fred'\n     */\n    var partialRight = baseRest(function(func, partials) {\n      var holders = replaceHolders(partials, getHolder(partialRight));\n      return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders);\n    });\n\n    /**\n     * Creates a function that invokes `func` with arguments arranged according\n     * to the specified `indexes` where the argument value at the first index is\n     * provided as the first argument, the argument value at the second index is\n     * provided as the second argument, and so on.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to rearrange arguments for.\n     * @param {...(number|number[])} indexes The arranged argument indexes.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var rearged = _.rearg(function(a, b, c) {\n     *   return [a, b, c];\n     * }, [2, 0, 1]);\n     *\n     * rearged('b', 'c', 'a')\n     * // => ['a', 'b', 'c']\n     */\n    var rearg = flatRest(function(func, indexes) {\n      return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);\n    });\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of the\n     * created function and arguments from `start` and beyond provided as\n     * an array.\n     *\n     * **Note:** This method is based on the\n     * [rest parameter](https://mdn.io/rest_parameters).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to apply a rest parameter to.\n     * @param {number} [start=func.length-1] The start position of the rest parameter.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var say = _.rest(function(what, names) {\n     *   return what + ' ' + _.initial(names).join(', ') +\n     *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);\n     * });\n     *\n     * say('hello', 'fred', 'barney', 'pebbles');\n     * // => 'hello fred, barney, & pebbles'\n     */\n    function rest(func, start) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      start = start === undefined ? start : toInteger(start);\n      return baseRest(func, start);\n    }\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of the\n     * create function and an array of arguments much like\n     * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).\n     *\n     * **Note:** This method is based on the\n     * [spread operator](https://mdn.io/spread_operator).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Function\n     * @param {Function} func The function to spread arguments over.\n     * @param {number} [start=0] The start position of the spread.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var say = _.spread(function(who, what) {\n     *   return who + ' says ' + what;\n     * });\n     *\n     * say(['fred', 'hello']);\n     * // => 'fred says hello'\n     *\n     * var numbers = Promise.all([\n     *   Promise.resolve(40),\n     *   Promise.resolve(36)\n     * ]);\n     *\n     * numbers.then(_.spread(function(x, y) {\n     *   return x + y;\n     * }));\n     * // => a Promise of 76\n     */\n    function spread(func, start) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      start = start == null ? 0 : nativeMax(toInteger(start), 0);\n      return baseRest(function(args) {\n        var array = args[start],\n            otherArgs = castSlice(args, 0, start);\n\n        if (array) {\n          arrayPush(otherArgs, array);\n        }\n        return apply(func, this, otherArgs);\n      });\n    }\n\n    /**\n     * Creates a throttled function that only invokes `func` at most once per\n     * every `wait` milliseconds. The throttled function comes with a `cancel`\n     * method to cancel delayed `func` invocations and a `flush` method to\n     * immediately invoke them. Provide `options` to indicate whether `func`\n     * should be invoked on the leading and/or trailing edge of the `wait`\n     * timeout. The `func` is invoked with the last arguments provided to the\n     * throttled function. Subsequent calls to the throttled function return the\n     * result of the last `func` invocation.\n     *\n     * **Note:** If `leading` and `trailing` options are `true`, `func` is\n     * invoked on the trailing edge of the timeout only if the throttled function\n     * is invoked more than once during the `wait` timeout.\n     *\n     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n     * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n     *\n     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n     * for details over the differences between `_.throttle` and `_.debounce`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to throttle.\n     * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.leading=true]\n     *  Specify invoking on the leading edge of the timeout.\n     * @param {boolean} [options.trailing=true]\n     *  Specify invoking on the trailing edge of the timeout.\n     * @returns {Function} Returns the new throttled function.\n     * @example\n     *\n     * // Avoid excessively updating the position while scrolling.\n     * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n     *\n     * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n     * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n     * jQuery(element).on('click', throttled);\n     *\n     * // Cancel the trailing throttled invocation.\n     * jQuery(window).on('popstate', throttled.cancel);\n     */\n    function throttle(func, wait, options) {\n      var leading = true,\n          trailing = true;\n\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      if (isObject(options)) {\n        leading = 'leading' in options ? !!options.leading : leading;\n        trailing = 'trailing' in options ? !!options.trailing : trailing;\n      }\n      return debounce(func, wait, {\n        'leading': leading,\n        'maxWait': wait,\n        'trailing': trailing\n      });\n    }\n\n    /**\n     * Creates a function that accepts up to one argument, ignoring any\n     * additional arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to cap arguments for.\n     * @returns {Function} Returns the new capped function.\n     * @example\n     *\n     * _.map(['6', '8', '10'], _.unary(parseInt));\n     * // => [6, 8, 10]\n     */\n    function unary(func) {\n      return ary(func, 1);\n    }\n\n    /**\n     * Creates a function that provides `value` to `wrapper` as its first\n     * argument. Any additional arguments provided to the function are appended\n     * to those provided to the `wrapper`. The wrapper is invoked with the `this`\n     * binding of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {*} value The value to wrap.\n     * @param {Function} [wrapper=identity] The wrapper function.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var p = _.wrap(_.escape, function(func, text) {\n     *   return '<p>' + func(text) + '</p>';\n     * });\n     *\n     * p('fred, barney, & pebbles');\n     * // => '<p>fred, barney, &amp; pebbles</p>'\n     */\n    function wrap(value, wrapper) {\n      return partial(castFunction(wrapper), value);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Casts `value` as an array if it's not one.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.4.0\n     * @category Lang\n     * @param {*} value The value to inspect.\n     * @returns {Array} Returns the cast array.\n     * @example\n     *\n     * _.castArray(1);\n     * // => [1]\n     *\n     * _.castArray({ 'a': 1 });\n     * // => [{ 'a': 1 }]\n     *\n     * _.castArray('abc');\n     * // => ['abc']\n     *\n     * _.castArray(null);\n     * // => [null]\n     *\n     * _.castArray(undefined);\n     * // => [undefined]\n     *\n     * _.castArray();\n     * // => []\n     *\n     * var array = [1, 2, 3];\n     * console.log(_.castArray(array) === array);\n     * // => true\n     */\n    function castArray() {\n      if (!arguments.length) {\n        return [];\n      }\n      var value = arguments[0];\n      return isArray(value) ? value : [value];\n    }\n\n    /**\n     * Creates a shallow clone of `value`.\n     *\n     * **Note:** This method is loosely based on the\n     * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)\n     * and supports cloning arrays, array buffers, booleans, date objects, maps,\n     * numbers, `Object` objects, regexes, sets, strings, symbols, and typed\n     * arrays. The own enumerable properties of `arguments` objects are cloned\n     * as plain objects. An empty object is returned for uncloneable values such\n     * as error objects, functions, DOM nodes, and WeakMaps.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @returns {*} Returns the cloned value.\n     * @see _.cloneDeep\n     * @example\n     *\n     * var objects = [{ 'a': 1 }, { 'b': 2 }];\n     *\n     * var shallow = _.clone(objects);\n     * console.log(shallow[0] === objects[0]);\n     * // => true\n     */\n    function clone(value) {\n      return baseClone(value, CLONE_SYMBOLS_FLAG);\n    }\n\n    /**\n     * This method is like `_.clone` except that it accepts `customizer` which\n     * is invoked to produce the cloned value. If `customizer` returns `undefined`,\n     * cloning is handled by the method instead. The `customizer` is invoked with\n     * up to four arguments; (value [, index|key, object, stack]).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @param {Function} [customizer] The function to customize cloning.\n     * @returns {*} Returns the cloned value.\n     * @see _.cloneDeepWith\n     * @example\n     *\n     * function customizer(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(false);\n     *   }\n     * }\n     *\n     * var el = _.cloneWith(document.body, customizer);\n     *\n     * console.log(el === document.body);\n     * // => false\n     * console.log(el.nodeName);\n     * // => 'BODY'\n     * console.log(el.childNodes.length);\n     * // => 0\n     */\n    function cloneWith(value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);\n    }\n\n    /**\n     * This method is like `_.clone` except that it recursively clones `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Lang\n     * @param {*} value The value to recursively clone.\n     * @returns {*} Returns the deep cloned value.\n     * @see _.clone\n     * @example\n     *\n     * var objects = [{ 'a': 1 }, { 'b': 2 }];\n     *\n     * var deep = _.cloneDeep(objects);\n     * console.log(deep[0] === objects[0]);\n     * // => false\n     */\n    function cloneDeep(value) {\n      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n    }\n\n    /**\n     * This method is like `_.cloneWith` except that it recursively clones `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to recursively clone.\n     * @param {Function} [customizer] The function to customize cloning.\n     * @returns {*} Returns the deep cloned value.\n     * @see _.cloneWith\n     * @example\n     *\n     * function customizer(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(true);\n     *   }\n     * }\n     *\n     * var el = _.cloneDeepWith(document.body, customizer);\n     *\n     * console.log(el === document.body);\n     * // => false\n     * console.log(el.nodeName);\n     * // => 'BODY'\n     * console.log(el.childNodes.length);\n     * // => 20\n     */\n    function cloneDeepWith(value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);\n    }\n\n    /**\n     * Checks if `object` conforms to `source` by invoking the predicate\n     * properties of `source` with the corresponding property values of `object`.\n     *\n     * **Note:** This method is equivalent to `_.conforms` when `source` is\n     * partially applied.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.14.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     *\n     * _.conformsTo(object, { 'b': function(n) { return n > 1; } });\n     * // => true\n     *\n     * _.conformsTo(object, { 'b': function(n) { return n > 2; } });\n     * // => false\n     */\n    function conformsTo(object, source) {\n      return source == null || baseConformsTo(object, source, keys(source));\n    }\n\n    /**\n     * Performs a\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * comparison between two values to determine if they are equivalent.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     * var other = { 'a': 1 };\n     *\n     * _.eq(object, object);\n     * // => true\n     *\n     * _.eq(object, other);\n     * // => false\n     *\n     * _.eq('a', 'a');\n     * // => true\n     *\n     * _.eq('a', Object('a'));\n     * // => false\n     *\n     * _.eq(NaN, NaN);\n     * // => true\n     */\n    function eq(value, other) {\n      return value === other || (value !== value && other !== other);\n    }\n\n    /**\n     * Checks if `value` is greater than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than `other`,\n     *  else `false`.\n     * @see _.lt\n     * @example\n     *\n     * _.gt(3, 1);\n     * // => true\n     *\n     * _.gt(3, 3);\n     * // => false\n     *\n     * _.gt(1, 3);\n     * // => false\n     */\n    var gt = createRelationalOperation(baseGt);\n\n    /**\n     * Checks if `value` is greater than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than or equal to\n     *  `other`, else `false`.\n     * @see _.lte\n     * @example\n     *\n     * _.gte(3, 1);\n     * // => true\n     *\n     * _.gte(3, 3);\n     * // => true\n     *\n     * _.gte(1, 3);\n     * // => false\n     */\n    var gte = createRelationalOperation(function(value, other) {\n      return value >= other;\n    });\n\n    /**\n     * Checks if `value` is likely an `arguments` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n     *  else `false`.\n     * @example\n     *\n     * _.isArguments(function() { return arguments; }());\n     * // => true\n     *\n     * _.isArguments([1, 2, 3]);\n     * // => false\n     */\n    var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n      return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n        !propertyIsEnumerable.call(value, 'callee');\n    };\n\n    /**\n     * Checks if `value` is classified as an `Array` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n     * @example\n     *\n     * _.isArray([1, 2, 3]);\n     * // => true\n     *\n     * _.isArray(document.body.children);\n     * // => false\n     *\n     * _.isArray('abc');\n     * // => false\n     *\n     * _.isArray(_.noop);\n     * // => false\n     */\n    var isArray = Array.isArray;\n\n    /**\n     * Checks if `value` is classified as an `ArrayBuffer` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n     * @example\n     *\n     * _.isArrayBuffer(new ArrayBuffer(2));\n     * // => true\n     *\n     * _.isArrayBuffer(new Array(2));\n     * // => false\n     */\n    var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;\n\n    /**\n     * Checks if `value` is array-like. A value is considered array-like if it's\n     * not a function and has a `value.length` that's an integer greater than or\n     * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n     * @example\n     *\n     * _.isArrayLike([1, 2, 3]);\n     * // => true\n     *\n     * _.isArrayLike(document.body.children);\n     * // => true\n     *\n     * _.isArrayLike('abc');\n     * // => true\n     *\n     * _.isArrayLike(_.noop);\n     * // => false\n     */\n    function isArrayLike(value) {\n      return value != null && isLength(value.length) && !isFunction(value);\n    }\n\n    /**\n     * This method is like `_.isArrayLike` except that it also checks if `value`\n     * is an object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array-like object,\n     *  else `false`.\n     * @example\n     *\n     * _.isArrayLikeObject([1, 2, 3]);\n     * // => true\n     *\n     * _.isArrayLikeObject(document.body.children);\n     * // => true\n     *\n     * _.isArrayLikeObject('abc');\n     * // => false\n     *\n     * _.isArrayLikeObject(_.noop);\n     * // => false\n     */\n    function isArrayLikeObject(value) {\n      return isObjectLike(value) && isArrayLike(value);\n    }\n\n    /**\n     * Checks if `value` is classified as a boolean primitive or object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.\n     * @example\n     *\n     * _.isBoolean(false);\n     * // => true\n     *\n     * _.isBoolean(null);\n     * // => false\n     */\n    function isBoolean(value) {\n      return value === true || value === false ||\n        (isObjectLike(value) && baseGetTag(value) == boolTag);\n    }\n\n    /**\n     * Checks if `value` is a buffer.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n     * @example\n     *\n     * _.isBuffer(new Buffer(2));\n     * // => true\n     *\n     * _.isBuffer(new Uint8Array(2));\n     * // => false\n     */\n    var isBuffer = nativeIsBuffer || stubFalse;\n\n    /**\n     * Checks if `value` is classified as a `Date` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n     * @example\n     *\n     * _.isDate(new Date);\n     * // => true\n     *\n     * _.isDate('Mon April 23 2012');\n     * // => false\n     */\n    var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;\n\n    /**\n     * Checks if `value` is likely a DOM element.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.\n     * @example\n     *\n     * _.isElement(document.body);\n     * // => true\n     *\n     * _.isElement('<body>');\n     * // => false\n     */\n    function isElement(value) {\n      return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);\n    }\n\n    /**\n     * Checks if `value` is an empty object, collection, map, or set.\n     *\n     * Objects are considered empty if they have no own enumerable string keyed\n     * properties.\n     *\n     * Array-like values such as `arguments` objects, arrays, buffers, strings, or\n     * jQuery-like collections are considered empty if they have a `length` of `0`.\n     * Similarly, maps and sets are considered empty if they have a `size` of `0`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is empty, else `false`.\n     * @example\n     *\n     * _.isEmpty(null);\n     * // => true\n     *\n     * _.isEmpty(true);\n     * // => true\n     *\n     * _.isEmpty(1);\n     * // => true\n     *\n     * _.isEmpty([1, 2, 3]);\n     * // => false\n     *\n     * _.isEmpty({ 'a': 1 });\n     * // => false\n     */\n    function isEmpty(value) {\n      if (value == null) {\n        return true;\n      }\n      if (isArrayLike(value) &&\n          (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||\n            isBuffer(value) || isTypedArray(value) || isArguments(value))) {\n        return !value.length;\n      }\n      var tag = getTag(value);\n      if (tag == mapTag || tag == setTag) {\n        return !value.size;\n      }\n      if (isPrototype(value)) {\n        return !baseKeys(value).length;\n      }\n      for (var key in value) {\n        if (hasOwnProperty.call(value, key)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * Performs a deep comparison between two values to determine if they are\n     * equivalent.\n     *\n     * **Note:** This method supports comparing arrays, array buffers, booleans,\n     * date objects, error objects, maps, numbers, `Object` objects, regexes,\n     * sets, strings, symbols, and typed arrays. `Object` objects are compared\n     * by their own, not inherited, enumerable properties. Functions and DOM\n     * nodes are compared by strict equality, i.e. `===`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     * var other = { 'a': 1 };\n     *\n     * _.isEqual(object, other);\n     * // => true\n     *\n     * object === other;\n     * // => false\n     */\n    function isEqual(value, other) {\n      return baseIsEqual(value, other);\n    }\n\n    /**\n     * This method is like `_.isEqual` except that it accepts `customizer` which\n     * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n     * are handled by the method instead. The `customizer` is invoked with up to\n     * six arguments: (objValue, othValue [, index|key, object, other, stack]).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * function isGreeting(value) {\n     *   return /^h(?:i|ello)$/.test(value);\n     * }\n     *\n     * function customizer(objValue, othValue) {\n     *   if (isGreeting(objValue) && isGreeting(othValue)) {\n     *     return true;\n     *   }\n     * }\n     *\n     * var array = ['hello', 'goodbye'];\n     * var other = ['hi', 'goodbye'];\n     *\n     * _.isEqualWith(array, other, customizer);\n     * // => true\n     */\n    function isEqualWith(value, other, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      var result = customizer ? customizer(value, other) : undefined;\n      return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;\n    }\n\n    /**\n     * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,\n     * `SyntaxError`, `TypeError`, or `URIError` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an error object, else `false`.\n     * @example\n     *\n     * _.isError(new Error);\n     * // => true\n     *\n     * _.isError(Error);\n     * // => false\n     */\n    function isError(value) {\n      if (!isObjectLike(value)) {\n        return false;\n      }\n      var tag = baseGetTag(value);\n      return tag == errorTag || tag == domExcTag ||\n        (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));\n    }\n\n    /**\n     * Checks if `value` is a finite primitive number.\n     *\n     * **Note:** This method is based on\n     * [`Number.isFinite`](https://mdn.io/Number/isFinite).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.\n     * @example\n     *\n     * _.isFinite(3);\n     * // => true\n     *\n     * _.isFinite(Number.MIN_VALUE);\n     * // => true\n     *\n     * _.isFinite(Infinity);\n     * // => false\n     *\n     * _.isFinite('3');\n     * // => false\n     */\n    function isFinite(value) {\n      return typeof value == 'number' && nativeIsFinite(value);\n    }\n\n    /**\n     * Checks if `value` is classified as a `Function` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n     * @example\n     *\n     * _.isFunction(_);\n     * // => true\n     *\n     * _.isFunction(/abc/);\n     * // => false\n     */\n    function isFunction(value) {\n      if (!isObject(value)) {\n        return false;\n      }\n      // The use of `Object#toString` avoids issues with the `typeof` operator\n      // in Safari 9 which returns 'object' for typed arrays and other constructors.\n      var tag = baseGetTag(value);\n      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n    }\n\n    /**\n     * Checks if `value` is an integer.\n     *\n     * **Note:** This method is based on\n     * [`Number.isInteger`](https://mdn.io/Number/isInteger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an integer, else `false`.\n     * @example\n     *\n     * _.isInteger(3);\n     * // => true\n     *\n     * _.isInteger(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isInteger(Infinity);\n     * // => false\n     *\n     * _.isInteger('3');\n     * // => false\n     */\n    function isInteger(value) {\n      return typeof value == 'number' && value == toInteger(value);\n    }\n\n    /**\n     * Checks if `value` is a valid array-like length.\n     *\n     * **Note:** This method is loosely based on\n     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n     * @example\n     *\n     * _.isLength(3);\n     * // => true\n     *\n     * _.isLength(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isLength(Infinity);\n     * // => false\n     *\n     * _.isLength('3');\n     * // => false\n     */\n    function isLength(value) {\n      return typeof value == 'number' &&\n        value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n    }\n\n    /**\n     * Checks if `value` is the\n     * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n     * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n     * @example\n     *\n     * _.isObject({});\n     * // => true\n     *\n     * _.isObject([1, 2, 3]);\n     * // => true\n     *\n     * _.isObject(_.noop);\n     * // => true\n     *\n     * _.isObject(null);\n     * // => false\n     */\n    function isObject(value) {\n      var type = typeof value;\n      return value != null && (type == 'object' || type == 'function');\n    }\n\n    /**\n     * Checks if `value` is object-like. A value is object-like if it's not `null`\n     * and has a `typeof` result of \"object\".\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n     * @example\n     *\n     * _.isObjectLike({});\n     * // => true\n     *\n     * _.isObjectLike([1, 2, 3]);\n     * // => true\n     *\n     * _.isObjectLike(_.noop);\n     * // => false\n     *\n     * _.isObjectLike(null);\n     * // => false\n     */\n    function isObjectLike(value) {\n      return value != null && typeof value == 'object';\n    }\n\n    /**\n     * Checks if `value` is classified as a `Map` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n     * @example\n     *\n     * _.isMap(new Map);\n     * // => true\n     *\n     * _.isMap(new WeakMap);\n     * // => false\n     */\n    var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\n    /**\n     * Performs a partial deep comparison between `object` and `source` to\n     * determine if `object` contains equivalent property values.\n     *\n     * **Note:** This method is equivalent to `_.matches` when `source` is\n     * partially applied.\n     *\n     * Partial comparisons will match empty array and empty object `source`\n     * values against any array or object value, respectively. See `_.isEqual`\n     * for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     *\n     * _.isMatch(object, { 'b': 2 });\n     * // => true\n     *\n     * _.isMatch(object, { 'b': 1 });\n     * // => false\n     */\n    function isMatch(object, source) {\n      return object === source || baseIsMatch(object, source, getMatchData(source));\n    }\n\n    /**\n     * This method is like `_.isMatch` except that it accepts `customizer` which\n     * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n     * are handled by the method instead. The `customizer` is invoked with five\n     * arguments: (objValue, srcValue, index|key, object, source).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * function isGreeting(value) {\n     *   return /^h(?:i|ello)$/.test(value);\n     * }\n     *\n     * function customizer(objValue, srcValue) {\n     *   if (isGreeting(objValue) && isGreeting(srcValue)) {\n     *     return true;\n     *   }\n     * }\n     *\n     * var object = { 'greeting': 'hello' };\n     * var source = { 'greeting': 'hi' };\n     *\n     * _.isMatchWith(object, source, customizer);\n     * // => true\n     */\n    function isMatchWith(object, source, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseIsMatch(object, source, getMatchData(source), customizer);\n    }\n\n    /**\n     * Checks if `value` is `NaN`.\n     *\n     * **Note:** This method is based on\n     * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as\n     * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for\n     * `undefined` and other non-number values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n     * @example\n     *\n     * _.isNaN(NaN);\n     * // => true\n     *\n     * _.isNaN(new Number(NaN));\n     * // => true\n     *\n     * isNaN(undefined);\n     * // => true\n     *\n     * _.isNaN(undefined);\n     * // => false\n     */\n    function isNaN(value) {\n      // An `NaN` primitive is the only value that is not equal to itself.\n      // Perform the `toStringTag` check first to avoid errors with some\n      // ActiveX objects in IE.\n      return isNumber(value) && value != +value;\n    }\n\n    /**\n     * Checks if `value` is a pristine native function.\n     *\n     * **Note:** This method can't reliably detect native functions in the presence\n     * of the core-js package because core-js circumvents this kind of detection.\n     * Despite multiple requests, the core-js maintainer has made it clear: any\n     * attempt to fix the detection will be obstructed. As a result, we're left\n     * with little choice but to throw an error. Unfortunately, this also affects\n     * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),\n     * which rely on core-js.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a native function,\n     *  else `false`.\n     * @example\n     *\n     * _.isNative(Array.prototype.push);\n     * // => true\n     *\n     * _.isNative(_);\n     * // => false\n     */\n    function isNative(value) {\n      if (isMaskable(value)) {\n        throw new Error(CORE_ERROR_TEXT);\n      }\n      return baseIsNative(value);\n    }\n\n    /**\n     * Checks if `value` is `null`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `null`, else `false`.\n     * @example\n     *\n     * _.isNull(null);\n     * // => true\n     *\n     * _.isNull(void 0);\n     * // => false\n     */\n    function isNull(value) {\n      return value === null;\n    }\n\n    /**\n     * Checks if `value` is `null` or `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\n     * @example\n     *\n     * _.isNil(null);\n     * // => true\n     *\n     * _.isNil(void 0);\n     * // => true\n     *\n     * _.isNil(NaN);\n     * // => false\n     */\n    function isNil(value) {\n      return value == null;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Number` primitive or object.\n     *\n     * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are\n     * classified as numbers, use the `_.isFinite` method.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a number, else `false`.\n     * @example\n     *\n     * _.isNumber(3);\n     * // => true\n     *\n     * _.isNumber(Number.MIN_VALUE);\n     * // => true\n     *\n     * _.isNumber(Infinity);\n     * // => true\n     *\n     * _.isNumber('3');\n     * // => false\n     */\n    function isNumber(value) {\n      return typeof value == 'number' ||\n        (isObjectLike(value) && baseGetTag(value) == numberTag);\n    }\n\n    /**\n     * Checks if `value` is a plain object, that is, an object created by the\n     * `Object` constructor or one with a `[[Prototype]]` of `null`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.8.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * _.isPlainObject(new Foo);\n     * // => false\n     *\n     * _.isPlainObject([1, 2, 3]);\n     * // => false\n     *\n     * _.isPlainObject({ 'x': 0, 'y': 0 });\n     * // => true\n     *\n     * _.isPlainObject(Object.create(null));\n     * // => true\n     */\n    function isPlainObject(value) {\n      if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n        return false;\n      }\n      var proto = getPrototype(value);\n      if (proto === null) {\n        return true;\n      }\n      var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n      return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n        funcToString.call(Ctor) == objectCtorString;\n    }\n\n    /**\n     * Checks if `value` is classified as a `RegExp` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n     * @example\n     *\n     * _.isRegExp(/abc/);\n     * // => true\n     *\n     * _.isRegExp('/abc/');\n     * // => false\n     */\n    var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;\n\n    /**\n     * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754\n     * double precision number which isn't the result of a rounded unsafe integer.\n     *\n     * **Note:** This method is based on\n     * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.\n     * @example\n     *\n     * _.isSafeInteger(3);\n     * // => true\n     *\n     * _.isSafeInteger(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isSafeInteger(Infinity);\n     * // => false\n     *\n     * _.isSafeInteger('3');\n     * // => false\n     */\n    function isSafeInteger(value) {\n      return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Set` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n     * @example\n     *\n     * _.isSet(new Set);\n     * // => true\n     *\n     * _.isSet(new WeakSet);\n     * // => false\n     */\n    var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\n    /**\n     * Checks if `value` is classified as a `String` primitive or object.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n     * @example\n     *\n     * _.isString('abc');\n     * // => true\n     *\n     * _.isString(1);\n     * // => false\n     */\n    function isString(value) {\n      return typeof value == 'string' ||\n        (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a `Symbol` primitive or object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n     * @example\n     *\n     * _.isSymbol(Symbol.iterator);\n     * // => true\n     *\n     * _.isSymbol('abc');\n     * // => false\n     */\n    function isSymbol(value) {\n      return typeof value == 'symbol' ||\n        (isObjectLike(value) && baseGetTag(value) == symbolTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a typed array.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n     * @example\n     *\n     * _.isTypedArray(new Uint8Array);\n     * // => true\n     *\n     * _.isTypedArray([]);\n     * // => false\n     */\n    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n    /**\n     * Checks if `value` is `undefined`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.\n     * @example\n     *\n     * _.isUndefined(void 0);\n     * // => true\n     *\n     * _.isUndefined(null);\n     * // => false\n     */\n    function isUndefined(value) {\n      return value === undefined;\n    }\n\n    /**\n     * Checks if `value` is classified as a `WeakMap` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.\n     * @example\n     *\n     * _.isWeakMap(new WeakMap);\n     * // => true\n     *\n     * _.isWeakMap(new Map);\n     * // => false\n     */\n    function isWeakMap(value) {\n      return isObjectLike(value) && getTag(value) == weakMapTag;\n    }\n\n    /**\n     * Checks if `value` is classified as a `WeakSet` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.\n     * @example\n     *\n     * _.isWeakSet(new WeakSet);\n     * // => true\n     *\n     * _.isWeakSet(new Set);\n     * // => false\n     */\n    function isWeakSet(value) {\n      return isObjectLike(value) && baseGetTag(value) == weakSetTag;\n    }\n\n    /**\n     * Checks if `value` is less than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than `other`,\n     *  else `false`.\n     * @see _.gt\n     * @example\n     *\n     * _.lt(1, 3);\n     * // => true\n     *\n     * _.lt(3, 3);\n     * // => false\n     *\n     * _.lt(3, 1);\n     * // => false\n     */\n    var lt = createRelationalOperation(baseLt);\n\n    /**\n     * Checks if `value` is less than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than or equal to\n     *  `other`, else `false`.\n     * @see _.gte\n     * @example\n     *\n     * _.lte(1, 3);\n     * // => true\n     *\n     * _.lte(3, 3);\n     * // => true\n     *\n     * _.lte(3, 1);\n     * // => false\n     */\n    var lte = createRelationalOperation(function(value, other) {\n      return value <= other;\n    });\n\n    /**\n     * Converts `value` to an array.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the converted array.\n     * @example\n     *\n     * _.toArray({ 'a': 1, 'b': 2 });\n     * // => [1, 2]\n     *\n     * _.toArray('abc');\n     * // => ['a', 'b', 'c']\n     *\n     * _.toArray(1);\n     * // => []\n     *\n     * _.toArray(null);\n     * // => []\n     */\n    function toArray(value) {\n      if (!value) {\n        return [];\n      }\n      if (isArrayLike(value)) {\n        return isString(value) ? stringToArray(value) : copyArray(value);\n      }\n      if (symIterator && value[symIterator]) {\n        return iteratorToArray(value[symIterator]());\n      }\n      var tag = getTag(value),\n          func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);\n\n      return func(value);\n    }\n\n    /**\n     * Converts `value` to a finite number.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.12.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted number.\n     * @example\n     *\n     * _.toFinite(3.2);\n     * // => 3.2\n     *\n     * _.toFinite(Number.MIN_VALUE);\n     * // => 5e-324\n     *\n     * _.toFinite(Infinity);\n     * // => 1.7976931348623157e+308\n     *\n     * _.toFinite('3.2');\n     * // => 3.2\n     */\n    function toFinite(value) {\n      if (!value) {\n        return value === 0 ? value : 0;\n      }\n      value = toNumber(value);\n      if (value === INFINITY || value === -INFINITY) {\n        var sign = (value < 0 ? -1 : 1);\n        return sign * MAX_INTEGER;\n      }\n      return value === value ? value : 0;\n    }\n\n    /**\n     * Converts `value` to an integer.\n     *\n     * **Note:** This method is loosely based on\n     * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toInteger(3.2);\n     * // => 3\n     *\n     * _.toInteger(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toInteger(Infinity);\n     * // => 1.7976931348623157e+308\n     *\n     * _.toInteger('3.2');\n     * // => 3\n     */\n    function toInteger(value) {\n      var result = toFinite(value),\n          remainder = result % 1;\n\n      return result === result ? (remainder ? result - remainder : result) : 0;\n    }\n\n    /**\n     * Converts `value` to an integer suitable for use as the length of an\n     * array-like object.\n     *\n     * **Note:** This method is based on\n     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toLength(3.2);\n     * // => 3\n     *\n     * _.toLength(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toLength(Infinity);\n     * // => 4294967295\n     *\n     * _.toLength('3.2');\n     * // => 3\n     */\n    function toLength(value) {\n      return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;\n    }\n\n    /**\n     * Converts `value` to a number.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to process.\n     * @returns {number} Returns the number.\n     * @example\n     *\n     * _.toNumber(3.2);\n     * // => 3.2\n     *\n     * _.toNumber(Number.MIN_VALUE);\n     * // => 5e-324\n     *\n     * _.toNumber(Infinity);\n     * // => Infinity\n     *\n     * _.toNumber('3.2');\n     * // => 3.2\n     */\n    function toNumber(value) {\n      if (typeof value == 'number') {\n        return value;\n      }\n      if (isSymbol(value)) {\n        return NAN;\n      }\n      if (isObject(value)) {\n        var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n        value = isObject(other) ? (other + '') : other;\n      }\n      if (typeof value != 'string') {\n        return value === 0 ? value : +value;\n      }\n      value = value.replace(reTrim, '');\n      var isBinary = reIsBinary.test(value);\n      return (isBinary || reIsOctal.test(value))\n        ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n        : (reIsBadHex.test(value) ? NAN : +value);\n    }\n\n    /**\n     * Converts `value` to a plain object flattening inherited enumerable string\n     * keyed properties of `value` to own properties of the plain object.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Object} Returns the converted plain object.\n     * @example\n     *\n     * function Foo() {\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.assign({ 'a': 1 }, new Foo);\n     * // => { 'a': 1, 'b': 2 }\n     *\n     * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n     * // => { 'a': 1, 'b': 2, 'c': 3 }\n     */\n    function toPlainObject(value) {\n      return copyObject(value, keysIn(value));\n    }\n\n    /**\n     * Converts `value` to a safe integer. A safe integer can be compared and\n     * represented correctly.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toSafeInteger(3.2);\n     * // => 3\n     *\n     * _.toSafeInteger(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toSafeInteger(Infinity);\n     * // => 9007199254740991\n     *\n     * _.toSafeInteger('3.2');\n     * // => 3\n     */\n    function toSafeInteger(value) {\n      return value\n        ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)\n        : (value === 0 ? value : 0);\n    }\n\n    /**\n     * Converts `value` to a string. An empty string is returned for `null`\n     * and `undefined` values. The sign of `-0` is preserved.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.toString(null);\n     * // => ''\n     *\n     * _.toString(-0);\n     * // => '-0'\n     *\n     * _.toString([1, 2, 3]);\n     * // => '1,2,3'\n     */\n    function toString(value) {\n      return value == null ? '' : baseToString(value);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Assigns own enumerable string keyed properties of source objects to the\n     * destination object. Source objects are applied from left to right.\n     * Subsequent sources overwrite property assignments of previous sources.\n     *\n     * **Note:** This method mutates `object` and is loosely based on\n     * [`Object.assign`](https://mdn.io/Object/assign).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.10.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.assignIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * function Bar() {\n     *   this.c = 3;\n     * }\n     *\n     * Foo.prototype.b = 2;\n     * Bar.prototype.d = 4;\n     *\n     * _.assign({ 'a': 0 }, new Foo, new Bar);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    var assign = createAssigner(function(object, source) {\n      if (isPrototype(source) || isArrayLike(source)) {\n        copyObject(source, keys(source), object);\n        return;\n      }\n      for (var key in source) {\n        if (hasOwnProperty.call(source, key)) {\n          assignValue(object, key, source[key]);\n        }\n      }\n    });\n\n    /**\n     * This method is like `_.assign` except that it iterates over own and\n     * inherited source properties.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias extend\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.assign\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * function Bar() {\n     *   this.c = 3;\n     * }\n     *\n     * Foo.prototype.b = 2;\n     * Bar.prototype.d = 4;\n     *\n     * _.assignIn({ 'a': 0 }, new Foo, new Bar);\n     * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }\n     */\n    var assignIn = createAssigner(function(object, source) {\n      copyObject(source, keysIn(source), object);\n    });\n\n    /**\n     * This method is like `_.assignIn` except that it accepts `customizer`\n     * which is invoked to produce the assigned values. If `customizer` returns\n     * `undefined`, assignment is handled by the method instead. The `customizer`\n     * is invoked with five arguments: (objValue, srcValue, key, object, source).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias extendWith\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @see _.assignWith\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   return _.isUndefined(objValue) ? srcValue : objValue;\n     * }\n     *\n     * var defaults = _.partialRight(_.assignInWith, customizer);\n     *\n     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {\n      copyObject(source, keysIn(source), object, customizer);\n    });\n\n    /**\n     * This method is like `_.assign` except that it accepts `customizer`\n     * which is invoked to produce the assigned values. If `customizer` returns\n     * `undefined`, assignment is handled by the method instead. The `customizer`\n     * is invoked with five arguments: (objValue, srcValue, key, object, source).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @see _.assignInWith\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   return _.isUndefined(objValue) ? srcValue : objValue;\n     * }\n     *\n     * var defaults = _.partialRight(_.assignWith, customizer);\n     *\n     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var assignWith = createAssigner(function(object, source, srcIndex, customizer) {\n      copyObject(source, keys(source), object, customizer);\n    });\n\n    /**\n     * Creates an array of values corresponding to `paths` of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Array} Returns the picked values.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n     *\n     * _.at(object, ['a[0].b.c', 'a[1]']);\n     * // => [3, 4]\n     */\n    var at = flatRest(baseAt);\n\n    /**\n     * Creates an object that inherits from the `prototype` object. If a\n     * `properties` object is given, its own enumerable string keyed properties\n     * are assigned to the created object.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.3.0\n     * @category Object\n     * @param {Object} prototype The object to inherit from.\n     * @param {Object} [properties] The properties to assign to the object.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * function Shape() {\n     *   this.x = 0;\n     *   this.y = 0;\n     * }\n     *\n     * function Circle() {\n     *   Shape.call(this);\n     * }\n     *\n     * Circle.prototype = _.create(Shape.prototype, {\n     *   'constructor': Circle\n     * });\n     *\n     * var circle = new Circle;\n     * circle instanceof Circle;\n     * // => true\n     *\n     * circle instanceof Shape;\n     * // => true\n     */\n    function create(prototype, properties) {\n      var result = baseCreate(prototype);\n      return properties == null ? result : baseAssign(result, properties);\n    }\n\n    /**\n     * Assigns own and inherited enumerable string keyed properties of source\n     * objects to the destination object for all destination properties that\n     * resolve to `undefined`. Source objects are applied from left to right.\n     * Once a property is set, additional values of the same property are ignored.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.defaultsDeep\n     * @example\n     *\n     * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var defaults = baseRest(function(args) {\n      args.push(undefined, customDefaultsAssignIn);\n      return apply(assignInWith, undefined, args);\n    });\n\n    /**\n     * This method is like `_.defaults` except that it recursively assigns\n     * default properties.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.defaults\n     * @example\n     *\n     * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });\n     * // => { 'a': { 'b': 2, 'c': 3 } }\n     */\n    var defaultsDeep = baseRest(function(args) {\n      args.push(undefined, customDefaultsMerge);\n      return apply(mergeWith, undefined, args);\n    });\n\n    /**\n     * This method is like `_.find` except that it returns the key of the first\n     * element `predicate` returns truthy for instead of the element itself.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {string|undefined} Returns the key of the matched element,\n     *  else `undefined`.\n     * @example\n     *\n     * var users = {\n     *   'barney':  { 'age': 36, 'active': true },\n     *   'fred':    { 'age': 40, 'active': false },\n     *   'pebbles': { 'age': 1,  'active': true }\n     * };\n     *\n     * _.findKey(users, function(o) { return o.age < 40; });\n     * // => 'barney' (iteration order is not guaranteed)\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findKey(users, { 'age': 1, 'active': true });\n     * // => 'pebbles'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findKey(users, ['active', false]);\n     * // => 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findKey(users, 'active');\n     * // => 'barney'\n     */\n    function findKey(object, predicate) {\n      return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);\n    }\n\n    /**\n     * This method is like `_.findKey` except that it iterates over elements of\n     * a collection in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {string|undefined} Returns the key of the matched element,\n     *  else `undefined`.\n     * @example\n     *\n     * var users = {\n     *   'barney':  { 'age': 36, 'active': true },\n     *   'fred':    { 'age': 40, 'active': false },\n     *   'pebbles': { 'age': 1,  'active': true }\n     * };\n     *\n     * _.findLastKey(users, function(o) { return o.age < 40; });\n     * // => returns 'pebbles' assuming `_.findKey` returns 'barney'\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findLastKey(users, { 'age': 36, 'active': true });\n     * // => 'barney'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findLastKey(users, ['active', false]);\n     * // => 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findLastKey(users, 'active');\n     * // => 'pebbles'\n     */\n    function findLastKey(object, predicate) {\n      return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);\n    }\n\n    /**\n     * Iterates over own and inherited enumerable string keyed properties of an\n     * object and invokes `iteratee` for each property. The iteratee is invoked\n     * with three arguments: (value, key, object). Iteratee functions may exit\n     * iteration early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forInRight\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forIn(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).\n     */\n    function forIn(object, iteratee) {\n      return object == null\n        ? object\n        : baseFor(object, getIteratee(iteratee, 3), keysIn);\n    }\n\n    /**\n     * This method is like `_.forIn` except that it iterates over properties of\n     * `object` in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forInRight(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.\n     */\n    function forInRight(object, iteratee) {\n      return object == null\n        ? object\n        : baseForRight(object, getIteratee(iteratee, 3), keysIn);\n    }\n\n    /**\n     * Iterates over own enumerable string keyed properties of an object and\n     * invokes `iteratee` for each property. The iteratee is invoked with three\n     * arguments: (value, key, object). Iteratee functions may exit iteration\n     * early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forOwnRight\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forOwn(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n     */\n    function forOwn(object, iteratee) {\n      return object && baseForOwn(object, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.forOwn` except that it iterates over properties of\n     * `object` in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forOwn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forOwnRight(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.\n     */\n    function forOwnRight(object, iteratee) {\n      return object && baseForOwnRight(object, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * Creates an array of function property names from own enumerable properties\n     * of `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns the function names.\n     * @see _.functionsIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = _.constant('a');\n     *   this.b = _.constant('b');\n     * }\n     *\n     * Foo.prototype.c = _.constant('c');\n     *\n     * _.functions(new Foo);\n     * // => ['a', 'b']\n     */\n    function functions(object) {\n      return object == null ? [] : baseFunctions(object, keys(object));\n    }\n\n    /**\n     * Creates an array of function property names from own and inherited\n     * enumerable properties of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns the function names.\n     * @see _.functions\n     * @example\n     *\n     * function Foo() {\n     *   this.a = _.constant('a');\n     *   this.b = _.constant('b');\n     * }\n     *\n     * Foo.prototype.c = _.constant('c');\n     *\n     * _.functionsIn(new Foo);\n     * // => ['a', 'b', 'c']\n     */\n    function functionsIn(object) {\n      return object == null ? [] : baseFunctions(object, keysIn(object));\n    }\n\n    /**\n     * Gets the value at `path` of `object`. If the resolved value is\n     * `undefined`, the `defaultValue` is returned in its place.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.get(object, 'a[0].b.c');\n     * // => 3\n     *\n     * _.get(object, ['a', '0', 'b', 'c']);\n     * // => 3\n     *\n     * _.get(object, 'a.b.c', 'default');\n     * // => 'default'\n     */\n    function get(object, path, defaultValue) {\n      var result = object == null ? undefined : baseGet(object, path);\n      return result === undefined ? defaultValue : result;\n    }\n\n    /**\n     * Checks if `path` is a direct property of `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     * @example\n     *\n     * var object = { 'a': { 'b': 2 } };\n     * var other = _.create({ 'a': _.create({ 'b': 2 }) });\n     *\n     * _.has(object, 'a');\n     * // => true\n     *\n     * _.has(object, 'a.b');\n     * // => true\n     *\n     * _.has(object, ['a', 'b']);\n     * // => true\n     *\n     * _.has(other, 'a');\n     * // => false\n     */\n    function has(object, path) {\n      return object != null && hasPath(object, path, baseHas);\n    }\n\n    /**\n     * Checks if `path` is a direct or inherited property of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     * @example\n     *\n     * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n     *\n     * _.hasIn(object, 'a');\n     * // => true\n     *\n     * _.hasIn(object, 'a.b');\n     * // => true\n     *\n     * _.hasIn(object, ['a', 'b']);\n     * // => true\n     *\n     * _.hasIn(object, 'b');\n     * // => false\n     */\n    function hasIn(object, path) {\n      return object != null && hasPath(object, path, baseHasIn);\n    }\n\n    /**\n     * Creates an object composed of the inverted keys and values of `object`.\n     * If `object` contains duplicate values, subsequent values overwrite\n     * property assignments of previous values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.7.0\n     * @category Object\n     * @param {Object} object The object to invert.\n     * @returns {Object} Returns the new inverted object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2, 'c': 1 };\n     *\n     * _.invert(object);\n     * // => { '1': 'c', '2': 'b' }\n     */\n    var invert = createInverter(function(result, value, key) {\n      result[value] = key;\n    }, constant(identity));\n\n    /**\n     * This method is like `_.invert` except that the inverted object is generated\n     * from the results of running each element of `object` thru `iteratee`. The\n     * corresponding inverted value of each inverted key is an array of keys\n     * responsible for generating the inverted value. The iteratee is invoked\n     * with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.1.0\n     * @category Object\n     * @param {Object} object The object to invert.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Object} Returns the new inverted object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2, 'c': 1 };\n     *\n     * _.invertBy(object);\n     * // => { '1': ['a', 'c'], '2': ['b'] }\n     *\n     * _.invertBy(object, function(value) {\n     *   return 'group' + value;\n     * });\n     * // => { 'group1': ['a', 'c'], 'group2': ['b'] }\n     */\n    var invertBy = createInverter(function(result, value, key) {\n      if (hasOwnProperty.call(result, value)) {\n        result[value].push(key);\n      } else {\n        result[value] = [key];\n      }\n    }, getIteratee);\n\n    /**\n     * Invokes the method at `path` of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {*} Returns the result of the invoked method.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };\n     *\n     * _.invoke(object, 'a[0].b.c.slice', 1, 3);\n     * // => [2, 3]\n     */\n    var invoke = baseRest(baseInvoke);\n\n    /**\n     * Creates an array of the own enumerable property names of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects. See the\n     * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n     * for more details.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.keys(new Foo);\n     * // => ['a', 'b'] (iteration order is not guaranteed)\n     *\n     * _.keys('hi');\n     * // => ['0', '1']\n     */\n    function keys(object) {\n      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n    }\n\n    /**\n     * Creates an array of the own and inherited enumerable property names of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.keysIn(new Foo);\n     * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n     */\n    function keysIn(object) {\n      return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n    }\n\n    /**\n     * The opposite of `_.mapValues`; this method creates an object with the\n     * same values as `object` and keys generated by running each own enumerable\n     * string keyed property of `object` thru `iteratee`. The iteratee is invoked\n     * with three arguments: (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns the new mapped object.\n     * @see _.mapValues\n     * @example\n     *\n     * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {\n     *   return key + value;\n     * });\n     * // => { 'a1': 1, 'b2': 2 }\n     */\n    function mapKeys(object, iteratee) {\n      var result = {};\n      iteratee = getIteratee(iteratee, 3);\n\n      baseForOwn(object, function(value, key, object) {\n        baseAssignValue(result, iteratee(value, key, object), value);\n      });\n      return result;\n    }\n\n    /**\n     * Creates an object with the same keys as `object` and values generated\n     * by running each own enumerable string keyed property of `object` thru\n     * `iteratee`. The iteratee is invoked with three arguments:\n     * (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns the new mapped object.\n     * @see _.mapKeys\n     * @example\n     *\n     * var users = {\n     *   'fred':    { 'user': 'fred',    'age': 40 },\n     *   'pebbles': { 'user': 'pebbles', 'age': 1 }\n     * };\n     *\n     * _.mapValues(users, function(o) { return o.age; });\n     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.mapValues(users, 'age');\n     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n     */\n    function mapValues(object, iteratee) {\n      var result = {};\n      iteratee = getIteratee(iteratee, 3);\n\n      baseForOwn(object, function(value, key, object) {\n        baseAssignValue(result, key, iteratee(value, key, object));\n      });\n      return result;\n    }\n\n    /**\n     * This method is like `_.assign` except that it recursively merges own and\n     * inherited enumerable string keyed properties of source objects into the\n     * destination object. Source properties that resolve to `undefined` are\n     * skipped if a destination value exists. Array and plain object properties\n     * are merged recursively. Other objects and value types are overridden by\n     * assignment. Source objects are applied from left to right. Subsequent\n     * sources overwrite property assignments of previous sources.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {\n     *   'a': [{ 'b': 2 }, { 'd': 4 }]\n     * };\n     *\n     * var other = {\n     *   'a': [{ 'c': 3 }, { 'e': 5 }]\n     * };\n     *\n     * _.merge(object, other);\n     * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n     */\n    var merge = createAssigner(function(object, source, srcIndex) {\n      baseMerge(object, source, srcIndex);\n    });\n\n    /**\n     * This method is like `_.merge` except that it accepts `customizer` which\n     * is invoked to produce the merged values of the destination and source\n     * properties. If `customizer` returns `undefined`, merging is handled by the\n     * method instead. The `customizer` is invoked with six arguments:\n     * (objValue, srcValue, key, object, source, stack).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} customizer The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   if (_.isArray(objValue)) {\n     *     return objValue.concat(srcValue);\n     *   }\n     * }\n     *\n     * var object = { 'a': [1], 'b': [2] };\n     * var other = { 'a': [3], 'b': [4] };\n     *\n     * _.mergeWith(object, other, customizer);\n     * // => { 'a': [1, 3], 'b': [2, 4] }\n     */\n    var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\n      baseMerge(object, source, srcIndex, customizer);\n    });\n\n    /**\n     * The opposite of `_.pick`; this method creates an object composed of the\n     * own and inherited enumerable property paths of `object` that are not omitted.\n     *\n     * **Note:** This method is considerably slower than `_.pick`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {...(string|string[])} [paths] The property paths to omit.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.omit(object, ['a', 'c']);\n     * // => { 'b': '2' }\n     */\n    var omit = flatRest(function(object, paths) {\n      var result = {};\n      if (object == null) {\n        return result;\n      }\n      var isDeep = false;\n      paths = arrayMap(paths, function(path) {\n        path = castPath(path, object);\n        isDeep || (isDeep = path.length > 1);\n        return path;\n      });\n      copyObject(object, getAllKeysIn(object), result);\n      if (isDeep) {\n        result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);\n      }\n      var length = paths.length;\n      while (length--) {\n        baseUnset(result, paths[length]);\n      }\n      return result;\n    });\n\n    /**\n     * The opposite of `_.pickBy`; this method creates an object composed of\n     * the own and inherited enumerable string keyed properties of `object` that\n     * `predicate` doesn't return truthy for. The predicate is invoked with two\n     * arguments: (value, key).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {Function} [predicate=_.identity] The function invoked per property.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.omitBy(object, _.isNumber);\n     * // => { 'b': '2' }\n     */\n    function omitBy(object, predicate) {\n      return pickBy(object, negate(getIteratee(predicate)));\n    }\n\n    /**\n     * Creates an object composed of the picked `object` properties.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.pick(object, ['a', 'c']);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    var pick = flatRest(function(object, paths) {\n      return object == null ? {} : basePick(object, paths);\n    });\n\n    /**\n     * Creates an object composed of the `object` properties `predicate` returns\n     * truthy for. The predicate is invoked with two arguments: (value, key).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {Function} [predicate=_.identity] The function invoked per property.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.pickBy(object, _.isNumber);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    function pickBy(object, predicate) {\n      if (object == null) {\n        return {};\n      }\n      var props = arrayMap(getAllKeysIn(object), function(prop) {\n        return [prop];\n      });\n      predicate = getIteratee(predicate);\n      return basePickBy(object, props, function(value, path) {\n        return predicate(value, path[0]);\n      });\n    }\n\n    /**\n     * This method is like `_.get` except that if the resolved value is a\n     * function it's invoked with the `this` binding of its parent object and\n     * its result is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to resolve.\n     * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };\n     *\n     * _.result(object, 'a[0].b.c1');\n     * // => 3\n     *\n     * _.result(object, 'a[0].b.c2');\n     * // => 4\n     *\n     * _.result(object, 'a[0].b.c3', 'default');\n     * // => 'default'\n     *\n     * _.result(object, 'a[0].b.c3', _.constant('default'));\n     * // => 'default'\n     */\n    function result(object, path, defaultValue) {\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length;\n\n      // Ensure the loop is entered when path is empty.\n      if (!length) {\n        length = 1;\n        object = undefined;\n      }\n      while (++index < length) {\n        var value = object == null ? undefined : object[toKey(path[index])];\n        if (value === undefined) {\n          index = length;\n          value = defaultValue;\n        }\n        object = isFunction(value) ? value.call(object) : value;\n      }\n      return object;\n    }\n\n    /**\n     * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,\n     * it's created. Arrays are created for missing index properties while objects\n     * are created for all other missing properties. Use `_.setWith` to customize\n     * `path` creation.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.set(object, 'a[0].b.c', 4);\n     * console.log(object.a[0].b.c);\n     * // => 4\n     *\n     * _.set(object, ['x', '0', 'y', 'z'], 5);\n     * console.log(object.x[0].y.z);\n     * // => 5\n     */\n    function set(object, path, value) {\n      return object == null ? object : baseSet(object, path, value);\n    }\n\n    /**\n     * This method is like `_.set` except that it accepts `customizer` which is\n     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`\n     * path creation is handled by the method instead. The `customizer` is invoked\n     * with three arguments: (nsValue, key, nsObject).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {};\n     *\n     * _.setWith(object, '[0][1]', 'a', Object);\n     * // => { '0': { '1': 'a' } }\n     */\n    function setWith(object, path, value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return object == null ? object : baseSet(object, path, value, customizer);\n    }\n\n    /**\n     * Creates an array of own enumerable string keyed-value pairs for `object`\n     * which can be consumed by `_.fromPairs`. If `object` is a map or set, its\n     * entries are returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias entries\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the key-value pairs.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.toPairs(new Foo);\n     * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)\n     */\n    var toPairs = createToPairs(keys);\n\n    /**\n     * Creates an array of own and inherited enumerable string keyed-value pairs\n     * for `object` which can be consumed by `_.fromPairs`. If `object` is a map\n     * or set, its entries are returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias entriesIn\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the key-value pairs.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.toPairsIn(new Foo);\n     * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)\n     */\n    var toPairsIn = createToPairs(keysIn);\n\n    /**\n     * An alternative to `_.reduce`; this method transforms `object` to a new\n     * `accumulator` object which is the result of running each of its own\n     * enumerable string keyed properties thru `iteratee`, with each invocation\n     * potentially mutating the `accumulator` object. If `accumulator` is not\n     * provided, a new object with the same `[[Prototype]]` will be used. The\n     * iteratee is invoked with four arguments: (accumulator, value, key, object).\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The custom accumulator value.\n     * @returns {*} Returns the accumulated value.\n     * @example\n     *\n     * _.transform([2, 3, 4], function(result, n) {\n     *   result.push(n *= n);\n     *   return n % 2 == 0;\n     * }, []);\n     * // => [4, 9]\n     *\n     * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n     *   (result[value] || (result[value] = [])).push(key);\n     * }, {});\n     * // => { '1': ['a', 'c'], '2': ['b'] }\n     */\n    function transform(object, iteratee, accumulator) {\n      var isArr = isArray(object),\n          isArrLike = isArr || isBuffer(object) || isTypedArray(object);\n\n      iteratee = getIteratee(iteratee, 4);\n      if (accumulator == null) {\n        var Ctor = object && object.constructor;\n        if (isArrLike) {\n          accumulator = isArr ? new Ctor : [];\n        }\n        else if (isObject(object)) {\n          accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};\n        }\n        else {\n          accumulator = {};\n        }\n      }\n      (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {\n        return iteratee(accumulator, value, index, object);\n      });\n      return accumulator;\n    }\n\n    /**\n     * Removes the property at `path` of `object`.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to unset.\n     * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 7 } }] };\n     * _.unset(object, 'a[0].b.c');\n     * // => true\n     *\n     * console.log(object);\n     * // => { 'a': [{ 'b': {} }] };\n     *\n     * _.unset(object, ['a', '0', 'b', 'c']);\n     * // => true\n     *\n     * console.log(object);\n     * // => { 'a': [{ 'b': {} }] };\n     */\n    function unset(object, path) {\n      return object == null ? true : baseUnset(object, path);\n    }\n\n    /**\n     * This method is like `_.set` except that accepts `updater` to produce the\n     * value to set. Use `_.updateWith` to customize `path` creation. The `updater`\n     * is invoked with one argument: (value).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {Function} updater The function to produce the updated value.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.update(object, 'a[0].b.c', function(n) { return n * n; });\n     * console.log(object.a[0].b.c);\n     * // => 9\n     *\n     * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });\n     * console.log(object.x[0].y.z);\n     * // => 0\n     */\n    function update(object, path, updater) {\n      return object == null ? object : baseUpdate(object, path, castFunction(updater));\n    }\n\n    /**\n     * This method is like `_.update` except that it accepts `customizer` which is\n     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`\n     * path creation is handled by the method instead. The `customizer` is invoked\n     * with three arguments: (nsValue, key, nsObject).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {Function} updater The function to produce the updated value.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {};\n     *\n     * _.updateWith(object, '[0][1]', _.constant('a'), Object);\n     * // => { '0': { '1': 'a' } }\n     */\n    function updateWith(object, path, updater, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);\n    }\n\n    /**\n     * Creates an array of the own enumerable string keyed property values of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property values.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.values(new Foo);\n     * // => [1, 2] (iteration order is not guaranteed)\n     *\n     * _.values('hi');\n     * // => ['h', 'i']\n     */\n    function values(object) {\n      return object == null ? [] : baseValues(object, keys(object));\n    }\n\n    /**\n     * Creates an array of the own and inherited enumerable string keyed property\n     * values of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property values.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.valuesIn(new Foo);\n     * // => [1, 2, 3] (iteration order is not guaranteed)\n     */\n    function valuesIn(object) {\n      return object == null ? [] : baseValues(object, keysIn(object));\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Clamps `number` within the inclusive `lower` and `upper` bounds.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Number\n     * @param {number} number The number to clamp.\n     * @param {number} [lower] The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the clamped number.\n     * @example\n     *\n     * _.clamp(-10, -5, 5);\n     * // => -5\n     *\n     * _.clamp(10, -5, 5);\n     * // => 5\n     */\n    function clamp(number, lower, upper) {\n      if (upper === undefined) {\n        upper = lower;\n        lower = undefined;\n      }\n      if (upper !== undefined) {\n        upper = toNumber(upper);\n        upper = upper === upper ? upper : 0;\n      }\n      if (lower !== undefined) {\n        lower = toNumber(lower);\n        lower = lower === lower ? lower : 0;\n      }\n      return baseClamp(toNumber(number), lower, upper);\n    }\n\n    /**\n     * Checks if `n` is between `start` and up to, but not including, `end`. If\n     * `end` is not specified, it's set to `start` with `start` then set to `0`.\n     * If `start` is greater than `end` the params are swapped to support\n     * negative ranges.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.3.0\n     * @category Number\n     * @param {number} number The number to check.\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n     * @see _.range, _.rangeRight\n     * @example\n     *\n     * _.inRange(3, 2, 4);\n     * // => true\n     *\n     * _.inRange(4, 8);\n     * // => true\n     *\n     * _.inRange(4, 2);\n     * // => false\n     *\n     * _.inRange(2, 2);\n     * // => false\n     *\n     * _.inRange(1.2, 2);\n     * // => true\n     *\n     * _.inRange(5.2, 4);\n     * // => false\n     *\n     * _.inRange(-3, -2, -6);\n     * // => true\n     */\n    function inRange(number, start, end) {\n      start = toFinite(start);\n      if (end === undefined) {\n        end = start;\n        start = 0;\n      } else {\n        end = toFinite(end);\n      }\n      number = toNumber(number);\n      return baseInRange(number, start, end);\n    }\n\n    /**\n     * Produces a random number between the inclusive `lower` and `upper` bounds.\n     * If only one argument is provided a number between `0` and the given number\n     * is returned. If `floating` is `true`, or either `lower` or `upper` are\n     * floats, a floating-point number is returned instead of an integer.\n     *\n     * **Note:** JavaScript follows the IEEE-754 standard for resolving\n     * floating-point values which can produce unexpected results.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.7.0\n     * @category Number\n     * @param {number} [lower=0] The lower bound.\n     * @param {number} [upper=1] The upper bound.\n     * @param {boolean} [floating] Specify returning a floating-point number.\n     * @returns {number} Returns the random number.\n     * @example\n     *\n     * _.random(0, 5);\n     * // => an integer between 0 and 5\n     *\n     * _.random(5);\n     * // => also an integer between 0 and 5\n     *\n     * _.random(5, true);\n     * // => a floating-point number between 0 and 5\n     *\n     * _.random(1.2, 5.2);\n     * // => a floating-point number between 1.2 and 5.2\n     */\n    function random(lower, upper, floating) {\n      if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {\n        upper = floating = undefined;\n      }\n      if (floating === undefined) {\n        if (typeof upper == 'boolean') {\n          floating = upper;\n          upper = undefined;\n        }\n        else if (typeof lower == 'boolean') {\n          floating = lower;\n          lower = undefined;\n        }\n      }\n      if (lower === undefined && upper === undefined) {\n        lower = 0;\n        upper = 1;\n      }\n      else {\n        lower = toFinite(lower);\n        if (upper === undefined) {\n          upper = lower;\n          lower = 0;\n        } else {\n          upper = toFinite(upper);\n        }\n      }\n      if (lower > upper) {\n        var temp = lower;\n        lower = upper;\n        upper = temp;\n      }\n      if (floating || lower % 1 || upper % 1) {\n        var rand = nativeRandom();\n        return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);\n      }\n      return baseRandom(lower, upper);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the camel cased string.\n     * @example\n     *\n     * _.camelCase('Foo Bar');\n     * // => 'fooBar'\n     *\n     * _.camelCase('--foo-bar--');\n     * // => 'fooBar'\n     *\n     * _.camelCase('__FOO_BAR__');\n     * // => 'fooBar'\n     */\n    var camelCase = createCompounder(function(result, word, index) {\n      word = word.toLowerCase();\n      return result + (index ? capitalize(word) : word);\n    });\n\n    /**\n     * Converts the first character of `string` to upper case and the remaining\n     * to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to capitalize.\n     * @returns {string} Returns the capitalized string.\n     * @example\n     *\n     * _.capitalize('FRED');\n     * // => 'Fred'\n     */\n    function capitalize(string) {\n      return upperFirst(toString(string).toLowerCase());\n    }\n\n    /**\n     * Deburrs `string` by converting\n     * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)\n     * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)\n     * letters to basic Latin letters and removing\n     * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to deburr.\n     * @returns {string} Returns the deburred string.\n     * @example\n     *\n     * _.deburr('déjà vu');\n     * // => 'deja vu'\n     */\n    function deburr(string) {\n      string = toString(string);\n      return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');\n    }\n\n    /**\n     * Checks if `string` ends with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=string.length] The position to search up to.\n     * @returns {boolean} Returns `true` if `string` ends with `target`,\n     *  else `false`.\n     * @example\n     *\n     * _.endsWith('abc', 'c');\n     * // => true\n     *\n     * _.endsWith('abc', 'b');\n     * // => false\n     *\n     * _.endsWith('abc', 'b', 2);\n     * // => true\n     */\n    function endsWith(string, target, position) {\n      string = toString(string);\n      target = baseToString(target);\n\n      var length = string.length;\n      position = position === undefined\n        ? length\n        : baseClamp(toInteger(position), 0, length);\n\n      var end = position;\n      position -= target.length;\n      return position >= 0 && string.slice(position, end) == target;\n    }\n\n    /**\n     * Converts the characters \"&\", \"<\", \">\", '\"', and \"'\" in `string` to their\n     * corresponding HTML entities.\n     *\n     * **Note:** No other characters are escaped. To escape additional\n     * characters use a third-party library like [_he_](https://mths.be/he).\n     *\n     * Though the \">\" character is escaped for symmetry, characters like\n     * \">\" and \"/\" don't need escaping in HTML and have no special meaning\n     * unless they're part of a tag or unquoted attribute value. See\n     * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\n     * (under \"semi-related fun fact\") for more details.\n     *\n     * When working with HTML you should always\n     * [quote attribute values](http://wonko.com/post/html-escaping) to reduce\n     * XSS vectors.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escape('fred, barney, & pebbles');\n     * // => 'fred, barney, &amp; pebbles'\n     */\n    function escape(string) {\n      string = toString(string);\n      return (string && reHasUnescapedHtml.test(string))\n        ? string.replace(reUnescapedHtml, escapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Escapes the `RegExp` special characters \"^\", \"$\", \"\\\", \".\", \"*\", \"+\",\n     * \"?\", \"(\", \")\", \"[\", \"]\", \"{\", \"}\", and \"|\" in `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escapeRegExp('[lodash](https://lodash.com/)');\n     * // => '\\[lodash\\]\\(https://lodash\\.com/\\)'\n     */\n    function escapeRegExp(string) {\n      string = toString(string);\n      return (string && reHasRegExpChar.test(string))\n        ? string.replace(reRegExpChar, '\\\\$&')\n        : string;\n    }\n\n    /**\n     * Converts `string` to\n     * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the kebab cased string.\n     * @example\n     *\n     * _.kebabCase('Foo Bar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('fooBar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('__FOO_BAR__');\n     * // => 'foo-bar'\n     */\n    var kebabCase = createCompounder(function(result, word, index) {\n      return result + (index ? '-' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts `string`, as space separated words, to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the lower cased string.\n     * @example\n     *\n     * _.lowerCase('--Foo-Bar--');\n     * // => 'foo bar'\n     *\n     * _.lowerCase('fooBar');\n     * // => 'foo bar'\n     *\n     * _.lowerCase('__FOO_BAR__');\n     * // => 'foo bar'\n     */\n    var lowerCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts the first character of `string` to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.lowerFirst('Fred');\n     * // => 'fred'\n     *\n     * _.lowerFirst('FRED');\n     * // => 'fRED'\n     */\n    var lowerFirst = createCaseFirst('toLowerCase');\n\n    /**\n     * Pads `string` on the left and right sides if it's shorter than `length`.\n     * Padding characters are truncated if they can't be evenly divided by `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.pad('abc', 8);\n     * // => '  abc   '\n     *\n     * _.pad('abc', 8, '_-');\n     * // => '_-abc_-_'\n     *\n     * _.pad('abc', 3);\n     * // => 'abc'\n     */\n    function pad(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      if (!length || strLength >= length) {\n        return string;\n      }\n      var mid = (length - strLength) / 2;\n      return (\n        createPadding(nativeFloor(mid), chars) +\n        string +\n        createPadding(nativeCeil(mid), chars)\n      );\n    }\n\n    /**\n     * Pads `string` on the right side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padEnd('abc', 6);\n     * // => 'abc   '\n     *\n     * _.padEnd('abc', 6, '_-');\n     * // => 'abc_-_'\n     *\n     * _.padEnd('abc', 3);\n     * // => 'abc'\n     */\n    function padEnd(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      return (length && strLength < length)\n        ? (string + createPadding(length - strLength, chars))\n        : string;\n    }\n\n    /**\n     * Pads `string` on the left side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padStart('abc', 6);\n     * // => '   abc'\n     *\n     * _.padStart('abc', 6, '_-');\n     * // => '_-_abc'\n     *\n     * _.padStart('abc', 3);\n     * // => 'abc'\n     */\n    function padStart(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      return (length && strLength < length)\n        ? (createPadding(length - strLength, chars) + string)\n        : string;\n    }\n\n    /**\n     * Converts `string` to an integer of the specified radix. If `radix` is\n     * `undefined` or `0`, a `radix` of `10` is used unless `value` is a\n     * hexadecimal, in which case a `radix` of `16` is used.\n     *\n     * **Note:** This method aligns with the\n     * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category String\n     * @param {string} string The string to convert.\n     * @param {number} [radix=10] The radix to interpret `value` by.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.parseInt('08');\n     * // => 8\n     *\n     * _.map(['6', '08', '10'], _.parseInt);\n     * // => [6, 8, 10]\n     */\n    function parseInt(string, radix, guard) {\n      if (guard || radix == null) {\n        radix = 0;\n      } else if (radix) {\n        radix = +radix;\n      }\n      return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);\n    }\n\n    /**\n     * Repeats the given string `n` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to repeat.\n     * @param {number} [n=1] The number of times to repeat the string.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the repeated string.\n     * @example\n     *\n     * _.repeat('*', 3);\n     * // => '***'\n     *\n     * _.repeat('abc', 2);\n     * // => 'abcabc'\n     *\n     * _.repeat('abc', 0);\n     * // => ''\n     */\n    function repeat(string, n, guard) {\n      if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {\n        n = 1;\n      } else {\n        n = toInteger(n);\n      }\n      return baseRepeat(toString(string), n);\n    }\n\n    /**\n     * Replaces matches for `pattern` in `string` with `replacement`.\n     *\n     * **Note:** This method is based on\n     * [`String#replace`](https://mdn.io/String/replace).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to modify.\n     * @param {RegExp|string} pattern The pattern to replace.\n     * @param {Function|string} replacement The match replacement.\n     * @returns {string} Returns the modified string.\n     * @example\n     *\n     * _.replace('Hi Fred', 'Fred', 'Barney');\n     * // => 'Hi Barney'\n     */\n    function replace() {\n      var args = arguments,\n          string = toString(args[0]);\n\n      return args.length < 3 ? string : string.replace(args[1], args[2]);\n    }\n\n    /**\n     * Converts `string` to\n     * [snake case](https://en.wikipedia.org/wiki/Snake_case).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the snake cased string.\n     * @example\n     *\n     * _.snakeCase('Foo Bar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('fooBar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('--FOO-BAR--');\n     * // => 'foo_bar'\n     */\n    var snakeCase = createCompounder(function(result, word, index) {\n      return result + (index ? '_' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Splits `string` by `separator`.\n     *\n     * **Note:** This method is based on\n     * [`String#split`](https://mdn.io/String/split).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to split.\n     * @param {RegExp|string} separator The separator pattern to split by.\n     * @param {number} [limit] The length to truncate results to.\n     * @returns {Array} Returns the string segments.\n     * @example\n     *\n     * _.split('a-b-c', '-', 2);\n     * // => ['a', 'b']\n     */\n    function split(string, separator, limit) {\n      if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {\n        separator = limit = undefined;\n      }\n      limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;\n      if (!limit) {\n        return [];\n      }\n      string = toString(string);\n      if (string && (\n            typeof separator == 'string' ||\n            (separator != null && !isRegExp(separator))\n          )) {\n        separator = baseToString(separator);\n        if (!separator && hasUnicode(string)) {\n          return castSlice(stringToArray(string), 0, limit);\n        }\n      }\n      return string.split(separator, limit);\n    }\n\n    /**\n     * Converts `string` to\n     * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.1.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the start cased string.\n     * @example\n     *\n     * _.startCase('--foo-bar--');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('fooBar');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('__FOO_BAR__');\n     * // => 'FOO BAR'\n     */\n    var startCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + upperFirst(word);\n    });\n\n    /**\n     * Checks if `string` starts with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=0] The position to search from.\n     * @returns {boolean} Returns `true` if `string` starts with `target`,\n     *  else `false`.\n     * @example\n     *\n     * _.startsWith('abc', 'a');\n     * // => true\n     *\n     * _.startsWith('abc', 'b');\n     * // => false\n     *\n     * _.startsWith('abc', 'b', 1);\n     * // => true\n     */\n    function startsWith(string, target, position) {\n      string = toString(string);\n      position = position == null\n        ? 0\n        : baseClamp(toInteger(position), 0, string.length);\n\n      target = baseToString(target);\n      return string.slice(position, position + target.length) == target;\n    }\n\n    /**\n     * Creates a compiled template function that can interpolate data properties\n     * in \"interpolate\" delimiters, HTML-escape interpolated data properties in\n     * \"escape\" delimiters, and execute JavaScript in \"evaluate\" delimiters. Data\n     * properties may be accessed as free variables in the template. If a setting\n     * object is given, it takes precedence over `_.templateSettings` values.\n     *\n     * **Note:** In the development build `_.template` utilizes\n     * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)\n     * for easier debugging.\n     *\n     * For more information on precompiling templates see\n     * [lodash's custom builds documentation](https://lodash.com/custom-builds).\n     *\n     * For more information on Chrome extension sandboxes see\n     * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The template string.\n     * @param {Object} [options={}] The options object.\n     * @param {RegExp} [options.escape=_.templateSettings.escape]\n     *  The HTML \"escape\" delimiter.\n     * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]\n     *  The \"evaluate\" delimiter.\n     * @param {Object} [options.imports=_.templateSettings.imports]\n     *  An object to import into the template as free variables.\n     * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]\n     *  The \"interpolate\" delimiter.\n     * @param {string} [options.sourceURL='lodash.templateSources[n]']\n     *  The sourceURL of the compiled template.\n     * @param {string} [options.variable='obj']\n     *  The data object variable name.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the compiled template function.\n     * @example\n     *\n     * // Use the \"interpolate\" delimiter to create a compiled template.\n     * var compiled = _.template('hello <%= user %>!');\n     * compiled({ 'user': 'fred' });\n     * // => 'hello fred!'\n     *\n     * // Use the HTML \"escape\" delimiter to escape data property values.\n     * var compiled = _.template('<b><%- value %></b>');\n     * compiled({ 'value': '<script>' });\n     * // => '<b>&lt;script&gt;</b>'\n     *\n     * // Use the \"evaluate\" delimiter to execute JavaScript and generate HTML.\n     * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // Use the internal `print` function in \"evaluate\" delimiters.\n     * var compiled = _.template('<% print(\"hello \" + user); %>!');\n     * compiled({ 'user': 'barney' });\n     * // => 'hello barney!'\n     *\n     * // Use the ES template literal delimiter as an \"interpolate\" delimiter.\n     * // Disable support by replacing the \"interpolate\" delimiter.\n     * var compiled = _.template('hello ${ user }!');\n     * compiled({ 'user': 'pebbles' });\n     * // => 'hello pebbles!'\n     *\n     * // Use backslashes to treat delimiters as plain text.\n     * var compiled = _.template('<%= \"\\\\<%- value %\\\\>\" %>');\n     * compiled({ 'value': 'ignored' });\n     * // => '<%- value %>'\n     *\n     * // Use the `imports` option to import `jQuery` as `jq`.\n     * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';\n     * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // Use the `sourceURL` option to specify a custom sourceURL for the template.\n     * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });\n     * compiled(data);\n     * // => Find the source of \"greeting.jst\" under the Sources tab or Resources panel of the web inspector.\n     *\n     * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.\n     * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });\n     * compiled.source;\n     * // => function(data) {\n     * //   var __t, __p = '';\n     * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';\n     * //   return __p;\n     * // }\n     *\n     * // Use custom template delimiters.\n     * _.templateSettings.interpolate = /{{([\\s\\S]+?)}}/g;\n     * var compiled = _.template('hello {{ user }}!');\n     * compiled({ 'user': 'mustache' });\n     * // => 'hello mustache!'\n     *\n     * // Use the `source` property to inline compiled templates for meaningful\n     * // line numbers in error messages and stack traces.\n     * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\\\n     *   var JST = {\\\n     *     \"main\": ' + _.template(mainText).source + '\\\n     *   };\\\n     * ');\n     */\n    function template(string, options, guard) {\n      // Based on John Resig's `tmpl` implementation\n      // (http://ejohn.org/blog/javascript-micro-templating/)\n      // and Laura Doktorova's doT.js (https://github.com/olado/doT).\n      var settings = lodash.templateSettings;\n\n      if (guard && isIterateeCall(string, options, guard)) {\n        options = undefined;\n      }\n      string = toString(string);\n      options = assignInWith({}, options, settings, customDefaultsAssignIn);\n\n      var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),\n          importsKeys = keys(imports),\n          importsValues = baseValues(imports, importsKeys);\n\n      var isEscaping,\n          isEvaluating,\n          index = 0,\n          interpolate = options.interpolate || reNoMatch,\n          source = \"__p += '\";\n\n      // Compile the regexp to match each delimiter.\n      var reDelimiters = RegExp(\n        (options.escape || reNoMatch).source + '|' +\n        interpolate.source + '|' +\n        (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +\n        (options.evaluate || reNoMatch).source + '|$'\n      , 'g');\n\n      // Use a sourceURL for easier debugging.\n      var sourceURL = '//# sourceURL=' +\n        ('sourceURL' in options\n          ? options.sourceURL\n          : ('lodash.templateSources[' + (++templateCounter) + ']')\n        ) + '\\n';\n\n      string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {\n        interpolateValue || (interpolateValue = esTemplateValue);\n\n        // Escape characters that can't be included in string literals.\n        source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);\n\n        // Replace delimiters with snippets.\n        if (escapeValue) {\n          isEscaping = true;\n          source += \"' +\\n__e(\" + escapeValue + \") +\\n'\";\n        }\n        if (evaluateValue) {\n          isEvaluating = true;\n          source += \"';\\n\" + evaluateValue + \";\\n__p += '\";\n        }\n        if (interpolateValue) {\n          source += \"' +\\n((__t = (\" + interpolateValue + \")) == null ? '' : __t) +\\n'\";\n        }\n        index = offset + match.length;\n\n        // The JS engine embedded in Adobe products needs `match` returned in\n        // order to produce the correct `offset` value.\n        return match;\n      });\n\n      source += \"';\\n\";\n\n      // If `variable` is not specified wrap a with-statement around the generated\n      // code to add the data object to the top of the scope chain.\n      var variable = options.variable;\n      if (!variable) {\n        source = 'with (obj) {\\n' + source + '\\n}\\n';\n      }\n      // Cleanup code by stripping empty strings.\n      source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)\n        .replace(reEmptyStringMiddle, '$1')\n        .replace(reEmptyStringTrailing, '$1;');\n\n      // Frame code as the function body.\n      source = 'function(' + (variable || 'obj') + ') {\\n' +\n        (variable\n          ? ''\n          : 'obj || (obj = {});\\n'\n        ) +\n        \"var __t, __p = ''\" +\n        (isEscaping\n           ? ', __e = _.escape'\n           : ''\n        ) +\n        (isEvaluating\n          ? ', __j = Array.prototype.join;\\n' +\n            \"function print() { __p += __j.call(arguments, '') }\\n\"\n          : ';\\n'\n        ) +\n        source +\n        'return __p\\n}';\n\n      var result = attempt(function() {\n        return Function(importsKeys, sourceURL + 'return ' + source)\n          .apply(undefined, importsValues);\n      });\n\n      // Provide the compiled function's source by its `toString` method or\n      // the `source` property as a convenience for inlining compiled templates.\n      result.source = source;\n      if (isError(result)) {\n        throw result;\n      }\n      return result;\n    }\n\n    /**\n     * Converts `string`, as a whole, to lower case just like\n     * [String#toLowerCase](https://mdn.io/toLowerCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the lower cased string.\n     * @example\n     *\n     * _.toLower('--Foo-Bar--');\n     * // => '--foo-bar--'\n     *\n     * _.toLower('fooBar');\n     * // => 'foobar'\n     *\n     * _.toLower('__FOO_BAR__');\n     * // => '__foo_bar__'\n     */\n    function toLower(value) {\n      return toString(value).toLowerCase();\n    }\n\n    /**\n     * Converts `string`, as a whole, to upper case just like\n     * [String#toUpperCase](https://mdn.io/toUpperCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the upper cased string.\n     * @example\n     *\n     * _.toUpper('--foo-bar--');\n     * // => '--FOO-BAR--'\n     *\n     * _.toUpper('fooBar');\n     * // => 'FOOBAR'\n     *\n     * _.toUpper('__foo_bar__');\n     * // => '__FOO_BAR__'\n     */\n    function toUpper(value) {\n      return toString(value).toUpperCase();\n    }\n\n    /**\n     * Removes leading and trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trim('  abc  ');\n     * // => 'abc'\n     *\n     * _.trim('-_-abc-_-', '_-');\n     * // => 'abc'\n     *\n     * _.map(['  foo  ', '  bar  '], _.trim);\n     * // => ['foo', 'bar']\n     */\n    function trim(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.replace(reTrim, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          chrSymbols = stringToArray(chars),\n          start = charsStartIndex(strSymbols, chrSymbols),\n          end = charsEndIndex(strSymbols, chrSymbols) + 1;\n\n      return castSlice(strSymbols, start, end).join('');\n    }\n\n    /**\n     * Removes trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimEnd('  abc  ');\n     * // => '  abc'\n     *\n     * _.trimEnd('-_-abc-_-', '_-');\n     * // => '-_-abc'\n     */\n    function trimEnd(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.replace(reTrimEnd, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;\n\n      return castSlice(strSymbols, 0, end).join('');\n    }\n\n    /**\n     * Removes leading whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimStart('  abc  ');\n     * // => 'abc  '\n     *\n     * _.trimStart('-_-abc-_-', '_-');\n     * // => 'abc-_-'\n     */\n    function trimStart(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.replace(reTrimStart, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          start = charsStartIndex(strSymbols, stringToArray(chars));\n\n      return castSlice(strSymbols, start).join('');\n    }\n\n    /**\n     * Truncates `string` if it's longer than the given maximum string length.\n     * The last characters of the truncated string are replaced with the omission\n     * string which defaults to \"...\".\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to truncate.\n     * @param {Object} [options={}] The options object.\n     * @param {number} [options.length=30] The maximum string length.\n     * @param {string} [options.omission='...'] The string to indicate text is omitted.\n     * @param {RegExp|string} [options.separator] The separator pattern to truncate to.\n     * @returns {string} Returns the truncated string.\n     * @example\n     *\n     * _.truncate('hi-diddly-ho there, neighborino');\n     * // => 'hi-diddly-ho there, neighbo...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': ' '\n     * });\n     * // => 'hi-diddly-ho there,...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': /,? +/\n     * });\n     * // => 'hi-diddly-ho there...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'omission': ' [...]'\n     * });\n     * // => 'hi-diddly-ho there, neig [...]'\n     */\n    function truncate(string, options) {\n      var length = DEFAULT_TRUNC_LENGTH,\n          omission = DEFAULT_TRUNC_OMISSION;\n\n      if (isObject(options)) {\n        var separator = 'separator' in options ? options.separator : separator;\n        length = 'length' in options ? toInteger(options.length) : length;\n        omission = 'omission' in options ? baseToString(options.omission) : omission;\n      }\n      string = toString(string);\n\n      var strLength = string.length;\n      if (hasUnicode(string)) {\n        var strSymbols = stringToArray(string);\n        strLength = strSymbols.length;\n      }\n      if (length >= strLength) {\n        return string;\n      }\n      var end = length - stringSize(omission);\n      if (end < 1) {\n        return omission;\n      }\n      var result = strSymbols\n        ? castSlice(strSymbols, 0, end).join('')\n        : string.slice(0, end);\n\n      if (separator === undefined) {\n        return result + omission;\n      }\n      if (strSymbols) {\n        end += (result.length - end);\n      }\n      if (isRegExp(separator)) {\n        if (string.slice(end).search(separator)) {\n          var match,\n              substring = result;\n\n          if (!separator.global) {\n            separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');\n          }\n          separator.lastIndex = 0;\n          while ((match = separator.exec(substring))) {\n            var newEnd = match.index;\n          }\n          result = result.slice(0, newEnd === undefined ? end : newEnd);\n        }\n      } else if (string.indexOf(baseToString(separator), end) != end) {\n        var index = result.lastIndexOf(separator);\n        if (index > -1) {\n          result = result.slice(0, index);\n        }\n      }\n      return result + omission;\n    }\n\n    /**\n     * The inverse of `_.escape`; this method converts the HTML entities\n     * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to\n     * their corresponding characters.\n     *\n     * **Note:** No other HTML entities are unescaped. To unescape additional\n     * HTML entities use a third-party library like [_he_](https://mths.be/he).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.6.0\n     * @category String\n     * @param {string} [string=''] The string to unescape.\n     * @returns {string} Returns the unescaped string.\n     * @example\n     *\n     * _.unescape('fred, barney, &amp; pebbles');\n     * // => 'fred, barney, & pebbles'\n     */\n    function unescape(string) {\n      string = toString(string);\n      return (string && reHasEscapedHtml.test(string))\n        ? string.replace(reEscapedHtml, unescapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Converts `string`, as space separated words, to upper case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the upper cased string.\n     * @example\n     *\n     * _.upperCase('--foo-bar');\n     * // => 'FOO BAR'\n     *\n     * _.upperCase('fooBar');\n     * // => 'FOO BAR'\n     *\n     * _.upperCase('__foo_bar__');\n     * // => 'FOO BAR'\n     */\n    var upperCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + word.toUpperCase();\n    });\n\n    /**\n     * Converts the first character of `string` to upper case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.upperFirst('fred');\n     * // => 'Fred'\n     *\n     * _.upperFirst('FRED');\n     * // => 'FRED'\n     */\n    var upperFirst = createCaseFirst('toUpperCase');\n\n    /**\n     * Splits `string` into an array of its words.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {RegExp|string} [pattern] The pattern to match words.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the words of `string`.\n     * @example\n     *\n     * _.words('fred, barney, & pebbles');\n     * // => ['fred', 'barney', 'pebbles']\n     *\n     * _.words('fred, barney, & pebbles', /[^, ]+/g);\n     * // => ['fred', 'barney', '&', 'pebbles']\n     */\n    function words(string, pattern, guard) {\n      string = toString(string);\n      pattern = guard ? undefined : pattern;\n\n      if (pattern === undefined) {\n        return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);\n      }\n      return string.match(pattern) || [];\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Attempts to invoke `func`, returning either the result or the caught error\n     * object. Any additional arguments are provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Function} func The function to attempt.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {*} Returns the `func` result or error object.\n     * @example\n     *\n     * // Avoid throwing errors for invalid selectors.\n     * var elements = _.attempt(function(selector) {\n     *   return document.querySelectorAll(selector);\n     * }, '>_>');\n     *\n     * if (_.isError(elements)) {\n     *   elements = [];\n     * }\n     */\n    var attempt = baseRest(function(func, args) {\n      try {\n        return apply(func, undefined, args);\n      } catch (e) {\n        return isError(e) ? e : new Error(e);\n      }\n    });\n\n    /**\n     * Binds methods of an object to the object itself, overwriting the existing\n     * method.\n     *\n     * **Note:** This method doesn't set the \"length\" property of bound functions.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {Object} object The object to bind and assign the bound methods to.\n     * @param {...(string|string[])} methodNames The object method names to bind.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var view = {\n     *   'label': 'docs',\n     *   'click': function() {\n     *     console.log('clicked ' + this.label);\n     *   }\n     * };\n     *\n     * _.bindAll(view, ['click']);\n     * jQuery(element).on('click', view.click);\n     * // => Logs 'clicked docs' when clicked.\n     */\n    var bindAll = flatRest(function(object, methodNames) {\n      arrayEach(methodNames, function(key) {\n        key = toKey(key);\n        baseAssignValue(object, key, bind(object[key], object));\n      });\n      return object;\n    });\n\n    /**\n     * Creates a function that iterates over `pairs` and invokes the corresponding\n     * function of the first predicate to return truthy. The predicate-function\n     * pairs are invoked with the `this` binding and arguments of the created\n     * function.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {Array} pairs The predicate-function pairs.\n     * @returns {Function} Returns the new composite function.\n     * @example\n     *\n     * var func = _.cond([\n     *   [_.matches({ 'a': 1 }),           _.constant('matches A')],\n     *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],\n     *   [_.stubTrue,                      _.constant('no match')]\n     * ]);\n     *\n     * func({ 'a': 1, 'b': 2 });\n     * // => 'matches A'\n     *\n     * func({ 'a': 0, 'b': 1 });\n     * // => 'matches B'\n     *\n     * func({ 'a': '1', 'b': '2' });\n     * // => 'no match'\n     */\n    function cond(pairs) {\n      var length = pairs == null ? 0 : pairs.length,\n          toIteratee = getIteratee();\n\n      pairs = !length ? [] : arrayMap(pairs, function(pair) {\n        if (typeof pair[1] != 'function') {\n          throw new TypeError(FUNC_ERROR_TEXT);\n        }\n        return [toIteratee(pair[0]), pair[1]];\n      });\n\n      return baseRest(function(args) {\n        var index = -1;\n        while (++index < length) {\n          var pair = pairs[index];\n          if (apply(pair[0], this, args)) {\n            return apply(pair[1], this, args);\n          }\n        }\n      });\n    }\n\n    /**\n     * Creates a function that invokes the predicate properties of `source` with\n     * the corresponding property values of a given object, returning `true` if\n     * all predicates return truthy, else `false`.\n     *\n     * **Note:** The created function is equivalent to `_.conformsTo` with\n     * `source` partially applied.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 2, 'b': 1 },\n     *   { 'a': 1, 'b': 2 }\n     * ];\n     *\n     * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));\n     * // => [{ 'a': 1, 'b': 2 }]\n     */\n    function conforms(source) {\n      return baseConforms(baseClone(source, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that returns `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Util\n     * @param {*} value The value to return from the new function.\n     * @returns {Function} Returns the new constant function.\n     * @example\n     *\n     * var objects = _.times(2, _.constant({ 'a': 1 }));\n     *\n     * console.log(objects);\n     * // => [{ 'a': 1 }, { 'a': 1 }]\n     *\n     * console.log(objects[0] === objects[1]);\n     * // => true\n     */\n    function constant(value) {\n      return function() {\n        return value;\n      };\n    }\n\n    /**\n     * Checks `value` to determine whether a default value should be returned in\n     * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,\n     * or `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.14.0\n     * @category Util\n     * @param {*} value The value to check.\n     * @param {*} defaultValue The default value.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * _.defaultTo(1, 10);\n     * // => 1\n     *\n     * _.defaultTo(undefined, 10);\n     * // => 10\n     */\n    function defaultTo(value, defaultValue) {\n      return (value == null || value !== value) ? defaultValue : value;\n    }\n\n    /**\n     * Creates a function that returns the result of invoking the given functions\n     * with the `this` binding of the created function, where each successive\n     * invocation is supplied the return value of the previous.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [funcs] The functions to invoke.\n     * @returns {Function} Returns the new composite function.\n     * @see _.flowRight\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flow([_.add, square]);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flow = createFlow();\n\n    /**\n     * This method is like `_.flow` except that it creates a function that\n     * invokes the given functions from right to left.\n     *\n     * @static\n     * @since 3.0.0\n     * @memberOf _\n     * @category Util\n     * @param {...(Function|Function[])} [funcs] The functions to invoke.\n     * @returns {Function} Returns the new composite function.\n     * @see _.flow\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flowRight([square, _.add]);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flowRight = createFlow(true);\n\n    /**\n     * This method returns the first argument it receives.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {*} value Any value.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     *\n     * console.log(_.identity(object) === object);\n     * // => true\n     */\n    function identity(value) {\n      return value;\n    }\n\n    /**\n     * Creates a function that invokes `func` with the arguments of the created\n     * function. If `func` is a property name, the created function returns the\n     * property value for a given element. If `func` is an array or object, the\n     * created function returns `true` for elements that contain the equivalent\n     * source properties, otherwise it returns `false`.\n     *\n     * @static\n     * @since 4.0.0\n     * @memberOf _\n     * @category Util\n     * @param {*} [func=_.identity] The value to convert to a callback.\n     * @returns {Function} Returns the callback.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));\n     * // => [{ 'user': 'barney', 'age': 36, 'active': true }]\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.filter(users, _.iteratee(['user', 'fred']));\n     * // => [{ 'user': 'fred', 'age': 40 }]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.map(users, _.iteratee('user'));\n     * // => ['barney', 'fred']\n     *\n     * // Create custom iteratee shorthands.\n     * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {\n     *   return !_.isRegExp(func) ? iteratee(func) : function(string) {\n     *     return func.test(string);\n     *   };\n     * });\n     *\n     * _.filter(['abc', 'def'], /ef/);\n     * // => ['def']\n     */\n    function iteratee(func) {\n      return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that performs a partial deep comparison between a given\n     * object and `source`, returning `true` if the given object has equivalent\n     * property values, else `false`.\n     *\n     * **Note:** The created function is equivalent to `_.isMatch` with `source`\n     * partially applied.\n     *\n     * Partial comparisons will match empty array and empty object `source`\n     * values against any array or object value, respectively. See `_.isEqual`\n     * for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 1, 'b': 2, 'c': 3 },\n     *   { 'a': 4, 'b': 5, 'c': 6 }\n     * ];\n     *\n     * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));\n     * // => [{ 'a': 4, 'b': 5, 'c': 6 }]\n     */\n    function matches(source) {\n      return baseMatches(baseClone(source, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that performs a partial deep comparison between the\n     * value at `path` of a given object to `srcValue`, returning `true` if the\n     * object value is equivalent, else `false`.\n     *\n     * **Note:** Partial comparisons will match empty array and empty object\n     * `srcValue` values against any array or object value, respectively. See\n     * `_.isEqual` for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Util\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 1, 'b': 2, 'c': 3 },\n     *   { 'a': 4, 'b': 5, 'c': 6 }\n     * ];\n     *\n     * _.find(objects, _.matchesProperty('a', 4));\n     * // => { 'a': 4, 'b': 5, 'c': 6 }\n     */\n    function matchesProperty(path, srcValue) {\n      return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that invokes the method at `path` of a given object.\n     * Any additional arguments are provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Util\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new invoker function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': _.constant(2) } },\n     *   { 'a': { 'b': _.constant(1) } }\n     * ];\n     *\n     * _.map(objects, _.method('a.b'));\n     * // => [2, 1]\n     *\n     * _.map(objects, _.method(['a', 'b']));\n     * // => [2, 1]\n     */\n    var method = baseRest(function(path, args) {\n      return function(object) {\n        return baseInvoke(object, path, args);\n      };\n    });\n\n    /**\n     * The opposite of `_.method`; this method creates a function that invokes\n     * the method at a given path of `object`. Any additional arguments are\n     * provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Util\n     * @param {Object} object The object to query.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new invoker function.\n     * @example\n     *\n     * var array = _.times(3, _.constant),\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.methodOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.methodOf(object));\n     * // => [2, 0]\n     */\n    var methodOf = baseRest(function(object, args) {\n      return function(path) {\n        return baseInvoke(object, path, args);\n      };\n    });\n\n    /**\n     * Adds all own enumerable string keyed function properties of a source\n     * object to the destination object. If `object` is a function, then methods\n     * are added to its prototype as well.\n     *\n     * **Note:** Use `_.runInContext` to create a pristine `lodash` function to\n     * avoid conflicts caused by modifying the original.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {Function|Object} [object=lodash] The destination object.\n     * @param {Object} source The object of functions to add.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.chain=true] Specify whether mixins are chainable.\n     * @returns {Function|Object} Returns `object`.\n     * @example\n     *\n     * function vowels(string) {\n     *   return _.filter(string, function(v) {\n     *     return /[aeiou]/i.test(v);\n     *   });\n     * }\n     *\n     * _.mixin({ 'vowels': vowels });\n     * _.vowels('fred');\n     * // => ['e']\n     *\n     * _('fred').vowels().value();\n     * // => ['e']\n     *\n     * _.mixin({ 'vowels': vowels }, { 'chain': false });\n     * _('fred').vowels();\n     * // => ['e']\n     */\n    function mixin(object, source, options) {\n      var props = keys(source),\n          methodNames = baseFunctions(source, props);\n\n      if (options == null &&\n          !(isObject(source) && (methodNames.length || !props.length))) {\n        options = source;\n        source = object;\n        object = this;\n        methodNames = baseFunctions(source, keys(source));\n      }\n      var chain = !(isObject(options) && 'chain' in options) || !!options.chain,\n          isFunc = isFunction(object);\n\n      arrayEach(methodNames, function(methodName) {\n        var func = source[methodName];\n        object[methodName] = func;\n        if (isFunc) {\n          object.prototype[methodName] = function() {\n            var chainAll = this.__chain__;\n            if (chain || chainAll) {\n              var result = object(this.__wrapped__),\n                  actions = result.__actions__ = copyArray(this.__actions__);\n\n              actions.push({ 'func': func, 'args': arguments, 'thisArg': object });\n              result.__chain__ = chainAll;\n              return result;\n            }\n            return func.apply(object, arrayPush([this.value()], arguments));\n          };\n        }\n      });\n\n      return object;\n    }\n\n    /**\n     * Reverts the `_` variable to its previous value and returns a reference to\n     * the `lodash` function.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @returns {Function} Returns the `lodash` function.\n     * @example\n     *\n     * var lodash = _.noConflict();\n     */\n    function noConflict() {\n      if (root._ === this) {\n        root._ = oldDash;\n      }\n      return this;\n    }\n\n    /**\n     * This method returns `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.3.0\n     * @category Util\n     * @example\n     *\n     * _.times(2, _.noop);\n     * // => [undefined, undefined]\n     */\n    function noop() {\n      // No operation performed.\n    }\n\n    /**\n     * Creates a function that gets the argument at index `n`. If `n` is negative,\n     * the nth argument from the end is returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {number} [n=0] The index of the argument to return.\n     * @returns {Function} Returns the new pass-thru function.\n     * @example\n     *\n     * var func = _.nthArg(1);\n     * func('a', 'b', 'c', 'd');\n     * // => 'b'\n     *\n     * var func = _.nthArg(-2);\n     * func('a', 'b', 'c', 'd');\n     * // => 'c'\n     */\n    function nthArg(n) {\n      n = toInteger(n);\n      return baseRest(function(args) {\n        return baseNth(args, n);\n      });\n    }\n\n    /**\n     * Creates a function that invokes `iteratees` with the arguments it receives\n     * and returns their results.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [iteratees=[_.identity]]\n     *  The iteratees to invoke.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.over([Math.max, Math.min]);\n     *\n     * func(1, 2, 3, 4);\n     * // => [4, 1]\n     */\n    var over = createOver(arrayMap);\n\n    /**\n     * Creates a function that checks if **all** of the `predicates` return\n     * truthy when invoked with the arguments it receives.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [predicates=[_.identity]]\n     *  The predicates to check.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.overEvery([Boolean, isFinite]);\n     *\n     * func('1');\n     * // => true\n     *\n     * func(null);\n     * // => false\n     *\n     * func(NaN);\n     * // => false\n     */\n    var overEvery = createOver(arrayEvery);\n\n    /**\n     * Creates a function that checks if **any** of the `predicates` return\n     * truthy when invoked with the arguments it receives.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [predicates=[_.identity]]\n     *  The predicates to check.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.overSome([Boolean, isFinite]);\n     *\n     * func('1');\n     * // => true\n     *\n     * func(null);\n     * // => true\n     *\n     * func(NaN);\n     * // => false\n     */\n    var overSome = createOver(arraySome);\n\n    /**\n     * Creates a function that returns the value at `path` of a given object.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Util\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new accessor function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': 2 } },\n     *   { 'a': { 'b': 1 } }\n     * ];\n     *\n     * _.map(objects, _.property('a.b'));\n     * // => [2, 1]\n     *\n     * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');\n     * // => [1, 2]\n     */\n    function property(path) {\n      return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n    }\n\n    /**\n     * The opposite of `_.property`; this method creates a function that returns\n     * the value at a given path of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Object} object The object to query.\n     * @returns {Function} Returns the new accessor function.\n     * @example\n     *\n     * var array = [0, 1, 2],\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.propertyOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));\n     * // => [2, 0]\n     */\n    function propertyOf(object) {\n      return function(path) {\n        return object == null ? undefined : baseGet(object, path);\n      };\n    }\n\n    /**\n     * Creates an array of numbers (positive and/or negative) progressing from\n     * `start` up to, but not including, `end`. A step of `-1` is used if a negative\n     * `start` is specified without an `end` or `step`. If `end` is not specified,\n     * it's set to `start` with `start` then set to `0`.\n     *\n     * **Note:** JavaScript follows the IEEE-754 standard for resolving\n     * floating-point values which can produce unexpected results.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the range of numbers.\n     * @see _.inRange, _.rangeRight\n     * @example\n     *\n     * _.range(4);\n     * // => [0, 1, 2, 3]\n     *\n     * _.range(-4);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 5);\n     * // => [1, 2, 3, 4]\n     *\n     * _.range(0, 20, 5);\n     * // => [0, 5, 10, 15]\n     *\n     * _.range(0, -4, -1);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.range(0);\n     * // => []\n     */\n    var range = createRange();\n\n    /**\n     * This method is like `_.range` except that it populates values in\n     * descending order.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the range of numbers.\n     * @see _.inRange, _.range\n     * @example\n     *\n     * _.rangeRight(4);\n     * // => [3, 2, 1, 0]\n     *\n     * _.rangeRight(-4);\n     * // => [-3, -2, -1, 0]\n     *\n     * _.rangeRight(1, 5);\n     * // => [4, 3, 2, 1]\n     *\n     * _.rangeRight(0, 20, 5);\n     * // => [15, 10, 5, 0]\n     *\n     * _.rangeRight(0, -4, -1);\n     * // => [-3, -2, -1, 0]\n     *\n     * _.rangeRight(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.rangeRight(0);\n     * // => []\n     */\n    var rangeRight = createRange(true);\n\n    /**\n     * This method returns a new empty array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {Array} Returns the new empty array.\n     * @example\n     *\n     * var arrays = _.times(2, _.stubArray);\n     *\n     * console.log(arrays);\n     * // => [[], []]\n     *\n     * console.log(arrays[0] === arrays[1]);\n     * // => false\n     */\n    function stubArray() {\n      return [];\n    }\n\n    /**\n     * This method returns `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {boolean} Returns `false`.\n     * @example\n     *\n     * _.times(2, _.stubFalse);\n     * // => [false, false]\n     */\n    function stubFalse() {\n      return false;\n    }\n\n    /**\n     * This method returns a new empty object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {Object} Returns the new empty object.\n     * @example\n     *\n     * var objects = _.times(2, _.stubObject);\n     *\n     * console.log(objects);\n     * // => [{}, {}]\n     *\n     * console.log(objects[0] === objects[1]);\n     * // => false\n     */\n    function stubObject() {\n      return {};\n    }\n\n    /**\n     * This method returns an empty string.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {string} Returns the empty string.\n     * @example\n     *\n     * _.times(2, _.stubString);\n     * // => ['', '']\n     */\n    function stubString() {\n      return '';\n    }\n\n    /**\n     * This method returns `true`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {boolean} Returns `true`.\n     * @example\n     *\n     * _.times(2, _.stubTrue);\n     * // => [true, true]\n     */\n    function stubTrue() {\n      return true;\n    }\n\n    /**\n     * Invokes the iteratee `n` times, returning an array of the results of\n     * each invocation. The iteratee is invoked with one argument; (index).\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {number} n The number of times to invoke `iteratee`.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * _.times(3, String);\n     * // => ['0', '1', '2']\n     *\n     *  _.times(4, _.constant(0));\n     * // => [0, 0, 0, 0]\n     */\n    function times(n, iteratee) {\n      n = toInteger(n);\n      if (n < 1 || n > MAX_SAFE_INTEGER) {\n        return [];\n      }\n      var index = MAX_ARRAY_LENGTH,\n          length = nativeMin(n, MAX_ARRAY_LENGTH);\n\n      iteratee = getIteratee(iteratee);\n      n -= MAX_ARRAY_LENGTH;\n\n      var result = baseTimes(length, iteratee);\n      while (++index < n) {\n        iteratee(index);\n      }\n      return result;\n    }\n\n    /**\n     * Converts `value` to a property path array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the new property path array.\n     * @example\n     *\n     * _.toPath('a.b.c');\n     * // => ['a', 'b', 'c']\n     *\n     * _.toPath('a[0].b.c');\n     * // => ['a', '0', 'b', 'c']\n     */\n    function toPath(value) {\n      if (isArray(value)) {\n        return arrayMap(value, toKey);\n      }\n      return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));\n    }\n\n    /**\n     * Generates a unique ID. If `prefix` is given, the ID is appended to it.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {string} [prefix=''] The value to prefix the ID with.\n     * @returns {string} Returns the unique ID.\n     * @example\n     *\n     * _.uniqueId('contact_');\n     * // => 'contact_104'\n     *\n     * _.uniqueId();\n     * // => '105'\n     */\n    function uniqueId(prefix) {\n      var id = ++idCounter;\n      return toString(prefix) + id;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Adds two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.4.0\n     * @category Math\n     * @param {number} augend The first number in an addition.\n     * @param {number} addend The second number in an addition.\n     * @returns {number} Returns the total.\n     * @example\n     *\n     * _.add(6, 4);\n     * // => 10\n     */\n    var add = createMathOperation(function(augend, addend) {\n      return augend + addend;\n    }, 0);\n\n    /**\n     * Computes `number` rounded up to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round up.\n     * @param {number} [precision=0] The precision to round up to.\n     * @returns {number} Returns the rounded up number.\n     * @example\n     *\n     * _.ceil(4.006);\n     * // => 5\n     *\n     * _.ceil(6.004, 2);\n     * // => 6.01\n     *\n     * _.ceil(6040, -2);\n     * // => 6100\n     */\n    var ceil = createRound('ceil');\n\n    /**\n     * Divide two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {number} dividend The first number in a division.\n     * @param {number} divisor The second number in a division.\n     * @returns {number} Returns the quotient.\n     * @example\n     *\n     * _.divide(6, 4);\n     * // => 1.5\n     */\n    var divide = createMathOperation(function(dividend, divisor) {\n      return dividend / divisor;\n    }, 1);\n\n    /**\n     * Computes `number` rounded down to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round down.\n     * @param {number} [precision=0] The precision to round down to.\n     * @returns {number} Returns the rounded down number.\n     * @example\n     *\n     * _.floor(4.006);\n     * // => 4\n     *\n     * _.floor(0.046, 2);\n     * // => 0.04\n     *\n     * _.floor(4060, -2);\n     * // => 4000\n     */\n    var floor = createRound('floor');\n\n    /**\n     * Computes the maximum value of `array`. If `array` is empty or falsey,\n     * `undefined` is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * _.max([4, 2, 8, 6]);\n     * // => 8\n     *\n     * _.max([]);\n     * // => undefined\n     */\n    function max(array) {\n      return (array && array.length)\n        ? baseExtremum(array, identity, baseGt)\n        : undefined;\n    }\n\n    /**\n     * This method is like `_.max` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * the value is ranked. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * var objects = [{ 'n': 1 }, { 'n': 2 }];\n     *\n     * _.maxBy(objects, function(o) { return o.n; });\n     * // => { 'n': 2 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.maxBy(objects, 'n');\n     * // => { 'n': 2 }\n     */\n    function maxBy(array, iteratee) {\n      return (array && array.length)\n        ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)\n        : undefined;\n    }\n\n    /**\n     * Computes the mean of the values in `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {number} Returns the mean.\n     * @example\n     *\n     * _.mean([4, 2, 8, 6]);\n     * // => 5\n     */\n    function mean(array) {\n      return baseMean(array, identity);\n    }\n\n    /**\n     * This method is like `_.mean` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the value to be averaged.\n     * The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the mean.\n     * @example\n     *\n     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n     *\n     * _.meanBy(objects, function(o) { return o.n; });\n     * // => 5\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.meanBy(objects, 'n');\n     * // => 5\n     */\n    function meanBy(array, iteratee) {\n      return baseMean(array, getIteratee(iteratee, 2));\n    }\n\n    /**\n     * Computes the minimum value of `array`. If `array` is empty or falsey,\n     * `undefined` is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * _.min([4, 2, 8, 6]);\n     * // => 2\n     *\n     * _.min([]);\n     * // => undefined\n     */\n    function min(array) {\n      return (array && array.length)\n        ? baseExtremum(array, identity, baseLt)\n        : undefined;\n    }\n\n    /**\n     * This method is like `_.min` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * the value is ranked. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * var objects = [{ 'n': 1 }, { 'n': 2 }];\n     *\n     * _.minBy(objects, function(o) { return o.n; });\n     * // => { 'n': 1 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.minBy(objects, 'n');\n     * // => { 'n': 1 }\n     */\n    function minBy(array, iteratee) {\n      return (array && array.length)\n        ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)\n        : undefined;\n    }\n\n    /**\n     * Multiply two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {number} multiplier The first number in a multiplication.\n     * @param {number} multiplicand The second number in a multiplication.\n     * @returns {number} Returns the product.\n     * @example\n     *\n     * _.multiply(6, 4);\n     * // => 24\n     */\n    var multiply = createMathOperation(function(multiplier, multiplicand) {\n      return multiplier * multiplicand;\n    }, 1);\n\n    /**\n     * Computes `number` rounded to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round.\n     * @param {number} [precision=0] The precision to round to.\n     * @returns {number} Returns the rounded number.\n     * @example\n     *\n     * _.round(4.006);\n     * // => 4\n     *\n     * _.round(4.006, 2);\n     * // => 4.01\n     *\n     * _.round(4060, -2);\n     * // => 4100\n     */\n    var round = createRound('round');\n\n    /**\n     * Subtract two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {number} minuend The first number in a subtraction.\n     * @param {number} subtrahend The second number in a subtraction.\n     * @returns {number} Returns the difference.\n     * @example\n     *\n     * _.subtract(6, 4);\n     * // => 2\n     */\n    var subtract = createMathOperation(function(minuend, subtrahend) {\n      return minuend - subtrahend;\n    }, 0);\n\n    /**\n     * Computes the sum of the values in `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.4.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * _.sum([4, 2, 8, 6]);\n     * // => 20\n     */\n    function sum(array) {\n      return (array && array.length)\n        ? baseSum(array, identity)\n        : 0;\n    }\n\n    /**\n     * This method is like `_.sum` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the value to be summed.\n     * The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n     *\n     * _.sumBy(objects, function(o) { return o.n; });\n     * // => 20\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sumBy(objects, 'n');\n     * // => 20\n     */\n    function sumBy(array, iteratee) {\n      return (array && array.length)\n        ? baseSum(array, getIteratee(iteratee, 2))\n        : 0;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    // Add methods that return wrapped values in chain sequences.\n    lodash.after = after;\n    lodash.ary = ary;\n    lodash.assign = assign;\n    lodash.assignIn = assignIn;\n    lodash.assignInWith = assignInWith;\n    lodash.assignWith = assignWith;\n    lodash.at = at;\n    lodash.before = before;\n    lodash.bind = bind;\n    lodash.bindAll = bindAll;\n    lodash.bindKey = bindKey;\n    lodash.castArray = castArray;\n    lodash.chain = chain;\n    lodash.chunk = chunk;\n    lodash.compact = compact;\n    lodash.concat = concat;\n    lodash.cond = cond;\n    lodash.conforms = conforms;\n    lodash.constant = constant;\n    lodash.countBy = countBy;\n    lodash.create = create;\n    lodash.curry = curry;\n    lodash.curryRight = curryRight;\n    lodash.debounce = debounce;\n    lodash.defaults = defaults;\n    lodash.defaultsDeep = defaultsDeep;\n    lodash.defer = defer;\n    lodash.delay = delay;\n    lodash.difference = difference;\n    lodash.differenceBy = differenceBy;\n    lodash.differenceWith = differenceWith;\n    lodash.drop = drop;\n    lodash.dropRight = dropRight;\n    lodash.dropRightWhile = dropRightWhile;\n    lodash.dropWhile = dropWhile;\n    lodash.fill = fill;\n    lodash.filter = filter;\n    lodash.flatMap = flatMap;\n    lodash.flatMapDeep = flatMapDeep;\n    lodash.flatMapDepth = flatMapDepth;\n    lodash.flatten = flatten;\n    lodash.flattenDeep = flattenDeep;\n    lodash.flattenDepth = flattenDepth;\n    lodash.flip = flip;\n    lodash.flow = flow;\n    lodash.flowRight = flowRight;\n    lodash.fromPairs = fromPairs;\n    lodash.functions = functions;\n    lodash.functionsIn = functionsIn;\n    lodash.groupBy = groupBy;\n    lodash.initial = initial;\n    lodash.intersection = intersection;\n    lodash.intersectionBy = intersectionBy;\n    lodash.intersectionWith = intersectionWith;\n    lodash.invert = invert;\n    lodash.invertBy = invertBy;\n    lodash.invokeMap = invokeMap;\n    lodash.iteratee = iteratee;\n    lodash.keyBy = keyBy;\n    lodash.keys = keys;\n    lodash.keysIn = keysIn;\n    lodash.map = map;\n    lodash.mapKeys = mapKeys;\n    lodash.mapValues = mapValues;\n    lodash.matches = matches;\n    lodash.matchesProperty = matchesProperty;\n    lodash.memoize = memoize;\n    lodash.merge = merge;\n    lodash.mergeWith = mergeWith;\n    lodash.method = method;\n    lodash.methodOf = methodOf;\n    lodash.mixin = mixin;\n    lodash.negate = negate;\n    lodash.nthArg = nthArg;\n    lodash.omit = omit;\n    lodash.omitBy = omitBy;\n    lodash.once = once;\n    lodash.orderBy = orderBy;\n    lodash.over = over;\n    lodash.overArgs = overArgs;\n    lodash.overEvery = overEvery;\n    lodash.overSome = overSome;\n    lodash.partial = partial;\n    lodash.partialRight = partialRight;\n    lodash.partition = partition;\n    lodash.pick = pick;\n    lodash.pickBy = pickBy;\n    lodash.property = property;\n    lodash.propertyOf = propertyOf;\n    lodash.pull = pull;\n    lodash.pullAll = pullAll;\n    lodash.pullAllBy = pullAllBy;\n    lodash.pullAllWith = pullAllWith;\n    lodash.pullAt = pullAt;\n    lodash.range = range;\n    lodash.rangeRight = rangeRight;\n    lodash.rearg = rearg;\n    lodash.reject = reject;\n    lodash.remove = remove;\n    lodash.rest = rest;\n    lodash.reverse = reverse;\n    lodash.sampleSize = sampleSize;\n    lodash.set = set;\n    lodash.setWith = setWith;\n    lodash.shuffle = shuffle;\n    lodash.slice = slice;\n    lodash.sortBy = sortBy;\n    lodash.sortedUniq = sortedUniq;\n    lodash.sortedUniqBy = sortedUniqBy;\n    lodash.split = split;\n    lodash.spread = spread;\n    lodash.tail = tail;\n    lodash.take = take;\n    lodash.takeRight = takeRight;\n    lodash.takeRightWhile = takeRightWhile;\n    lodash.takeWhile = takeWhile;\n    lodash.tap = tap;\n    lodash.throttle = throttle;\n    lodash.thru = thru;\n    lodash.toArray = toArray;\n    lodash.toPairs = toPairs;\n    lodash.toPairsIn = toPairsIn;\n    lodash.toPath = toPath;\n    lodash.toPlainObject = toPlainObject;\n    lodash.transform = transform;\n    lodash.unary = unary;\n    lodash.union = union;\n    lodash.unionBy = unionBy;\n    lodash.unionWith = unionWith;\n    lodash.uniq = uniq;\n    lodash.uniqBy = uniqBy;\n    lodash.uniqWith = uniqWith;\n    lodash.unset = unset;\n    lodash.unzip = unzip;\n    lodash.unzipWith = unzipWith;\n    lodash.update = update;\n    lodash.updateWith = updateWith;\n    lodash.values = values;\n    lodash.valuesIn = valuesIn;\n    lodash.without = without;\n    lodash.words = words;\n    lodash.wrap = wrap;\n    lodash.xor = xor;\n    lodash.xorBy = xorBy;\n    lodash.xorWith = xorWith;\n    lodash.zip = zip;\n    lodash.zipObject = zipObject;\n    lodash.zipObjectDeep = zipObjectDeep;\n    lodash.zipWith = zipWith;\n\n    // Add aliases.\n    lodash.entries = toPairs;\n    lodash.entriesIn = toPairsIn;\n    lodash.extend = assignIn;\n    lodash.extendWith = assignInWith;\n\n    // Add methods to `lodash.prototype`.\n    mixin(lodash, lodash);\n\n    /*------------------------------------------------------------------------*/\n\n    // Add methods that return unwrapped values in chain sequences.\n    lodash.add = add;\n    lodash.attempt = attempt;\n    lodash.camelCase = camelCase;\n    lodash.capitalize = capitalize;\n    lodash.ceil = ceil;\n    lodash.clamp = clamp;\n    lodash.clone = clone;\n    lodash.cloneDeep = cloneDeep;\n    lodash.cloneDeepWith = cloneDeepWith;\n    lodash.cloneWith = cloneWith;\n    lodash.conformsTo = conformsTo;\n    lodash.deburr = deburr;\n    lodash.defaultTo = defaultTo;\n    lodash.divide = divide;\n    lodash.endsWith = endsWith;\n    lodash.eq = eq;\n    lodash.escape = escape;\n    lodash.escapeRegExp = escapeRegExp;\n    lodash.every = every;\n    lodash.find = find;\n    lodash.findIndex = findIndex;\n    lodash.findKey = findKey;\n    lodash.findLast = findLast;\n    lodash.findLastIndex = findLastIndex;\n    lodash.findLastKey = findLastKey;\n    lodash.floor = floor;\n    lodash.forEach = forEach;\n    lodash.forEachRight = forEachRight;\n    lodash.forIn = forIn;\n    lodash.forInRight = forInRight;\n    lodash.forOwn = forOwn;\n    lodash.forOwnRight = forOwnRight;\n    lodash.get = get;\n    lodash.gt = gt;\n    lodash.gte = gte;\n    lodash.has = has;\n    lodash.hasIn = hasIn;\n    lodash.head = head;\n    lodash.identity = identity;\n    lodash.includes = includes;\n    lodash.indexOf = indexOf;\n    lodash.inRange = inRange;\n    lodash.invoke = invoke;\n    lodash.isArguments = isArguments;\n    lodash.isArray = isArray;\n    lodash.isArrayBuffer = isArrayBuffer;\n    lodash.isArrayLike = isArrayLike;\n    lodash.isArrayLikeObject = isArrayLikeObject;\n    lodash.isBoolean = isBoolean;\n    lodash.isBuffer = isBuffer;\n    lodash.isDate = isDate;\n    lodash.isElement = isElement;\n    lodash.isEmpty = isEmpty;\n    lodash.isEqual = isEqual;\n    lodash.isEqualWith = isEqualWith;\n    lodash.isError = isError;\n    lodash.isFinite = isFinite;\n    lodash.isFunction = isFunction;\n    lodash.isInteger = isInteger;\n    lodash.isLength = isLength;\n    lodash.isMap = isMap;\n    lodash.isMatch = isMatch;\n    lodash.isMatchWith = isMatchWith;\n    lodash.isNaN = isNaN;\n    lodash.isNative = isNative;\n    lodash.isNil = isNil;\n    lodash.isNull = isNull;\n    lodash.isNumber = isNumber;\n    lodash.isObject = isObject;\n    lodash.isObjectLike = isObjectLike;\n    lodash.isPlainObject = isPlainObject;\n    lodash.isRegExp = isRegExp;\n    lodash.isSafeInteger = isSafeInteger;\n    lodash.isSet = isSet;\n    lodash.isString = isString;\n    lodash.isSymbol = isSymbol;\n    lodash.isTypedArray = isTypedArray;\n    lodash.isUndefined = isUndefined;\n    lodash.isWeakMap = isWeakMap;\n    lodash.isWeakSet = isWeakSet;\n    lodash.join = join;\n    lodash.kebabCase = kebabCase;\n    lodash.last = last;\n    lodash.lastIndexOf = lastIndexOf;\n    lodash.lowerCase = lowerCase;\n    lodash.lowerFirst = lowerFirst;\n    lodash.lt = lt;\n    lodash.lte = lte;\n    lodash.max = max;\n    lodash.maxBy = maxBy;\n    lodash.mean = mean;\n    lodash.meanBy = meanBy;\n    lodash.min = min;\n    lodash.minBy = minBy;\n    lodash.stubArray = stubArray;\n    lodash.stubFalse = stubFalse;\n    lodash.stubObject = stubObject;\n    lodash.stubString = stubString;\n    lodash.stubTrue = stubTrue;\n    lodash.multiply = multiply;\n    lodash.nth = nth;\n    lodash.noConflict = noConflict;\n    lodash.noop = noop;\n    lodash.now = now;\n    lodash.pad = pad;\n    lodash.padEnd = padEnd;\n    lodash.padStart = padStart;\n    lodash.parseInt = parseInt;\n    lodash.random = random;\n    lodash.reduce = reduce;\n    lodash.reduceRight = reduceRight;\n    lodash.repeat = repeat;\n    lodash.replace = replace;\n    lodash.result = result;\n    lodash.round = round;\n    lodash.runInContext = runInContext;\n    lodash.sample = sample;\n    lodash.size = size;\n    lodash.snakeCase = snakeCase;\n    lodash.some = some;\n    lodash.sortedIndex = sortedIndex;\n    lodash.sortedIndexBy = sortedIndexBy;\n    lodash.sortedIndexOf = sortedIndexOf;\n    lodash.sortedLastIndex = sortedLastIndex;\n    lodash.sortedLastIndexBy = sortedLastIndexBy;\n    lodash.sortedLastIndexOf = sortedLastIndexOf;\n    lodash.startCase = startCase;\n    lodash.startsWith = startsWith;\n    lodash.subtract = subtract;\n    lodash.sum = sum;\n    lodash.sumBy = sumBy;\n    lodash.template = template;\n    lodash.times = times;\n    lodash.toFinite = toFinite;\n    lodash.toInteger = toInteger;\n    lodash.toLength = toLength;\n    lodash.toLower = toLower;\n    lodash.toNumber = toNumber;\n    lodash.toSafeInteger = toSafeInteger;\n    lodash.toString = toString;\n    lodash.toUpper = toUpper;\n    lodash.trim = trim;\n    lodash.trimEnd = trimEnd;\n    lodash.trimStart = trimStart;\n    lodash.truncate = truncate;\n    lodash.unescape = unescape;\n    lodash.uniqueId = uniqueId;\n    lodash.upperCase = upperCase;\n    lodash.upperFirst = upperFirst;\n\n    // Add aliases.\n    lodash.each = forEach;\n    lodash.eachRight = forEachRight;\n    lodash.first = head;\n\n    mixin(lodash, (function() {\n      var source = {};\n      baseForOwn(lodash, function(func, methodName) {\n        if (!hasOwnProperty.call(lodash.prototype, methodName)) {\n          source[methodName] = func;\n        }\n      });\n      return source;\n    }()), { 'chain': false });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The semantic version number.\n     *\n     * @static\n     * @memberOf _\n     * @type {string}\n     */\n    lodash.VERSION = VERSION;\n\n    // Assign default placeholders.\n    arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {\n      lodash[methodName].placeholder = lodash;\n    });\n\n    // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.\n    arrayEach(['drop', 'take'], function(methodName, index) {\n      LazyWrapper.prototype[methodName] = function(n) {\n        n = n === undefined ? 1 : nativeMax(toInteger(n), 0);\n\n        var result = (this.__filtered__ && !index)\n          ? new LazyWrapper(this)\n          : this.clone();\n\n        if (result.__filtered__) {\n          result.__takeCount__ = nativeMin(n, result.__takeCount__);\n        } else {\n          result.__views__.push({\n            'size': nativeMin(n, MAX_ARRAY_LENGTH),\n            'type': methodName + (result.__dir__ < 0 ? 'Right' : '')\n          });\n        }\n        return result;\n      };\n\n      LazyWrapper.prototype[methodName + 'Right'] = function(n) {\n        return this.reverse()[methodName](n).reverse();\n      };\n    });\n\n    // Add `LazyWrapper` methods that accept an `iteratee` value.\n    arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {\n      var type = index + 1,\n          isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;\n\n      LazyWrapper.prototype[methodName] = function(iteratee) {\n        var result = this.clone();\n        result.__iteratees__.push({\n          'iteratee': getIteratee(iteratee, 3),\n          'type': type\n        });\n        result.__filtered__ = result.__filtered__ || isFilter;\n        return result;\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.head` and `_.last`.\n    arrayEach(['head', 'last'], function(methodName, index) {\n      var takeName = 'take' + (index ? 'Right' : '');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this[takeName](1).value()[0];\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.initial` and `_.tail`.\n    arrayEach(['initial', 'tail'], function(methodName, index) {\n      var dropName = 'drop' + (index ? '' : 'Right');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);\n      };\n    });\n\n    LazyWrapper.prototype.compact = function() {\n      return this.filter(identity);\n    };\n\n    LazyWrapper.prototype.find = function(predicate) {\n      return this.filter(predicate).head();\n    };\n\n    LazyWrapper.prototype.findLast = function(predicate) {\n      return this.reverse().find(predicate);\n    };\n\n    LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {\n      if (typeof path == 'function') {\n        return new LazyWrapper(this);\n      }\n      return this.map(function(value) {\n        return baseInvoke(value, path, args);\n      });\n    });\n\n    LazyWrapper.prototype.reject = function(predicate) {\n      return this.filter(negate(getIteratee(predicate)));\n    };\n\n    LazyWrapper.prototype.slice = function(start, end) {\n      start = toInteger(start);\n\n      var result = this;\n      if (result.__filtered__ && (start > 0 || end < 0)) {\n        return new LazyWrapper(result);\n      }\n      if (start < 0) {\n        result = result.takeRight(-start);\n      } else if (start) {\n        result = result.drop(start);\n      }\n      if (end !== undefined) {\n        end = toInteger(end);\n        result = end < 0 ? result.dropRight(-end) : result.take(end - start);\n      }\n      return result;\n    };\n\n    LazyWrapper.prototype.takeRightWhile = function(predicate) {\n      return this.reverse().takeWhile(predicate).reverse();\n    };\n\n    LazyWrapper.prototype.toArray = function() {\n      return this.take(MAX_ARRAY_LENGTH);\n    };\n\n    // Add `LazyWrapper` methods to `lodash.prototype`.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),\n          isTaker = /^(?:head|last)$/.test(methodName),\n          lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],\n          retUnwrapped = isTaker || /^find/.test(methodName);\n\n      if (!lodashFunc) {\n        return;\n      }\n      lodash.prototype[methodName] = function() {\n        var value = this.__wrapped__,\n            args = isTaker ? [1] : arguments,\n            isLazy = value instanceof LazyWrapper,\n            iteratee = args[0],\n            useLazy = isLazy || isArray(value);\n\n        var interceptor = function(value) {\n          var result = lodashFunc.apply(lodash, arrayPush([value], args));\n          return (isTaker && chainAll) ? result[0] : result;\n        };\n\n        if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {\n          // Avoid lazy use if the iteratee has a \"length\" value other than `1`.\n          isLazy = useLazy = false;\n        }\n        var chainAll = this.__chain__,\n            isHybrid = !!this.__actions__.length,\n            isUnwrapped = retUnwrapped && !chainAll,\n            onlyLazy = isLazy && !isHybrid;\n\n        if (!retUnwrapped && useLazy) {\n          value = onlyLazy ? value : new LazyWrapper(this);\n          var result = func.apply(value, args);\n          result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });\n          return new LodashWrapper(result, chainAll);\n        }\n        if (isUnwrapped && onlyLazy) {\n          return func.apply(this, args);\n        }\n        result = this.thru(interceptor);\n        return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;\n      };\n    });\n\n    // Add `Array` methods to `lodash.prototype`.\n    arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {\n      var func = arrayProto[methodName],\n          chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',\n          retUnwrapped = /^(?:pop|shift)$/.test(methodName);\n\n      lodash.prototype[methodName] = function() {\n        var args = arguments;\n        if (retUnwrapped && !this.__chain__) {\n          var value = this.value();\n          return func.apply(isArray(value) ? value : [], args);\n        }\n        return this[chainName](function(value) {\n          return func.apply(isArray(value) ? value : [], args);\n        });\n      };\n    });\n\n    // Map minified method names to their real names.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var lodashFunc = lodash[methodName];\n      if (lodashFunc) {\n        var key = (lodashFunc.name + ''),\n            names = realNames[key] || (realNames[key] = []);\n\n        names.push({ 'name': methodName, 'func': lodashFunc });\n      }\n    });\n\n    realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{\n      'name': 'wrapper',\n      'func': undefined\n    }];\n\n    // Add methods to `LazyWrapper`.\n    LazyWrapper.prototype.clone = lazyClone;\n    LazyWrapper.prototype.reverse = lazyReverse;\n    LazyWrapper.prototype.value = lazyValue;\n\n    // Add chain sequence methods to the `lodash` wrapper.\n    lodash.prototype.at = wrapperAt;\n    lodash.prototype.chain = wrapperChain;\n    lodash.prototype.commit = wrapperCommit;\n    lodash.prototype.next = wrapperNext;\n    lodash.prototype.plant = wrapperPlant;\n    lodash.prototype.reverse = wrapperReverse;\n    lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;\n\n    // Add lazy aliases.\n    lodash.prototype.first = lodash.prototype.head;\n\n    if (symIterator) {\n      lodash.prototype[symIterator] = wrapperToIterator;\n    }\n    return lodash;\n  });\n\n  /*--------------------------------------------------------------------------*/\n\n  // Export lodash.\n  var _ = runInContext();\n\n  // Some AMD build optimizers, like r.js, check for condition patterns like:\n  if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {\n    // Expose Lodash on the global object to prevent errors when Lodash is\n    // loaded by a script tag in the presence of an AMD loader.\n    // See http://requirejs.org/docs/errors.html#mismatch for more details.\n    // Use `_.noConflict` to remove Lodash from the global object.\n    root._ = _;\n\n    // Define as an anonymous module so, through path mapping, it can be\n    // referenced as the \"underscore\" module.\n    define(function() {\n      return _;\n    });\n  }\n  // Check for `exports` after `define` in case a build optimizer adds it.\n  else if (freeModule) {\n    // Export for Node.js.\n    (freeModule.exports = _)._ = _;\n    // Export for CommonJS support.\n    freeExports._ = _;\n  }\n  else {\n    // Export to the global object.\n    root._ = _;\n  }\n}.call(this));\n","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nmodule.exports = now;\n","var before = require('./before');\n\n/**\n * Creates a function that is restricted to invoking `func` once. Repeat calls\n * to the function return the value of the first invocation. The `func` is\n * invoked with the `this` binding and arguments of the created function.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new restricted function.\n * @example\n *\n * var initialize = _.once(createApplication);\n * initialize();\n * initialize();\n * // => `createApplication` is invoked once\n */\nfunction once(func) {\n  return before(2, func);\n}\n\nmodule.exports = once;\n","var toNumber = require('./toNumber');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n    MAX_INTEGER = 1.7976931348623157e+308;\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n  if (!value) {\n    return value === 0 ? value : 0;\n  }\n  value = toNumber(value);\n  if (value === INFINITY || value === -INFINITY) {\n    var sign = (value < 0 ? -1 : 1);\n    return sign * MAX_INTEGER;\n  }\n  return value === value ? value : 0;\n}\n\nmodule.exports = toFinite;\n","var toFinite = require('./toFinite');\n\n/**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\nfunction toInteger(value) {\n  var result = toFinite(value),\n      remainder = result % 1;\n\n  return result === result ? (remainder ? result - remainder : result) : 0;\n}\n\nmodule.exports = toInteger;\n","var isObject = require('./isObject'),\n    isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n","/*! picturefill - v3.0.2 - 2016-02-12\n * https://scottjehl.github.io/picturefill/\n * Copyright (c) 2016 https://github.com/scottjehl/picturefill/blob/master/Authors.txt; Licensed MIT\n */\n/*! Gecko-Picture - v1.0\n * https://github.com/scottjehl/picturefill/tree/3.0/src/plugins/gecko-picture\n * Firefox's early picture implementation (prior to FF41) is static and does\n * not react to viewport changes. This tiny module fixes this.\n */\n(function(window) {\n\t/*jshint eqnull:true */\n\tvar ua = navigator.userAgent;\n\n\tif ( window.HTMLPictureElement && ((/ecko/).test(ua) && ua.match(/rv\\:(\\d+)/) && RegExp.$1 < 45) ) {\n\t\taddEventListener(\"resize\", (function() {\n\t\t\tvar timer;\n\n\t\t\tvar dummySrc = document.createElement(\"source\");\n\n\t\t\tvar fixRespimg = function(img) {\n\t\t\t\tvar source, sizes;\n\t\t\t\tvar picture = img.parentNode;\n\n\t\t\t\tif (picture.nodeName.toUpperCase() === \"PICTURE\") {\n\t\t\t\t\tsource = dummySrc.cloneNode();\n\n\t\t\t\t\tpicture.insertBefore(source, picture.firstElementChild);\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\tpicture.removeChild(source);\n\t\t\t\t\t});\n\t\t\t\t} else if (!img._pfLastSize || img.offsetWidth > img._pfLastSize) {\n\t\t\t\t\timg._pfLastSize = img.offsetWidth;\n\t\t\t\t\tsizes = img.sizes;\n\t\t\t\t\timg.sizes += \",100vw\";\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\timg.sizes = sizes;\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tvar findPictureImgs = function() {\n\t\t\t\tvar i;\n\t\t\t\tvar imgs = document.querySelectorAll(\"picture > img, img[srcset][sizes]\");\n\t\t\t\tfor (i = 0; i < imgs.length; i++) {\n\t\t\t\t\tfixRespimg(imgs[i]);\n\t\t\t\t}\n\t\t\t};\n\t\t\tvar onResize = function() {\n\t\t\t\tclearTimeout(timer);\n\t\t\t\ttimer = setTimeout(findPictureImgs, 99);\n\t\t\t};\n\t\t\tvar mq = window.matchMedia && matchMedia(\"(orientation: landscape)\");\n\t\t\tvar init = function() {\n\t\t\t\tonResize();\n\n\t\t\t\tif (mq && mq.addListener) {\n\t\t\t\t\tmq.addListener(onResize);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tdummySrc.srcset = \"data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==\";\n\n\t\t\tif (/^[c|i]|d$/.test(document.readyState || \"\")) {\n\t\t\t\tinit();\n\t\t\t} else {\n\t\t\t\tdocument.addEventListener(\"DOMContentLoaded\", init);\n\t\t\t}\n\n\t\t\treturn onResize;\n\t\t})());\n\t}\n})(window);\n\n/*! Picturefill - v3.0.2\n * http://scottjehl.github.io/picturefill\n * Copyright (c) 2015 https://github.com/scottjehl/picturefill/blob/master/Authors.txt;\n *  License: MIT\n */\n\n(function( window, document, undefined ) {\n\t// Enable strict mode\n\t\"use strict\";\n\n\t// HTML shim|v it for old IE (IE9 will still need the HTML video tag workaround)\n\tdocument.createElement( \"picture\" );\n\n\tvar warn, eminpx, alwaysCheckWDescriptor, evalId;\n\t// local object for method references and testing exposure\n\tvar pf = {};\n\tvar isSupportTestReady = false;\n\tvar noop = function() {};\n\tvar image = document.createElement( \"img\" );\n\tvar getImgAttr = image.getAttribute;\n\tvar setImgAttr = image.setAttribute;\n\tvar removeImgAttr = image.removeAttribute;\n\tvar docElem = document.documentElement;\n\tvar types = {};\n\tvar cfg = {\n\t\t//resource selection:\n\t\talgorithm: \"\"\n\t};\n\tvar srcAttr = \"data-pfsrc\";\n\tvar srcsetAttr = srcAttr + \"set\";\n\t// ua sniffing is done for undetectable img loading features,\n\t// to do some non crucial perf optimizations\n\tvar ua = navigator.userAgent;\n\tvar supportAbort = (/rident/).test(ua) || ((/ecko/).test(ua) && ua.match(/rv\\:(\\d+)/) && RegExp.$1 > 35 );\n\tvar curSrcProp = \"currentSrc\";\n\tvar regWDesc = /\\s+\\+?\\d+(e\\d+)?w/;\n\tvar regSize = /(\\([^)]+\\))?\\s*(.+)/;\n\tvar setOptions = window.picturefillCFG;\n\t/**\n\t * Shortcut property for https://w3c.github.io/webappsec/specs/mixedcontent/#restricts-mixed-content ( for easy overriding in tests )\n\t */\n\t// baseStyle also used by getEmValue (i.e.: width: 1em is important)\n\tvar baseStyle = \"position:absolute;left:0;visibility:hidden;display:block;padding:0;border:none;font-size:1em;width:1em;overflow:hidden;clip:rect(0px, 0px, 0px, 0px)\";\n\tvar fsCss = \"font-size:100%!important;\";\n\tvar isVwDirty = true;\n\n\tvar cssCache = {};\n\tvar sizeLengthCache = {};\n\tvar DPR = window.devicePixelRatio;\n\tvar units = {\n\t\tpx: 1,\n\t\t\"in\": 96\n\t};\n\tvar anchor = document.createElement( \"a\" );\n\t/**\n\t * alreadyRun flag used for setOptions. is it true setOptions will reevaluate\n\t * @type {boolean}\n\t */\n\tvar alreadyRun = false;\n\n\t// Reusable, non-\"g\" Regexes\n\n\t// (Don't use \\s, to avoid matching non-breaking space.)\n\tvar regexLeadingSpaces = /^[ \\t\\n\\r\\u000c]+/,\n\t    regexLeadingCommasOrSpaces = /^[, \\t\\n\\r\\u000c]+/,\n\t    regexLeadingNotSpaces = /^[^ \\t\\n\\r\\u000c]+/,\n\t    regexTrailingCommas = /[,]+$/,\n\t    regexNonNegativeInteger = /^\\d+$/,\n\n\t    // ( Positive or negative or unsigned integers or decimals, without or without exponents.\n\t    // Must include at least one digit.\n\t    // According to spec tests any decimal point must be followed by a digit.\n\t    // No leading plus sign is allowed.)\n\t    // https://html.spec.whatwg.org/multipage/infrastructure.html#valid-floating-point-number\n\t    regexFloatingPoint = /^-?(?:[0-9]+|[0-9]*\\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/;\n\n\tvar on = function(obj, evt, fn, capture) {\n\t\tif ( obj.addEventListener ) {\n\t\t\tobj.addEventListener(evt, fn, capture || false);\n\t\t} else if ( obj.attachEvent ) {\n\t\t\tobj.attachEvent( \"on\" + evt, fn);\n\t\t}\n\t};\n\n\t/**\n\t * simple memoize function:\n\t */\n\n\tvar memoize = function(fn) {\n\t\tvar cache = {};\n\t\treturn function(input) {\n\t\t\tif ( !(input in cache) ) {\n\t\t\t\tcache[ input ] = fn(input);\n\t\t\t}\n\t\t\treturn cache[ input ];\n\t\t};\n\t};\n\n\t// UTILITY FUNCTIONS\n\n\t// Manual is faster than RegEx\n\t// http://jsperf.com/whitespace-character/5\n\tfunction isSpace(c) {\n\t\treturn (c === \"\\u0020\" || // space\n\t\t        c === \"\\u0009\" || // horizontal tab\n\t\t        c === \"\\u000A\" || // new line\n\t\t        c === \"\\u000C\" || // form feed\n\t\t        c === \"\\u000D\");  // carriage return\n\t}\n\n\t/**\n\t * gets a mediaquery and returns a boolean or gets a css length and returns a number\n\t * @param css mediaqueries or css length\n\t * @returns {boolean|number}\n\t *\n\t * based on: https://gist.github.com/jonathantneal/db4f77009b155f083738\n\t */\n\tvar evalCSS = (function() {\n\n\t\tvar regLength = /^([\\d\\.]+)(em|vw|px)$/;\n\t\tvar replace = function() {\n\t\t\tvar args = arguments, index = 0, string = args[0];\n\t\t\twhile (++index in args) {\n\t\t\t\tstring = string.replace(args[index], args[++index]);\n\t\t\t}\n\t\t\treturn string;\n\t\t};\n\n\t\tvar buildStr = memoize(function(css) {\n\n\t\t\treturn \"return \" + replace((css || \"\").toLowerCase(),\n\t\t\t\t// interpret `and`\n\t\t\t\t/\\band\\b/g, \"&&\",\n\n\t\t\t\t// interpret `,`\n\t\t\t\t/,/g, \"||\",\n\n\t\t\t\t// interpret `min-` as >=\n\t\t\t\t/min-([a-z-\\s]+):/g, \"e.$1>=\",\n\n\t\t\t\t// interpret `max-` as <=\n\t\t\t\t/max-([a-z-\\s]+):/g, \"e.$1<=\",\n\n\t\t\t\t//calc value\n\t\t\t\t/calc([^)]+)/g, \"($1)\",\n\n\t\t\t\t// interpret css values\n\t\t\t\t/(\\d+[\\.]*[\\d]*)([a-z]+)/g, \"($1 * e.$2)\",\n\t\t\t\t//make eval less evil\n\t\t\t\t/^(?!(e.[a-z]|[0-9\\.&=|><\\+\\-\\*\\(\\)\\/])).*/ig, \"\"\n\t\t\t) + \";\";\n\t\t});\n\n\t\treturn function(css, length) {\n\t\t\tvar parsedLength;\n\t\t\tif (!(css in cssCache)) {\n\t\t\t\tcssCache[css] = false;\n\t\t\t\tif (length && (parsedLength = css.match( regLength ))) {\n\t\t\t\t\tcssCache[css] = parsedLength[ 1 ] * units[parsedLength[ 2 ]];\n\t\t\t\t} else {\n\t\t\t\t\t/*jshint evil:true */\n\t\t\t\t\ttry{\n\t\t\t\t\t\tcssCache[css] = new Function(\"e\", buildStr(css))(units);\n\t\t\t\t\t} catch(e) {}\n\t\t\t\t\t/*jshint evil:false */\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn cssCache[css];\n\t\t};\n\t})();\n\n\tvar setResolution = function( candidate, sizesattr ) {\n\t\tif ( candidate.w ) { // h = means height: || descriptor.type === 'h' do not handle yet...\n\t\t\tcandidate.cWidth = pf.calcListLength( sizesattr || \"100vw\" );\n\t\t\tcandidate.res = candidate.w / candidate.cWidth ;\n\t\t} else {\n\t\t\tcandidate.res = candidate.d;\n\t\t}\n\t\treturn candidate;\n\t};\n\n\t/**\n\t *\n\t * @param opt\n\t */\n\tvar picturefill = function( opt ) {\n\n\t\tif (!isSupportTestReady) {return;}\n\n\t\tvar elements, i, plen;\n\n\t\tvar options = opt || {};\n\n\t\tif ( options.elements && options.elements.nodeType === 1 ) {\n\t\t\tif ( options.elements.nodeName.toUpperCase() === \"IMG\" ) {\n\t\t\t\toptions.elements =  [ options.elements ];\n\t\t\t} else {\n\t\t\t\toptions.context = options.elements;\n\t\t\t\toptions.elements =  null;\n\t\t\t}\n\t\t}\n\n\t\telements = options.elements || pf.qsa( (options.context || document), ( options.reevaluate || options.reselect ) ? pf.sel : pf.selShort );\n\n\t\tif ( (plen = elements.length) ) {\n\n\t\t\tpf.setupRun( options );\n\t\t\talreadyRun = true;\n\n\t\t\t// Loop through all elements\n\t\t\tfor ( i = 0; i < plen; i++ ) {\n\t\t\t\tpf.fillImg(elements[ i ], options);\n\t\t\t}\n\n\t\t\tpf.teardownRun( options );\n\t\t}\n\t};\n\n\t/**\n\t * outputs a warning for the developer\n\t * @param {message}\n\t * @type {Function}\n\t */\n\twarn = ( window.console && console.warn ) ?\n\t\tfunction( message ) {\n\t\t\tconsole.warn( message );\n\t\t} :\n\t\tnoop\n\t;\n\n\tif ( !(curSrcProp in image) ) {\n\t\tcurSrcProp = \"src\";\n\t}\n\n\t// Add support for standard mime types.\n\ttypes[ \"image/jpeg\" ] = true;\n\ttypes[ \"image/gif\" ] = true;\n\ttypes[ \"image/png\" ] = true;\n\n\tfunction detectTypeSupport( type, typeUri ) {\n\t\t// based on Modernizr's lossless img-webp test\n\t\t// note: asynchronous\n\t\tvar image = new window.Image();\n\t\timage.onerror = function() {\n\t\t\ttypes[ type ] = false;\n\t\t\tpicturefill();\n\t\t};\n\t\timage.onload = function() {\n\t\t\ttypes[ type ] = image.width === 1;\n\t\t\tpicturefill();\n\t\t};\n\t\timage.src = typeUri;\n\t\treturn \"pending\";\n\t}\n\n\t// test svg support\n\ttypes[ \"image/svg+xml\" ] = document.implementation.hasFeature( \"http://www.w3.org/TR/SVG11/feature#Image\", \"1.1\" );\n\n\t/**\n\t * updates the internal vW property with the current viewport width in px\n\t */\n\tfunction updateMetrics() {\n\n\t\tisVwDirty = false;\n\t\tDPR = window.devicePixelRatio;\n\t\tcssCache = {};\n\t\tsizeLengthCache = {};\n\n\t\tpf.DPR = DPR || 1;\n\n\t\tunits.width = Math.max(window.innerWidth || 0, docElem.clientWidth);\n\t\tunits.height = Math.max(window.innerHeight || 0, docElem.clientHeight);\n\n\t\tunits.vw = units.width / 100;\n\t\tunits.vh = units.height / 100;\n\n\t\tevalId = [ units.height, units.width, DPR ].join(\"-\");\n\n\t\tunits.em = pf.getEmValue();\n\t\tunits.rem = units.em;\n\t}\n\n\tfunction chooseLowRes( lowerValue, higherValue, dprValue, isCached ) {\n\t\tvar bonusFactor, tooMuch, bonus, meanDensity;\n\n\t\t//experimental\n\t\tif (cfg.algorithm === \"saveData\" ){\n\t\t\tif ( lowerValue > 2.7 ) {\n\t\t\t\tmeanDensity = dprValue + 1;\n\t\t\t} else {\n\t\t\t\ttooMuch = higherValue - dprValue;\n\t\t\t\tbonusFactor = Math.pow(lowerValue - 0.6, 1.5);\n\n\t\t\t\tbonus = tooMuch * bonusFactor;\n\n\t\t\t\tif (isCached) {\n\t\t\t\t\tbonus += 0.1 * bonusFactor;\n\t\t\t\t}\n\n\t\t\t\tmeanDensity = lowerValue + bonus;\n\t\t\t}\n\t\t} else {\n\t\t\tmeanDensity = (dprValue > 1) ?\n\t\t\t\tMath.sqrt(lowerValue * higherValue) :\n\t\t\t\tlowerValue;\n\t\t}\n\n\t\treturn meanDensity > dprValue;\n\t}\n\n\tfunction applyBestCandidate( img ) {\n\t\tvar srcSetCandidates;\n\t\tvar matchingSet = pf.getSet( img );\n\t\tvar evaluated = false;\n\t\tif ( matchingSet !== \"pending\" ) {\n\t\t\tevaluated = evalId;\n\t\t\tif ( matchingSet ) {\n\t\t\t\tsrcSetCandidates = pf.setRes( matchingSet );\n\t\t\t\tpf.applySetCandidate( srcSetCandidates, img );\n\t\t\t}\n\t\t}\n\t\timg[ pf.ns ].evaled = evaluated;\n\t}\n\n\tfunction ascendingSort( a, b ) {\n\t\treturn a.res - b.res;\n\t}\n\n\tfunction setSrcToCur( img, src, set ) {\n\t\tvar candidate;\n\t\tif ( !set && src ) {\n\t\t\tset = img[ pf.ns ].sets;\n\t\t\tset = set && set[set.length - 1];\n\t\t}\n\n\t\tcandidate = getCandidateForSrc(src, set);\n\n\t\tif ( candidate ) {\n\t\t\tsrc = pf.makeUrl(src);\n\t\t\timg[ pf.ns ].curSrc = src;\n\t\t\timg[ pf.ns ].curCan = candidate;\n\n\t\t\tif ( !candidate.res ) {\n\t\t\t\tsetResolution( candidate, candidate.set.sizes );\n\t\t\t}\n\t\t}\n\t\treturn candidate;\n\t}\n\n\tfunction getCandidateForSrc( src, set ) {\n\t\tvar i, candidate, candidates;\n\t\tif ( src && set ) {\n\t\t\tcandidates = pf.parseSet( set );\n\t\t\tsrc = pf.makeUrl(src);\n\t\t\tfor ( i = 0; i < candidates.length; i++ ) {\n\t\t\t\tif ( src === pf.makeUrl(candidates[ i ].url) ) {\n\t\t\t\t\tcandidate = candidates[ i ];\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn candidate;\n\t}\n\n\tfunction getAllSourceElements( picture, candidates ) {\n\t\tvar i, len, source, srcset;\n\n\t\t// SPEC mismatch intended for size and perf:\n\t\t// actually only source elements preceding the img should be used\n\t\t// also note: don't use qsa here, because IE8 sometimes doesn't like source as the key part in a selector\n\t\tvar sources = picture.getElementsByTagName( \"source\" );\n\n\t\tfor ( i = 0, len = sources.length; i < len; i++ ) {\n\t\t\tsource = sources[ i ];\n\t\t\tsource[ pf.ns ] = true;\n\t\t\tsrcset = source.getAttribute( \"srcset\" );\n\n\t\t\t// if source does not have a srcset attribute, skip\n\t\t\tif ( srcset ) {\n\t\t\t\tcandidates.push( {\n\t\t\t\t\tsrcset: srcset,\n\t\t\t\t\tmedia: source.getAttribute( \"media\" ),\n\t\t\t\t\ttype: source.getAttribute( \"type\" ),\n\t\t\t\t\tsizes: source.getAttribute( \"sizes\" )\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Srcset Parser\n\t * By Alex Bell |  MIT License\n\t *\n\t * @returns Array [{url: _, d: _, w: _, h:_, set:_(????)}, ...]\n\t *\n\t * Based super duper closely on the reference algorithm at:\n\t * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-srcset-attribute\n\t */\n\n\t// 1. Let input be the value passed to this algorithm.\n\t// (TO-DO : Explain what \"set\" argument is here. Maybe choose a more\n\t// descriptive & more searchable name.  Since passing the \"set\" in really has\n\t// nothing to do with parsing proper, I would prefer this assignment eventually\n\t// go in an external fn.)\n\tfunction parseSrcset(input, set) {\n\n\t\tfunction collectCharacters(regEx) {\n\t\t\tvar chars,\n\t\t\t    match = regEx.exec(input.substring(pos));\n\t\t\tif (match) {\n\t\t\t\tchars = match[ 0 ];\n\t\t\t\tpos += chars.length;\n\t\t\t\treturn chars;\n\t\t\t}\n\t\t}\n\n\t\tvar inputLength = input.length,\n\t\t    url,\n\t\t    descriptors,\n\t\t    currentDescriptor,\n\t\t    state,\n\t\t    c,\n\n\t\t    // 2. Let position be a pointer into input, initially pointing at the start\n\t\t    //    of the string.\n\t\t    pos = 0,\n\n\t\t    // 3. Let candidates be an initially empty source set.\n\t\t    candidates = [];\n\n\t\t/**\n\t\t* Adds descriptor properties to a candidate, pushes to the candidates array\n\t\t* @return undefined\n\t\t*/\n\t\t// (Declared outside of the while loop so that it's only created once.\n\t\t// (This fn is defined before it is used, in order to pass JSHINT.\n\t\t// Unfortunately this breaks the sequencing of the spec comments. :/ )\n\t\tfunction parseDescriptors() {\n\n\t\t\t// 9. Descriptor parser: Let error be no.\n\t\t\tvar pError = false,\n\n\t\t\t// 10. Let width be absent.\n\t\t\t// 11. Let density be absent.\n\t\t\t// 12. Let future-compat-h be absent. (We're implementing it now as h)\n\t\t\t    w, d, h, i,\n\t\t\t    candidate = {},\n\t\t\t    desc, lastChar, value, intVal, floatVal;\n\n\t\t\t// 13. For each descriptor in descriptors, run the appropriate set of steps\n\t\t\t// from the following list:\n\t\t\tfor (i = 0 ; i < descriptors.length; i++) {\n\t\t\t\tdesc = descriptors[ i ];\n\n\t\t\t\tlastChar = desc[ desc.length - 1 ];\n\t\t\t\tvalue = desc.substring(0, desc.length - 1);\n\t\t\t\tintVal = parseInt(value, 10);\n\t\t\t\tfloatVal = parseFloat(value);\n\n\t\t\t\t// If the descriptor consists of a valid non-negative integer followed by\n\t\t\t\t// a U+0077 LATIN SMALL LETTER W character\n\t\t\t\tif (regexNonNegativeInteger.test(value) && (lastChar === \"w\")) {\n\n\t\t\t\t\t// If width and density are not both absent, then let error be yes.\n\t\t\t\t\tif (w || d) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing non-negative integers to the descriptor.\n\t\t\t\t\t// If the result is zero, let error be yes.\n\t\t\t\t\t// Otherwise, let width be the result.\n\t\t\t\t\tif (intVal === 0) {pError = true;} else {w = intVal;}\n\n\t\t\t\t// If the descriptor consists of a valid floating-point number followed by\n\t\t\t\t// a U+0078 LATIN SMALL LETTER X character\n\t\t\t\t} else if (regexFloatingPoint.test(value) && (lastChar === \"x\")) {\n\n\t\t\t\t\t// If width, density and future-compat-h are not all absent, then let error\n\t\t\t\t\t// be yes.\n\t\t\t\t\tif (w || d || h) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing floating-point number values to the descriptor.\n\t\t\t\t\t// If the result is less than zero, let error be yes. Otherwise, let density\n\t\t\t\t\t// be the result.\n\t\t\t\t\tif (floatVal < 0) {pError = true;} else {d = floatVal;}\n\n\t\t\t\t// If the descriptor consists of a valid non-negative integer followed by\n\t\t\t\t// a U+0068 LATIN SMALL LETTER H character\n\t\t\t\t} else if (regexNonNegativeInteger.test(value) && (lastChar === \"h\")) {\n\n\t\t\t\t\t// If height and density are not both absent, then let error be yes.\n\t\t\t\t\tif (h || d) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing non-negative integers to the descriptor.\n\t\t\t\t\t// If the result is zero, let error be yes. Otherwise, let future-compat-h\n\t\t\t\t\t// be the result.\n\t\t\t\t\tif (intVal === 0) {pError = true;} else {h = intVal;}\n\n\t\t\t\t// Anything else, Let error be yes.\n\t\t\t\t} else {pError = true;}\n\t\t\t} // (close step 13 for loop)\n\n\t\t\t// 15. If error is still no, then append a new image source to candidates whose\n\t\t\t// URL is url, associated with a width width if not absent and a pixel\n\t\t\t// density density if not absent. Otherwise, there is a parse error.\n\t\t\tif (!pError) {\n\t\t\t\tcandidate.url = url;\n\n\t\t\t\tif (w) { candidate.w = w;}\n\t\t\t\tif (d) { candidate.d = d;}\n\t\t\t\tif (h) { candidate.h = h;}\n\t\t\t\tif (!h && !d && !w) {candidate.d = 1;}\n\t\t\t\tif (candidate.d === 1) {set.has1x = true;}\n\t\t\t\tcandidate.set = set;\n\n\t\t\t\tcandidates.push(candidate);\n\t\t\t}\n\t\t} // (close parseDescriptors fn)\n\n\t\t/**\n\t\t* Tokenizes descriptor properties prior to parsing\n\t\t* Returns undefined.\n\t\t* (Again, this fn is defined before it is used, in order to pass JSHINT.\n\t\t* Unfortunately this breaks the logical sequencing of the spec comments. :/ )\n\t\t*/\n\t\tfunction tokenize() {\n\n\t\t\t// 8.1. Descriptor tokeniser: Skip whitespace\n\t\t\tcollectCharacters(regexLeadingSpaces);\n\n\t\t\t// 8.2. Let current descriptor be the empty string.\n\t\t\tcurrentDescriptor = \"\";\n\n\t\t\t// 8.3. Let state be in descriptor.\n\t\t\tstate = \"in descriptor\";\n\n\t\t\twhile (true) {\n\n\t\t\t\t// 8.4. Let c be the character at position.\n\t\t\t\tc = input.charAt(pos);\n\n\t\t\t\t//  Do the following depending on the value of state.\n\t\t\t\t//  For the purpose of this step, \"EOF\" is a special character representing\n\t\t\t\t//  that position is past the end of input.\n\n\t\t\t\t// In descriptor\n\t\t\t\tif (state === \"in descriptor\") {\n\t\t\t\t\t// Do the following, depending on the value of c:\n\n\t\t\t\t  // Space character\n\t\t\t\t  // If current descriptor is not empty, append current descriptor to\n\t\t\t\t  // descriptors and let current descriptor be the empty string.\n\t\t\t\t  // Set state to after descriptor.\n\t\t\t\t\tif (isSpace(c)) {\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t\tcurrentDescriptor = \"\";\n\t\t\t\t\t\t\tstate = \"after descriptor\";\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// U+002C COMMA (,)\n\t\t\t\t\t// Advance position to the next character in input. If current descriptor\n\t\t\t\t\t// is not empty, append current descriptor to descriptors. Jump to the step\n\t\t\t\t\t// labeled descriptor parser.\n\t\t\t\t\t} else if (c === \",\") {\n\t\t\t\t\t\tpos += 1;\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// U+0028 LEFT PARENTHESIS (()\n\t\t\t\t\t// Append c to current descriptor. Set state to in parens.\n\t\t\t\t\t} else if (c === \"\\u0028\") {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t\tstate = \"in parens\";\n\n\t\t\t\t\t// EOF\n\t\t\t\t\t// If current descriptor is not empty, append current descriptor to\n\t\t\t\t\t// descriptors. Jump to the step labeled descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Append c to current descriptor.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t}\n\t\t\t\t// (end \"in descriptor\"\n\n\t\t\t\t// In parens\n\t\t\t\t} else if (state === \"in parens\") {\n\n\t\t\t\t\t// U+0029 RIGHT PARENTHESIS ())\n\t\t\t\t\t// Append c to current descriptor. Set state to in descriptor.\n\t\t\t\t\tif (c === \")\") {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t\tstate = \"in descriptor\";\n\n\t\t\t\t\t// EOF\n\t\t\t\t\t// Append current descriptor to descriptors. Jump to the step labeled\n\t\t\t\t\t// descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Append c to current descriptor.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t}\n\n\t\t\t\t// After descriptor\n\t\t\t\t} else if (state === \"after descriptor\") {\n\n\t\t\t\t\t// Do the following, depending on the value of c:\n\t\t\t\t\t// Space character: Stay in this state.\n\t\t\t\t\tif (isSpace(c)) {\n\n\t\t\t\t\t// EOF: Jump to the step labeled descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Set state to in descriptor. Set position to the previous character in input.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tstate = \"in descriptor\";\n\t\t\t\t\t\tpos -= 1;\n\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Advance position to the next character in input.\n\t\t\t\tpos += 1;\n\n\t\t\t// Repeat this step.\n\t\t\t} // (close while true loop)\n\t\t}\n\n\t\t// 4. Splitting loop: Collect a sequence of characters that are space\n\t\t//    characters or U+002C COMMA characters. If any U+002C COMMA characters\n\t\t//    were collected, that is a parse error.\n\t\twhile (true) {\n\t\t\tcollectCharacters(regexLeadingCommasOrSpaces);\n\n\t\t\t// 5. If position is past the end of input, return candidates and abort these steps.\n\t\t\tif (pos >= inputLength) {\n\t\t\t\treturn candidates; // (we're done, this is the sole return path)\n\t\t\t}\n\n\t\t\t// 6. Collect a sequence of characters that are not space characters,\n\t\t\t//    and let that be url.\n\t\t\turl = collectCharacters(regexLeadingNotSpaces);\n\n\t\t\t// 7. Let descriptors be a new empty list.\n\t\t\tdescriptors = [];\n\n\t\t\t// 8. If url ends with a U+002C COMMA character (,), follow these substeps:\n\t\t\t//\t\t(1). Remove all trailing U+002C COMMA characters from url. If this removed\n\t\t\t//         more than one character, that is a parse error.\n\t\t\tif (url.slice(-1) === \",\") {\n\t\t\t\turl = url.replace(regexTrailingCommas, \"\");\n\t\t\t\t// (Jump ahead to step 9 to skip tokenization and just push the candidate).\n\t\t\t\tparseDescriptors();\n\n\t\t\t//\tOtherwise, follow these substeps:\n\t\t\t} else {\n\t\t\t\ttokenize();\n\t\t\t} // (close else of step 8)\n\n\t\t// 16. Return to the step labeled splitting loop.\n\t\t} // (Close of big while loop.)\n\t}\n\n\t/*\n\t * Sizes Parser\n\t *\n\t * By Alex Bell |  MIT License\n\t *\n\t * Non-strict but accurate and lightweight JS Parser for the string value <img sizes=\"here\">\n\t *\n\t * Reference algorithm at:\n\t * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-sizes-attribute\n\t *\n\t * Most comments are copied in directly from the spec\n\t * (except for comments in parens).\n\t *\n\t * Grammar is:\n\t * <source-size-list> = <source-size># [ , <source-size-value> ]? | <source-size-value>\n\t * <source-size> = <media-condition> <source-size-value>\n\t * <source-size-value> = <length>\n\t * http://www.w3.org/html/wg/drafts/html/master/embedded-content.html#attr-img-sizes\n\t *\n\t * E.g. \"(max-width: 30em) 100vw, (max-width: 50em) 70vw, 100vw\"\n\t * or \"(min-width: 30em), calc(30vw - 15px)\" or just \"30vw\"\n\t *\n\t * Returns the first valid <css-length> with a media condition that evaluates to true,\n\t * or \"100vw\" if all valid media conditions evaluate to false.\n\t *\n\t */\n\n\tfunction parseSizes(strValue) {\n\n\t\t// (Percentage CSS lengths are not allowed in this case, to avoid confusion:\n\t\t// https://html.spec.whatwg.org/multipage/embedded-content.html#valid-source-size-list\n\t\t// CSS allows a single optional plus or minus sign:\n\t\t// http://www.w3.org/TR/CSS2/syndata.html#numbers\n\t\t// CSS is ASCII case-insensitive:\n\t\t// http://www.w3.org/TR/CSS2/syndata.html#characters )\n\t\t// Spec allows exponential notation for <number> type:\n\t\t// http://dev.w3.org/csswg/css-values/#numbers\n\t\tvar regexCssLengthWithUnits = /^(?:[+-]?[0-9]+|[0-9]*\\.[0-9]+)(?:[eE][+-]?[0-9]+)?(?:ch|cm|em|ex|in|mm|pc|pt|px|rem|vh|vmin|vmax|vw)$/i;\n\n\t\t// (This is a quick and lenient test. Because of optional unlimited-depth internal\n\t\t// grouping parens and strict spacing rules, this could get very complicated.)\n\t\tvar regexCssCalc = /^calc\\((?:[0-9a-z \\.\\+\\-\\*\\/\\(\\)]+)\\)$/i;\n\n\t\tvar i;\n\t\tvar unparsedSizesList;\n\t\tvar unparsedSizesListLength;\n\t\tvar unparsedSize;\n\t\tvar lastComponentValue;\n\t\tvar size;\n\n\t\t// UTILITY FUNCTIONS\n\n\t\t//  (Toy CSS parser. The goals here are:\n\t\t//  1) expansive test coverage without the weight of a full CSS parser.\n\t\t//  2) Avoiding regex wherever convenient.\n\t\t//  Quick tests: http://jsfiddle.net/gtntL4gr/3/\n\t\t//  Returns an array of arrays.)\n\t\tfunction parseComponentValues(str) {\n\t\t\tvar chrctr;\n\t\t\tvar component = \"\";\n\t\t\tvar componentArray = [];\n\t\t\tvar listArray = [];\n\t\t\tvar parenDepth = 0;\n\t\t\tvar pos = 0;\n\t\t\tvar inComment = false;\n\n\t\t\tfunction pushComponent() {\n\t\t\t\tif (component) {\n\t\t\t\t\tcomponentArray.push(component);\n\t\t\t\t\tcomponent = \"\";\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfunction pushComponentArray() {\n\t\t\t\tif (componentArray[0]) {\n\t\t\t\t\tlistArray.push(componentArray);\n\t\t\t\t\tcomponentArray = [];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// (Loop forwards from the beginning of the string.)\n\t\t\twhile (true) {\n\t\t\t\tchrctr = str.charAt(pos);\n\n\t\t\t\tif (chrctr === \"\") { // ( End of string reached.)\n\t\t\t\t\tpushComponent();\n\t\t\t\t\tpushComponentArray();\n\t\t\t\t\treturn listArray;\n\t\t\t\t} else if (inComment) {\n\t\t\t\t\tif ((chrctr === \"*\") && (str[pos + 1] === \"/\")) { // (At end of a comment.)\n\t\t\t\t\t\tinComment = false;\n\t\t\t\t\t\tpos += 2;\n\t\t\t\t\t\tpushComponent();\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tpos += 1; // (Skip all characters inside comments.)\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t} else if (isSpace(chrctr)) {\n\t\t\t\t\t// (If previous character in loop was also a space, or if\n\t\t\t\t\t// at the beginning of the string, do not add space char to\n\t\t\t\t\t// component.)\n\t\t\t\t\tif ( (str.charAt(pos - 1) && isSpace( str.charAt(pos - 1) ) ) || !component ) {\n\t\t\t\t\t\tpos += 1;\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else if (parenDepth === 0) {\n\t\t\t\t\t\tpushComponent();\n\t\t\t\t\t\tpos +=1;\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// (Replace any space character with a plain space for legibility.)\n\t\t\t\t\t\tchrctr = \" \";\n\t\t\t\t\t}\n\t\t\t\t} else if (chrctr === \"(\") {\n\t\t\t\t\tparenDepth += 1;\n\t\t\t\t} else if (chrctr === \")\") {\n\t\t\t\t\tparenDepth -= 1;\n\t\t\t\t} else if (chrctr === \",\") {\n\t\t\t\t\tpushComponent();\n\t\t\t\t\tpushComponentArray();\n\t\t\t\t\tpos += 1;\n\t\t\t\t\tcontinue;\n\t\t\t\t} else if ( (chrctr === \"/\") && (str.charAt(pos + 1) === \"*\") ) {\n\t\t\t\t\tinComment = true;\n\t\t\t\t\tpos += 2;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tcomponent = component + chrctr;\n\t\t\t\tpos += 1;\n\t\t\t}\n\t\t}\n\n\t\tfunction isValidNonNegativeSourceSizeValue(s) {\n\t\t\tif (regexCssLengthWithUnits.test(s) && (parseFloat(s) >= 0)) {return true;}\n\t\t\tif (regexCssCalc.test(s)) {return true;}\n\t\t\t// ( http://www.w3.org/TR/CSS2/syndata.html#numbers says:\n\t\t\t// \"-0 is equivalent to 0 and is not a negative number.\" which means that\n\t\t\t// unitless zero and unitless negative zero must be accepted as special cases.)\n\t\t\tif ((s === \"0\") || (s === \"-0\") || (s === \"+0\")) {return true;}\n\t\t\treturn false;\n\t\t}\n\n\t\t// When asked to parse a sizes attribute from an element, parse a\n\t\t// comma-separated list of component values from the value of the element's\n\t\t// sizes attribute (or the empty string, if the attribute is absent), and let\n\t\t// unparsed sizes list be the result.\n\t\t// http://dev.w3.org/csswg/css-syntax/#parse-comma-separated-list-of-component-values\n\n\t\tunparsedSizesList = parseComponentValues(strValue);\n\t\tunparsedSizesListLength = unparsedSizesList.length;\n\n\t\t// For each unparsed size in unparsed sizes list:\n\t\tfor (i = 0; i < unparsedSizesListLength; i++) {\n\t\t\tunparsedSize = unparsedSizesList[i];\n\n\t\t\t// 1. Remove all consecutive <whitespace-token>s from the end of unparsed size.\n\t\t\t// ( parseComponentValues() already omits spaces outside of parens. )\n\n\t\t\t// If unparsed size is now empty, that is a parse error; continue to the next\n\t\t\t// iteration of this algorithm.\n\t\t\t// ( parseComponentValues() won't push an empty array. )\n\n\t\t\t// 2. If the last component value in unparsed size is a valid non-negative\n\t\t\t// <source-size-value>, let size be its value and remove the component value\n\t\t\t// from unparsed size. Any CSS function other than the calc() function is\n\t\t\t// invalid. Otherwise, there is a parse error; continue to the next iteration\n\t\t\t// of this algorithm.\n\t\t\t// http://dev.w3.org/csswg/css-syntax/#parse-component-value\n\t\t\tlastComponentValue = unparsedSize[unparsedSize.length - 1];\n\n\t\t\tif (isValidNonNegativeSourceSizeValue(lastComponentValue)) {\n\t\t\t\tsize = lastComponentValue;\n\t\t\t\tunparsedSize.pop();\n\t\t\t} else {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// 3. Remove all consecutive <whitespace-token>s from the end of unparsed\n\t\t\t// size. If unparsed size is now empty, return size and exit this algorithm.\n\t\t\t// If this was not the last item in unparsed sizes list, that is a parse error.\n\t\t\tif (unparsedSize.length === 0) {\n\t\t\t\treturn size;\n\t\t\t}\n\n\t\t\t// 4. Parse the remaining component values in unparsed size as a\n\t\t\t// <media-condition>. If it does not parse correctly, or it does parse\n\t\t\t// correctly but the <media-condition> evaluates to false, continue to the\n\t\t\t// next iteration of this algorithm.\n\t\t\t// (Parsing all possible compound media conditions in JS is heavy, complicated,\n\t\t\t// and the payoff is unclear. Is there ever an situation where the\n\t\t\t// media condition parses incorrectly but still somehow evaluates to true?\n\t\t\t// Can we just rely on the browser/polyfill to do it?)\n\t\t\tunparsedSize = unparsedSize.join(\" \");\n\t\t\tif (!(pf.matchesMedia( unparsedSize ) ) ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// 5. Return size and exit this algorithm.\n\t\t\treturn size;\n\t\t}\n\n\t\t// If the above algorithm exhausts unparsed sizes list without returning a\n\t\t// size value, return 100vw.\n\t\treturn \"100vw\";\n\t}\n\n\t// namespace\n\tpf.ns = (\"pf\" + new Date().getTime()).substr(0, 9);\n\n\t// srcset support test\n\tpf.supSrcset = \"srcset\" in image;\n\tpf.supSizes = \"sizes\" in image;\n\tpf.supPicture = !!window.HTMLPictureElement;\n\n\t// UC browser does claim to support srcset and picture, but not sizes,\n\t// this extended test reveals the browser does support nothing\n\tif (pf.supSrcset && pf.supPicture && !pf.supSizes) {\n\t\t(function(image2) {\n\t\t\timage.srcset = \"data:,a\";\n\t\t\timage2.src = \"data:,a\";\n\t\t\tpf.supSrcset = image.complete === image2.complete;\n\t\t\tpf.supPicture = pf.supSrcset && pf.supPicture;\n\t\t})(document.createElement(\"img\"));\n\t}\n\n\t// Safari9 has basic support for sizes, but does't expose the `sizes` idl attribute\n\tif (pf.supSrcset && !pf.supSizes) {\n\n\t\t(function() {\n\t\t\tvar width2 = \"data:image/gif;base64,R0lGODlhAgABAPAAAP///wAAACH5BAAAAAAALAAAAAACAAEAAAICBAoAOw==\";\n\t\t\tvar width1 = \"data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==\";\n\t\t\tvar img = document.createElement(\"img\");\n\t\t\tvar test = function() {\n\t\t\t\tvar width = img.width;\n\n\t\t\t\tif (width === 2) {\n\t\t\t\t\tpf.supSizes = true;\n\t\t\t\t}\n\n\t\t\t\talwaysCheckWDescriptor = pf.supSrcset && !pf.supSizes;\n\n\t\t\t\tisSupportTestReady = true;\n\t\t\t\t// force async\n\t\t\t\tsetTimeout(picturefill);\n\t\t\t};\n\n\t\t\timg.onload = test;\n\t\t\timg.onerror = test;\n\t\t\timg.setAttribute(\"sizes\", \"9px\");\n\n\t\t\timg.srcset = width1 + \" 1w,\" + width2 + \" 9w\";\n\t\t\timg.src = width1;\n\t\t})();\n\n\t} else {\n\t\tisSupportTestReady = true;\n\t}\n\n\t// using pf.qsa instead of dom traversing does scale much better,\n\t// especially on sites mixing responsive and non-responsive images\n\tpf.selShort = \"picture>img,img[srcset]\";\n\tpf.sel = pf.selShort;\n\tpf.cfg = cfg;\n\n\t/**\n\t * Shortcut property for `devicePixelRatio` ( for easy overriding in tests )\n\t */\n\tpf.DPR = (DPR  || 1 );\n\tpf.u = units;\n\n\t// container of supported mime types that one might need to qualify before using\n\tpf.types =  types;\n\n\tpf.setSize = noop;\n\n\t/**\n\t * Gets a string and returns the absolute URL\n\t * @param src\n\t * @returns {String} absolute URL\n\t */\n\n\tpf.makeUrl = memoize(function(src) {\n\t\tanchor.href = src;\n\t\treturn anchor.href;\n\t});\n\n\t/**\n\t * Gets a DOM element or document and a selctor and returns the found matches\n\t * Can be extended with jQuery/Sizzle for IE7 support\n\t * @param context\n\t * @param sel\n\t * @returns {NodeList|Array}\n\t */\n\tpf.qsa = function(context, sel) {\n\t\treturn ( \"querySelector\" in context ) ? context.querySelectorAll(sel) : [];\n\t};\n\n\t/**\n\t * Shortcut method for matchMedia ( for easy overriding in tests )\n\t * wether native or pf.mMQ is used will be decided lazy on first call\n\t * @returns {boolean}\n\t */\n\tpf.matchesMedia = function() {\n\t\tif ( window.matchMedia && (matchMedia( \"(min-width: 0.1em)\" ) || {}).matches ) {\n\t\t\tpf.matchesMedia = function( media ) {\n\t\t\t\treturn !media || ( matchMedia( media ).matches );\n\t\t\t};\n\t\t} else {\n\t\t\tpf.matchesMedia = pf.mMQ;\n\t\t}\n\n\t\treturn pf.matchesMedia.apply( this, arguments );\n\t};\n\n\t/**\n\t * A simplified matchMedia implementation for IE8 and IE9\n\t * handles only min-width/max-width with px or em values\n\t * @param media\n\t * @returns {boolean}\n\t */\n\tpf.mMQ = function( media ) {\n\t\treturn media ? evalCSS(media) : true;\n\t};\n\n\t/**\n\t * Returns the calculated length in css pixel from the given sourceSizeValue\n\t * http://dev.w3.org/csswg/css-values-3/#length-value\n\t * intended Spec mismatches:\n\t * * Does not check for invalid use of CSS functions\n\t * * Does handle a computed length of 0 the same as a negative and therefore invalid value\n\t * @param sourceSizeValue\n\t * @returns {Number}\n\t */\n\tpf.calcLength = function( sourceSizeValue ) {\n\n\t\tvar value = evalCSS(sourceSizeValue, true) || false;\n\t\tif (value < 0) {\n\t\t\tvalue = false;\n\t\t}\n\n\t\treturn value;\n\t};\n\n\t/**\n\t * Takes a type string and checks if its supported\n\t */\n\n\tpf.supportsType = function( type ) {\n\t\treturn ( type ) ? types[ type ] : true;\n\t};\n\n\t/**\n\t * Parses a sourceSize into mediaCondition (media) and sourceSizeValue (length)\n\t * @param sourceSizeStr\n\t * @returns {*}\n\t */\n\tpf.parseSize = memoize(function( sourceSizeStr ) {\n\t\tvar match = ( sourceSizeStr || \"\" ).match(regSize);\n\t\treturn {\n\t\t\tmedia: match && match[1],\n\t\t\tlength: match && match[2]\n\t\t};\n\t});\n\n\tpf.parseSet = function( set ) {\n\t\tif ( !set.cands ) {\n\t\t\tset.cands = parseSrcset(set.srcset, set);\n\t\t}\n\t\treturn set.cands;\n\t};\n\n\t/**\n\t * returns 1em in css px for html/body default size\n\t * function taken from respondjs\n\t * @returns {*|number}\n\t */\n\tpf.getEmValue = function() {\n\t\tvar body;\n\t\tif ( !eminpx && (body = document.body) ) {\n\t\t\tvar div = document.createElement( \"div\" ),\n\t\t\t\toriginalHTMLCSS = docElem.style.cssText,\n\t\t\t\toriginalBodyCSS = body.style.cssText;\n\n\t\t\tdiv.style.cssText = baseStyle;\n\n\t\t\t// 1em in a media query is the value of the default font size of the browser\n\t\t\t// reset docElem and body to ensure the correct value is returned\n\t\t\tdocElem.style.cssText = fsCss;\n\t\t\tbody.style.cssText = fsCss;\n\n\t\t\tbody.appendChild( div );\n\t\t\teminpx = div.offsetWidth;\n\t\t\tbody.removeChild( div );\n\n\t\t\t//also update eminpx before returning\n\t\t\teminpx = parseFloat( eminpx, 10 );\n\n\t\t\t// restore the original values\n\t\t\tdocElem.style.cssText = originalHTMLCSS;\n\t\t\tbody.style.cssText = originalBodyCSS;\n\n\t\t}\n\t\treturn eminpx || 16;\n\t};\n\n\t/**\n\t * Takes a string of sizes and returns the width in pixels as a number\n\t */\n\tpf.calcListLength = function( sourceSizeListStr ) {\n\t\t// Split up source size list, ie ( max-width: 30em ) 100%, ( max-width: 50em ) 50%, 33%\n\t\t//\n\t\t//                           or (min-width:30em) calc(30% - 15px)\n\t\tif ( !(sourceSizeListStr in sizeLengthCache) || cfg.uT ) {\n\t\t\tvar winningLength = pf.calcLength( parseSizes( sourceSizeListStr ) );\n\n\t\t\tsizeLengthCache[ sourceSizeListStr ] = !winningLength ? units.width : winningLength;\n\t\t}\n\n\t\treturn sizeLengthCache[ sourceSizeListStr ];\n\t};\n\n\t/**\n\t * Takes a candidate object with a srcset property in the form of url/\n\t * ex. \"images/pic-medium.png 1x, images/pic-medium-2x.png 2x\" or\n\t *     \"images/pic-medium.png 400w, images/pic-medium-2x.png 800w\" or\n\t *     \"images/pic-small.png\"\n\t * Get an array of image candidates in the form of\n\t *      {url: \"/foo/bar.png\", resolution: 1}\n\t * where resolution is http://dev.w3.org/csswg/css-values-3/#resolution-value\n\t * If sizes is specified, res is calculated\n\t */\n\tpf.setRes = function( set ) {\n\t\tvar candidates;\n\t\tif ( set ) {\n\n\t\t\tcandidates = pf.parseSet( set );\n\n\t\t\tfor ( var i = 0, len = candidates.length; i < len; i++ ) {\n\t\t\t\tsetResolution( candidates[ i ], set.sizes );\n\t\t\t}\n\t\t}\n\t\treturn candidates;\n\t};\n\n\tpf.setRes.res = setResolution;\n\n\tpf.applySetCandidate = function( candidates, img ) {\n\t\tif ( !candidates.length ) {return;}\n\t\tvar candidate,\n\t\t\ti,\n\t\t\tj,\n\t\t\tlength,\n\t\t\tbestCandidate,\n\t\t\tcurSrc,\n\t\t\tcurCan,\n\t\t\tcandidateSrc,\n\t\t\tabortCurSrc;\n\n\t\tvar imageData = img[ pf.ns ];\n\t\tvar dpr = pf.DPR;\n\n\t\tcurSrc = imageData.curSrc || img[curSrcProp];\n\n\t\tcurCan = imageData.curCan || setSrcToCur(img, curSrc, candidates[0].set);\n\n\t\t// if we have a current source, we might either become lazy or give this source some advantage\n\t\tif ( curCan && curCan.set === candidates[ 0 ].set ) {\n\n\t\t\t// if browser can abort image request and the image has a higher pixel density than needed\n\t\t\t// and this image isn't downloaded yet, we skip next part and try to save bandwidth\n\t\t\tabortCurSrc = (supportAbort && !img.complete && curCan.res - 0.1 > dpr);\n\n\t\t\tif ( !abortCurSrc ) {\n\t\t\t\tcurCan.cached = true;\n\n\t\t\t\t// if current candidate is \"best\", \"better\" or \"okay\",\n\t\t\t\t// set it to bestCandidate\n\t\t\t\tif ( curCan.res >= dpr ) {\n\t\t\t\t\tbestCandidate = curCan;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( !bestCandidate ) {\n\n\t\t\tcandidates.sort( ascendingSort );\n\n\t\t\tlength = candidates.length;\n\t\t\tbestCandidate = candidates[ length - 1 ];\n\n\t\t\tfor ( i = 0; i < length; i++ ) {\n\t\t\t\tcandidate = candidates[ i ];\n\t\t\t\tif ( candidate.res >= dpr ) {\n\t\t\t\t\tj = i - 1;\n\n\t\t\t\t\t// we have found the perfect candidate,\n\t\t\t\t\t// but let's improve this a little bit with some assumptions ;-)\n\t\t\t\t\tif (candidates[ j ] &&\n\t\t\t\t\t\t(abortCurSrc || curSrc !== pf.makeUrl( candidate.url )) &&\n\t\t\t\t\t\tchooseLowRes(candidates[ j ].res, candidate.res, dpr, candidates[ j ].cached)) {\n\n\t\t\t\t\t\tbestCandidate = candidates[ j ];\n\n\t\t\t\t\t} else {\n\t\t\t\t\t\tbestCandidate = candidate;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( bestCandidate ) {\n\n\t\t\tcandidateSrc = pf.makeUrl( bestCandidate.url );\n\n\t\t\timageData.curSrc = candidateSrc;\n\t\t\timageData.curCan = bestCandidate;\n\n\t\t\tif ( candidateSrc !== curSrc ) {\n\t\t\t\tpf.setSrc( img, bestCandidate );\n\t\t\t}\n\t\t\tpf.setSize( img );\n\t\t}\n\t};\n\n\tpf.setSrc = function( img, bestCandidate ) {\n\t\tvar origWidth;\n\t\timg.src = bestCandidate.url;\n\n\t\t// although this is a specific Safari issue, we don't want to take too much different code paths\n\t\tif ( bestCandidate.set.type === \"image/svg+xml\" ) {\n\t\t\torigWidth = img.style.width;\n\t\t\timg.style.width = (img.offsetWidth + 1) + \"px\";\n\n\t\t\t// next line only should trigger a repaint\n\t\t\t// if... is only done to trick dead code removal\n\t\t\tif ( img.offsetWidth + 1 ) {\n\t\t\t\timg.style.width = origWidth;\n\t\t\t}\n\t\t}\n\t};\n\n\tpf.getSet = function( img ) {\n\t\tvar i, set, supportsType;\n\t\tvar match = false;\n\t\tvar sets = img [ pf.ns ].sets;\n\n\t\tfor ( i = 0; i < sets.length && !match; i++ ) {\n\t\t\tset = sets[i];\n\n\t\t\tif ( !set.srcset || !pf.matchesMedia( set.media ) || !(supportsType = pf.supportsType( set.type )) ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif ( supportsType === \"pending\" ) {\n\t\t\t\tset = supportsType;\n\t\t\t}\n\n\t\t\tmatch = set;\n\t\t\tbreak;\n\t\t}\n\n\t\treturn match;\n\t};\n\n\tpf.parseSets = function( element, parent, options ) {\n\t\tvar srcsetAttribute, imageSet, isWDescripor, srcsetParsed;\n\n\t\tvar hasPicture = parent && parent.nodeName.toUpperCase() === \"PICTURE\";\n\t\tvar imageData = element[ pf.ns ];\n\n\t\tif ( imageData.src === undefined || options.src ) {\n\t\t\timageData.src = getImgAttr.call( element, \"src\" );\n\t\t\tif ( imageData.src ) {\n\t\t\t\tsetImgAttr.call( element, srcAttr, imageData.src );\n\t\t\t} else {\n\t\t\t\tremoveImgAttr.call( element, srcAttr );\n\t\t\t}\n\t\t}\n\n\t\tif ( imageData.srcset === undefined || options.srcset || !pf.supSrcset || element.srcset ) {\n\t\t\tsrcsetAttribute = getImgAttr.call( element, \"srcset\" );\n\t\t\timageData.srcset = srcsetAttribute;\n\t\t\tsrcsetParsed = true;\n\t\t}\n\n\t\timageData.sets = [];\n\n\t\tif ( hasPicture ) {\n\t\t\timageData.pic = true;\n\t\t\tgetAllSourceElements( parent, imageData.sets );\n\t\t}\n\n\t\tif ( imageData.srcset ) {\n\t\t\timageSet = {\n\t\t\t\tsrcset: imageData.srcset,\n\t\t\t\tsizes: getImgAttr.call( element, \"sizes\" )\n\t\t\t};\n\n\t\t\timageData.sets.push( imageSet );\n\n\t\t\tisWDescripor = (alwaysCheckWDescriptor || imageData.src) && regWDesc.test(imageData.srcset || \"\");\n\n\t\t\t// add normal src as candidate, if source has no w descriptor\n\t\t\tif ( !isWDescripor && imageData.src && !getCandidateForSrc(imageData.src, imageSet) && !imageSet.has1x ) {\n\t\t\t\timageSet.srcset += \", \" + imageData.src;\n\t\t\t\timageSet.cands.push({\n\t\t\t\t\turl: imageData.src,\n\t\t\t\t\td: 1,\n\t\t\t\t\tset: imageSet\n\t\t\t\t});\n\t\t\t}\n\n\t\t} else if ( imageData.src ) {\n\t\t\timageData.sets.push( {\n\t\t\t\tsrcset: imageData.src,\n\t\t\t\tsizes: null\n\t\t\t} );\n\t\t}\n\n\t\timageData.curCan = null;\n\t\timageData.curSrc = undefined;\n\n\t\t// if img has picture or the srcset was removed or has a srcset and does not support srcset at all\n\t\t// or has a w descriptor (and does not support sizes) set support to false to evaluate\n\t\timageData.supported = !( hasPicture || ( imageSet && !pf.supSrcset ) || (isWDescripor && !pf.supSizes) );\n\n\t\tif ( srcsetParsed && pf.supSrcset && !imageData.supported ) {\n\t\t\tif ( srcsetAttribute ) {\n\t\t\t\tsetImgAttr.call( element, srcsetAttr, srcsetAttribute );\n\t\t\t\telement.srcset = \"\";\n\t\t\t} else {\n\t\t\t\tremoveImgAttr.call( element, srcsetAttr );\n\t\t\t}\n\t\t}\n\n\t\tif (imageData.supported && !imageData.srcset && ((!imageData.src && element.src) ||  element.src !== pf.makeUrl(imageData.src))) {\n\t\t\tif (imageData.src === null) {\n\t\t\t\telement.removeAttribute(\"src\");\n\t\t\t} else {\n\t\t\t\telement.src = imageData.src;\n\t\t\t}\n\t\t}\n\n\t\timageData.parsed = true;\n\t};\n\n\tpf.fillImg = function(element, options) {\n\t\tvar imageData;\n\t\tvar extreme = options.reselect || options.reevaluate;\n\n\t\t// expando for caching data on the img\n\t\tif ( !element[ pf.ns ] ) {\n\t\t\telement[ pf.ns ] = {};\n\t\t}\n\n\t\timageData = element[ pf.ns ];\n\n\t\t// if the element has already been evaluated, skip it\n\t\t// unless `options.reevaluate` is set to true ( this, for example,\n\t\t// is set to true when running `picturefill` on `resize` ).\n\t\tif ( !extreme && imageData.evaled === evalId ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( !imageData.parsed || options.reevaluate ) {\n\t\t\tpf.parseSets( element, element.parentNode, options );\n\t\t}\n\n\t\tif ( !imageData.supported ) {\n\t\t\tapplyBestCandidate( element );\n\t\t} else {\n\t\t\timageData.evaled = evalId;\n\t\t}\n\t};\n\n\tpf.setupRun = function() {\n\t\tif ( !alreadyRun || isVwDirty || (DPR !== window.devicePixelRatio) ) {\n\t\t\tupdateMetrics();\n\t\t}\n\t};\n\n\t// If picture is supported, well, that's awesome.\n\tif ( pf.supPicture ) {\n\t\tpicturefill = noop;\n\t\tpf.fillImg = noop;\n\t} else {\n\n\t\t // Set up picture polyfill by polling the document\n\t\t(function() {\n\t\t\tvar isDomReady;\n\t\t\tvar regReady = window.attachEvent ? /d$|^c/ : /d$|^c|^i/;\n\n\t\t\tvar run = function() {\n\t\t\t\tvar readyState = document.readyState || \"\";\n\n\t\t\t\ttimerId = setTimeout(run, readyState === \"loading\" ? 200 :  999);\n\t\t\t\tif ( document.body ) {\n\t\t\t\t\tpf.fillImgs();\n\t\t\t\t\tisDomReady = isDomReady || regReady.test(readyState);\n\t\t\t\t\tif ( isDomReady ) {\n\t\t\t\t\t\tclearTimeout( timerId );\n\t\t\t\t\t}\n\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tvar timerId = setTimeout(run, document.body ? 9 : 99);\n\n\t\t\t// Also attach picturefill on resize and readystatechange\n\t\t\t// http://modernjavascript.blogspot.com/2013/08/building-better-debounce.html\n\t\t\tvar debounce = function(func, wait) {\n\t\t\t\tvar timeout, timestamp;\n\t\t\t\tvar later = function() {\n\t\t\t\t\tvar last = (new Date()) - timestamp;\n\n\t\t\t\t\tif (last < wait) {\n\t\t\t\t\t\ttimeout = setTimeout(later, wait - last);\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttimeout = null;\n\t\t\t\t\t\tfunc();\n\t\t\t\t\t}\n\t\t\t\t};\n\n\t\t\t\treturn function() {\n\t\t\t\t\ttimestamp = new Date();\n\n\t\t\t\t\tif (!timeout) {\n\t\t\t\t\t\ttimeout = setTimeout(later, wait);\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\t\t\tvar lastClientWidth = docElem.clientHeight;\n\t\t\tvar onResize = function() {\n\t\t\t\tisVwDirty = Math.max(window.innerWidth || 0, docElem.clientWidth) !== units.width || docElem.clientHeight !== lastClientWidth;\n\t\t\t\tlastClientWidth = docElem.clientHeight;\n\t\t\t\tif ( isVwDirty ) {\n\t\t\t\t\tpf.fillImgs();\n\t\t\t\t}\n\t\t\t};\n\n\t\t\ton( window, \"resize\", debounce(onResize, 99 ) );\n\t\t\ton( document, \"readystatechange\", run );\n\t\t})();\n\t}\n\n\tpf.picturefill = picturefill;\n\t//use this internally for easy monkey patching/performance testing\n\tpf.fillImgs = picturefill;\n\tpf.teardownRun = noop;\n\n\t/* expose methods for testing */\n\tpicturefill._ = pf;\n\n\twindow.picturefillCFG = {\n\t\tpf: pf,\n\t\tpush: function(args) {\n\t\t\tvar name = args.shift();\n\t\t\tif (typeof pf[name] === \"function\") {\n\t\t\t\tpf[name].apply(pf, args);\n\t\t\t} else {\n\t\t\t\tcfg[name] = args[0];\n\t\t\t\tif (alreadyRun) {\n\t\t\t\t\tpf.fillImgs( { reselect: true } );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\twhile (setOptions && setOptions.length) {\n\t\twindow.picturefillCFG.push(setOptions.shift());\n\t}\n\n\t/* expose picturefill */\n\twindow.picturefill = picturefill;\n\n\t/* expose picturefill */\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\t\t// CommonJS, just export\n\t\tmodule.exports = picturefill;\n\t} else if ( typeof define === \"function\" && define.amd ) {\n\t\t// AMD support\n\t\tdefine( \"picturefill\", function() { return picturefill; } );\n\t}\n\n\t// IE8 evals this sync, so it must be the last thing we do\n\tif ( !pf.supPicture ) {\n\t\ttypes[ \"image/webp\" ] = detectTypeSupport(\"image/webp\", \"data:image/webp;base64,UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAABBxAR/Q9ERP8DAABWUDggGAAAADABAJ0BKgEAAQADADQlpAADcAD++/1QAA==\" );\n\t}\n\n} )( window, document );\n","/*\n     _ _      _       _\n ___| (_) ___| | __  (_)___\n/ __| | |/ __| |/ /  | / __|\n\\__ \\ | | (__|   < _ | \\__ \\\n|___/_|_|\\___|_|\\_(_)/ |___/\n                   |__/\n\n Version: 1.8.1\n  Author: Ken Wheeler\n Website: http://kenwheeler.github.io\n    Docs: http://kenwheeler.github.io/slick\n    Repo: http://github.com/kenwheeler/slick\n  Issues: http://github.com/kenwheeler/slick/issues\n\n */\n/* global window, document, define, jQuery, setInterval, clearInterval */\n;(function(factory) {\n    'use strict';\n    if (typeof define === 'function' && define.amd) {\n        define(['jquery'], factory);\n    } else if (typeof exports !== 'undefined') {\n        module.exports = factory(require('jquery'));\n    } else {\n        factory(jQuery);\n    }\n\n}(function($) {\n    'use strict';\n    var Slick = window.Slick || {};\n\n    Slick = (function() {\n\n        var instanceUid = 0;\n\n        function Slick(element, settings) {\n\n            var _ = this, dataSettings;\n\n            _.defaults = {\n                accessibility: true,\n                adaptiveHeight: false,\n                appendArrows: $(element),\n                appendDots: $(element),\n                arrows: true,\n                asNavFor: null,\n                prevArrow: '<button class=\"slick-prev\" aria-label=\"Previous\" type=\"button\">Previous</button>',\n                nextArrow: '<button class=\"slick-next\" aria-label=\"Next\" type=\"button\">Next</button>',\n                autoplay: false,\n                autoplaySpeed: 3000,\n                centerMode: false,\n                centerPadding: '50px',\n                cssEase: 'ease',\n                customPaging: function(slider, i) {\n                    return $('<button type=\"button\" />').text(i + 1);\n                },\n                dots: false,\n                dotsClass: 'slick-dots',\n                draggable: true,\n                easing: 'linear',\n                edgeFriction: 0.35,\n                fade: false,\n                focusOnSelect: false,\n                focusOnChange: false,\n                infinite: true,\n                initialSlide: 0,\n                lazyLoad: 'ondemand',\n                mobileFirst: false,\n                pauseOnHover: true,\n                pauseOnFocus: true,\n                pauseOnDotsHover: false,\n                respondTo: 'window',\n                responsive: null,\n                rows: 1,\n                rtl: false,\n                slide: '',\n                slidesPerRow: 1,\n                slidesToShow: 1,\n                slidesToScroll: 1,\n                speed: 500,\n                swipe: true,\n                swipeToSlide: false,\n                touchMove: true,\n                touchThreshold: 5,\n                useCSS: true,\n                useTransform: true,\n                variableWidth: false,\n                vertical: false,\n                verticalSwiping: false,\n                waitForAnimate: true,\n                zIndex: 1000\n            };\n\n            _.initials = {\n                animating: false,\n                dragging: false,\n                autoPlayTimer: null,\n                currentDirection: 0,\n                currentLeft: null,\n                currentSlide: 0,\n                direction: 1,\n                $dots: null,\n                listWidth: null,\n                listHeight: null,\n                loadIndex: 0,\n                $nextArrow: null,\n                $prevArrow: null,\n                scrolling: false,\n                slideCount: null,\n                slideWidth: null,\n                $slideTrack: null,\n                $slides: null,\n                sliding: false,\n                slideOffset: 0,\n                swipeLeft: null,\n                swiping: false,\n                $list: null,\n                touchObject: {},\n                transformsEnabled: false,\n                unslicked: false\n            };\n\n            $.extend(_, _.initials);\n\n            _.activeBreakpoint = null;\n            _.animType = null;\n            _.animProp = null;\n            _.breakpoints = [];\n            _.breakpointSettings = [];\n            _.cssTransitions = false;\n            _.focussed = false;\n            _.interrupted = false;\n            _.hidden = 'hidden';\n            _.paused = true;\n            _.positionProp = null;\n            _.respondTo = null;\n            _.rowCount = 1;\n            _.shouldClick = true;\n            _.$slider = $(element);\n            _.$slidesCache = null;\n            _.transformType = null;\n            _.transitionType = null;\n            _.visibilityChange = 'visibilitychange';\n            _.windowWidth = 0;\n            _.windowTimer = null;\n\n            dataSettings = $(element).data('slick') || {};\n\n            _.options = $.extend({}, _.defaults, settings, dataSettings);\n\n            _.currentSlide = _.options.initialSlide;\n\n            _.originalSettings = _.options;\n\n            if (typeof document.mozHidden !== 'undefined') {\n                _.hidden = 'mozHidden';\n                _.visibilityChange = 'mozvisibilitychange';\n            } else if (typeof document.webkitHidden !== 'undefined') {\n                _.hidden = 'webkitHidden';\n                _.visibilityChange = 'webkitvisibilitychange';\n            }\n\n            _.autoPlay = $.proxy(_.autoPlay, _);\n            _.autoPlayClear = $.proxy(_.autoPlayClear, _);\n            _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);\n            _.changeSlide = $.proxy(_.changeSlide, _);\n            _.clickHandler = $.proxy(_.clickHandler, _);\n            _.selectHandler = $.proxy(_.selectHandler, _);\n            _.setPosition = $.proxy(_.setPosition, _);\n            _.swipeHandler = $.proxy(_.swipeHandler, _);\n            _.dragHandler = $.proxy(_.dragHandler, _);\n            _.keyHandler = $.proxy(_.keyHandler, _);\n\n            _.instanceUid = instanceUid++;\n\n            // A simple way to check for HTML strings\n            // Strict HTML recognition (must start with <)\n            // Extracted from jQuery v1.11 source\n            _.htmlExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*)$/;\n\n\n            _.registerBreakpoints();\n            _.init(true);\n\n        }\n\n        return Slick;\n\n    }());\n\n    Slick.prototype.activateADA = function() {\n        var _ = this;\n\n        _.$slideTrack.find('.slick-active').attr({\n            'aria-hidden': 'false'\n        }).find('a, input, button, select').attr({\n            'tabindex': '0'\n        });\n\n    };\n\n    Slick.prototype.addSlide = Slick.prototype.slickAdd = function(markup, index, addBefore) {\n\n        var _ = this;\n\n        if (typeof(index) === 'boolean') {\n            addBefore = index;\n            index = null;\n        } else if (index < 0 || (index >= _.slideCount)) {\n            return false;\n        }\n\n        _.unload();\n\n        if (typeof(index) === 'number') {\n            if (index === 0 && _.$slides.length === 0) {\n                $(markup).appendTo(_.$slideTrack);\n            } else if (addBefore) {\n                $(markup).insertBefore(_.$slides.eq(index));\n            } else {\n                $(markup).insertAfter(_.$slides.eq(index));\n            }\n        } else {\n            if (addBefore === true) {\n                $(markup).prependTo(_.$slideTrack);\n            } else {\n                $(markup).appendTo(_.$slideTrack);\n            }\n        }\n\n        _.$slides = _.$slideTrack.children(this.options.slide);\n\n        _.$slideTrack.children(this.options.slide).detach();\n\n        _.$slideTrack.append(_.$slides);\n\n        _.$slides.each(function(index, element) {\n            $(element).attr('data-slick-index', index);\n        });\n\n        _.$slidesCache = _.$slides;\n\n        _.reinit();\n\n    };\n\n    Slick.prototype.animateHeight = function() {\n        var _ = this;\n        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {\n            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);\n            _.$list.animate({\n                height: targetHeight\n            }, _.options.speed);\n        }\n    };\n\n    Slick.prototype.animateSlide = function(targetLeft, callback) {\n\n        var animProps = {},\n            _ = this;\n\n        _.animateHeight();\n\n        if (_.options.rtl === true && _.options.vertical === false) {\n            targetLeft = -targetLeft;\n        }\n        if (_.transformsEnabled === false) {\n            if (_.options.vertical === false) {\n                _.$slideTrack.animate({\n                    left: targetLeft\n                }, _.options.speed, _.options.easing, callback);\n            } else {\n                _.$slideTrack.animate({\n                    top: targetLeft\n                }, _.options.speed, _.options.easing, callback);\n            }\n\n        } else {\n\n            if (_.cssTransitions === false) {\n                if (_.options.rtl === true) {\n                    _.currentLeft = -(_.currentLeft);\n                }\n                $({\n                    animStart: _.currentLeft\n                }).animate({\n                    animStart: targetLeft\n                }, {\n                    duration: _.options.speed,\n                    easing: _.options.easing,\n                    step: function(now) {\n                        now = Math.ceil(now);\n                        if (_.options.vertical === false) {\n                            animProps[_.animType] = 'translate(' +\n                                now + 'px, 0px)';\n                            _.$slideTrack.css(animProps);\n                        } else {\n                            animProps[_.animType] = 'translate(0px,' +\n                                now + 'px)';\n                            _.$slideTrack.css(animProps);\n                        }\n                    },\n                    complete: function() {\n                        if (callback) {\n                            callback.call();\n                        }\n                    }\n                });\n\n            } else {\n\n                _.applyTransition();\n                targetLeft = Math.ceil(targetLeft);\n\n                if (_.options.vertical === false) {\n                    animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';\n                } else {\n                    animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';\n                }\n                _.$slideTrack.css(animProps);\n\n                if (callback) {\n                    setTimeout(function() {\n\n                        _.disableTransition();\n\n                        callback.call();\n                    }, _.options.speed);\n                }\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.getNavTarget = function() {\n\n        var _ = this,\n            asNavFor = _.options.asNavFor;\n\n        if ( asNavFor && asNavFor !== null ) {\n            asNavFor = $(asNavFor).not(_.$slider);\n        }\n\n        return asNavFor;\n\n    };\n\n    Slick.prototype.asNavFor = function(index) {\n\n        var _ = this,\n            asNavFor = _.getNavTarget();\n\n        if ( asNavFor !== null && typeof asNavFor === 'object' ) {\n            asNavFor.each(function() {\n                var target = $(this).slick('getSlick');\n                if(!target.unslicked) {\n                    target.slideHandler(index, true);\n                }\n            });\n        }\n\n    };\n\n    Slick.prototype.applyTransition = function(slide) {\n\n        var _ = this,\n            transition = {};\n\n        if (_.options.fade === false) {\n            transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;\n        } else {\n            transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;\n        }\n\n        if (_.options.fade === false) {\n            _.$slideTrack.css(transition);\n        } else {\n            _.$slides.eq(slide).css(transition);\n        }\n\n    };\n\n    Slick.prototype.autoPlay = function() {\n\n        var _ = this;\n\n        _.autoPlayClear();\n\n        if ( _.slideCount > _.options.slidesToShow ) {\n            _.autoPlayTimer = setInterval( _.autoPlayIterator, _.options.autoplaySpeed );\n        }\n\n    };\n\n    Slick.prototype.autoPlayClear = function() {\n\n        var _ = this;\n\n        if (_.autoPlayTimer) {\n            clearInterval(_.autoPlayTimer);\n        }\n\n    };\n\n    Slick.prototype.autoPlayIterator = function() {\n\n        var _ = this,\n            slideTo = _.currentSlide + _.options.slidesToScroll;\n\n        if ( !_.paused && !_.interrupted && !_.focussed ) {\n\n            if ( _.options.infinite === false ) {\n\n                if ( _.direction === 1 && ( _.currentSlide + 1 ) === ( _.slideCount - 1 )) {\n                    _.direction = 0;\n                }\n\n                else if ( _.direction === 0 ) {\n\n                    slideTo = _.currentSlide - _.options.slidesToScroll;\n\n                    if ( _.currentSlide - 1 === 0 ) {\n                        _.direction = 1;\n                    }\n\n                }\n\n            }\n\n            _.slideHandler( slideTo );\n\n        }\n\n    };\n\n    Slick.prototype.buildArrows = function() {\n\n        var _ = this;\n\n        if (_.options.arrows === true ) {\n\n            _.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow');\n            _.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow');\n\n            if( _.slideCount > _.options.slidesToShow ) {\n\n                _.$prevArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');\n                _.$nextArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');\n\n                if (_.htmlExpr.test(_.options.prevArrow)) {\n                    _.$prevArrow.prependTo(_.options.appendArrows);\n                }\n\n                if (_.htmlExpr.test(_.options.nextArrow)) {\n                    _.$nextArrow.appendTo(_.options.appendArrows);\n                }\n\n                if (_.options.infinite !== true) {\n                    _.$prevArrow\n                        .addClass('slick-disabled')\n                        .attr('aria-disabled', 'true');\n                }\n\n            } else {\n\n                _.$prevArrow.add( _.$nextArrow )\n\n                    .addClass('slick-hidden')\n                    .attr({\n                        'aria-disabled': 'true',\n                        'tabindex': '-1'\n                    });\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.buildDots = function() {\n\n        var _ = this,\n            i, dot;\n\n        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$slider.addClass('slick-dotted');\n\n            dot = $('<ul />').addClass(_.options.dotsClass);\n\n            for (i = 0; i <= _.getDotCount(); i += 1) {\n                dot.append($('<li />').append(_.options.customPaging.call(this, _, i)));\n            }\n\n            _.$dots = dot.appendTo(_.options.appendDots);\n\n            _.$dots.find('li').first().addClass('slick-active');\n\n        }\n\n    };\n\n    Slick.prototype.buildOut = function() {\n\n        var _ = this;\n\n        _.$slides =\n            _.$slider\n                .children( _.options.slide + ':not(.slick-cloned)')\n                .addClass('slick-slide');\n\n        _.slideCount = _.$slides.length;\n\n        _.$slides.each(function(index, element) {\n            $(element)\n                .attr('data-slick-index', index)\n                .data('originalStyling', $(element).attr('style') || '');\n        });\n\n        _.$slider.addClass('slick-slider');\n\n        _.$slideTrack = (_.slideCount === 0) ?\n            $('<div class=\"slick-track\"/>').appendTo(_.$slider) :\n            _.$slides.wrapAll('<div class=\"slick-track\"/>').parent();\n\n        _.$list = _.$slideTrack.wrap(\n            '<div class=\"slick-list\"/>').parent();\n        _.$slideTrack.css('opacity', 0);\n\n        if (_.options.centerMode === true || _.options.swipeToSlide === true) {\n            _.options.slidesToScroll = 1;\n        }\n\n        $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');\n\n        _.setupInfinite();\n\n        _.buildArrows();\n\n        _.buildDots();\n\n        _.updateDots();\n\n\n        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);\n\n        if (_.options.draggable === true) {\n            _.$list.addClass('draggable');\n        }\n\n    };\n\n    Slick.prototype.buildRows = function() {\n\n        var _ = this, a, b, c, newSlides, numOfSlides, originalSlides,slidesPerSection;\n\n        newSlides = document.createDocumentFragment();\n        originalSlides = _.$slider.children();\n\n        if(_.options.rows > 0) {\n\n            slidesPerSection = _.options.slidesPerRow * _.options.rows;\n            numOfSlides = Math.ceil(\n                originalSlides.length / slidesPerSection\n            );\n\n            for(a = 0; a < numOfSlides; a++){\n                var slide = document.createElement('div');\n                for(b = 0; b < _.options.rows; b++) {\n                    var row = document.createElement('div');\n                    for(c = 0; c < _.options.slidesPerRow; c++) {\n                        var target = (a * slidesPerSection + ((b * _.options.slidesPerRow) + c));\n                        if (originalSlides.get(target)) {\n                            row.appendChild(originalSlides.get(target));\n                        }\n                    }\n                    slide.appendChild(row);\n                }\n                newSlides.appendChild(slide);\n            }\n\n            _.$slider.empty().append(newSlides);\n            _.$slider.children().children().children()\n                .css({\n                    'width':(100 / _.options.slidesPerRow) + '%',\n                    'display': 'inline-block'\n                });\n\n        }\n\n    };\n\n    Slick.prototype.checkResponsive = function(initial, forceUpdate) {\n\n        var _ = this,\n            breakpoint, targetBreakpoint, respondToWidth, triggerBreakpoint = false;\n        var sliderWidth = _.$slider.width();\n        var windowWidth = window.innerWidth || $(window).width();\n\n        if (_.respondTo === 'window') {\n            respondToWidth = windowWidth;\n        } else if (_.respondTo === 'slider') {\n            respondToWidth = sliderWidth;\n        } else if (_.respondTo === 'min') {\n            respondToWidth = Math.min(windowWidth, sliderWidth);\n        }\n\n        if ( _.options.responsive &&\n            _.options.responsive.length &&\n            _.options.responsive !== null) {\n\n            targetBreakpoint = null;\n\n            for (breakpoint in _.breakpoints) {\n                if (_.breakpoints.hasOwnProperty(breakpoint)) {\n                    if (_.originalSettings.mobileFirst === false) {\n                        if (respondToWidth < _.breakpoints[breakpoint]) {\n                            targetBreakpoint = _.breakpoints[breakpoint];\n                        }\n                    } else {\n                        if (respondToWidth > _.breakpoints[breakpoint]) {\n                            targetBreakpoint = _.breakpoints[breakpoint];\n                        }\n                    }\n                }\n            }\n\n            if (targetBreakpoint !== null) {\n                if (_.activeBreakpoint !== null) {\n                    if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {\n                        _.activeBreakpoint =\n                            targetBreakpoint;\n                        if (_.breakpointSettings[targetBreakpoint] === 'unslick') {\n                            _.unslick(targetBreakpoint);\n                        } else {\n                            _.options = $.extend({}, _.originalSettings,\n                                _.breakpointSettings[\n                                    targetBreakpoint]);\n                            if (initial === true) {\n                                _.currentSlide = _.options.initialSlide;\n                            }\n                            _.refresh(initial);\n                        }\n                        triggerBreakpoint = targetBreakpoint;\n                    }\n                } else {\n                    _.activeBreakpoint = targetBreakpoint;\n                    if (_.breakpointSettings[targetBreakpoint] === 'unslick') {\n                        _.unslick(targetBreakpoint);\n                    } else {\n                        _.options = $.extend({}, _.originalSettings,\n                            _.breakpointSettings[\n                                targetBreakpoint]);\n                        if (initial === true) {\n                            _.currentSlide = _.options.initialSlide;\n                        }\n                        _.refresh(initial);\n                    }\n                    triggerBreakpoint = targetBreakpoint;\n                }\n            } else {\n                if (_.activeBreakpoint !== null) {\n                    _.activeBreakpoint = null;\n                    _.options = _.originalSettings;\n                    if (initial === true) {\n                        _.currentSlide = _.options.initialSlide;\n                    }\n                    _.refresh(initial);\n                    triggerBreakpoint = targetBreakpoint;\n                }\n            }\n\n            // only trigger breakpoints during an actual break. not on initialize.\n            if( !initial && triggerBreakpoint !== false ) {\n                _.$slider.trigger('breakpoint', [_, triggerBreakpoint]);\n            }\n        }\n\n    };\n\n    Slick.prototype.changeSlide = function(event, dontAnimate) {\n\n        var _ = this,\n            $target = $(event.currentTarget),\n            indexOffset, slideOffset, unevenOffset;\n\n        // If target is a link, prevent default action.\n        if($target.is('a')) {\n            event.preventDefault();\n        }\n\n        // If target is not the <li> element (ie: a child), find the <li>.\n        if(!$target.is('li')) {\n            $target = $target.closest('li');\n        }\n\n        unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);\n        indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;\n\n        switch (event.data.message) {\n\n            case 'previous':\n                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;\n                if (_.slideCount > _.options.slidesToShow) {\n                    _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);\n                }\n                break;\n\n            case 'next':\n                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;\n                if (_.slideCount > _.options.slidesToShow) {\n                    _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);\n                }\n                break;\n\n            case 'index':\n                var index = event.data.index === 0 ? 0 :\n                    event.data.index || $target.index() * _.options.slidesToScroll;\n\n                _.slideHandler(_.checkNavigable(index), false, dontAnimate);\n                $target.children().trigger('focus');\n                break;\n\n            default:\n                return;\n        }\n\n    };\n\n    Slick.prototype.checkNavigable = function(index) {\n\n        var _ = this,\n            navigables, prevNavigable;\n\n        navigables = _.getNavigableIndexes();\n        prevNavigable = 0;\n        if (index > navigables[navigables.length - 1]) {\n            index = navigables[navigables.length - 1];\n        } else {\n            for (var n in navigables) {\n                if (index < navigables[n]) {\n                    index = prevNavigable;\n                    break;\n                }\n                prevNavigable = navigables[n];\n            }\n        }\n\n        return index;\n    };\n\n    Slick.prototype.cleanUpEvents = function() {\n\n        var _ = this;\n\n        if (_.options.dots && _.$dots !== null) {\n\n            $('li', _.$dots)\n                .off('click.slick', _.changeSlide)\n                .off('mouseenter.slick', $.proxy(_.interrupt, _, true))\n                .off('mouseleave.slick', $.proxy(_.interrupt, _, false));\n\n            if (_.options.accessibility === true) {\n                _.$dots.off('keydown.slick', _.keyHandler);\n            }\n        }\n\n        _.$slider.off('focus.slick blur.slick');\n\n        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {\n            _.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide);\n            _.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide);\n\n            if (_.options.accessibility === true) {\n                _.$prevArrow && _.$prevArrow.off('keydown.slick', _.keyHandler);\n                _.$nextArrow && _.$nextArrow.off('keydown.slick', _.keyHandler);\n            }\n        }\n\n        _.$list.off('touchstart.slick mousedown.slick', _.swipeHandler);\n        _.$list.off('touchmove.slick mousemove.slick', _.swipeHandler);\n        _.$list.off('touchend.slick mouseup.slick', _.swipeHandler);\n        _.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler);\n\n        _.$list.off('click.slick', _.clickHandler);\n\n        $(document).off(_.visibilityChange, _.visibility);\n\n        _.cleanUpSlideEvents();\n\n        if (_.options.accessibility === true) {\n            _.$list.off('keydown.slick', _.keyHandler);\n        }\n\n        if (_.options.focusOnSelect === true) {\n            $(_.$slideTrack).children().off('click.slick', _.selectHandler);\n        }\n\n        $(window).off('orientationchange.slick.slick-' + _.instanceUid, _.orientationChange);\n\n        $(window).off('resize.slick.slick-' + _.instanceUid, _.resize);\n\n        $('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault);\n\n        $(window).off('load.slick.slick-' + _.instanceUid, _.setPosition);\n\n    };\n\n    Slick.prototype.cleanUpSlideEvents = function() {\n\n        var _ = this;\n\n        _.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true));\n        _.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false));\n\n    };\n\n    Slick.prototype.cleanUpRows = function() {\n\n        var _ = this, originalSlides;\n\n        if(_.options.rows > 0) {\n            originalSlides = _.$slides.children().children();\n            originalSlides.removeAttr('style');\n            _.$slider.empty().append(originalSlides);\n        }\n\n    };\n\n    Slick.prototype.clickHandler = function(event) {\n\n        var _ = this;\n\n        if (_.shouldClick === false) {\n            event.stopImmediatePropagation();\n            event.stopPropagation();\n            event.preventDefault();\n        }\n\n    };\n\n    Slick.prototype.destroy = function(refresh) {\n\n        var _ = this;\n\n        _.autoPlayClear();\n\n        _.touchObject = {};\n\n        _.cleanUpEvents();\n\n        $('.slick-cloned', _.$slider).detach();\n\n        if (_.$dots) {\n            _.$dots.remove();\n        }\n\n        if ( _.$prevArrow && _.$prevArrow.length ) {\n\n            _.$prevArrow\n                .removeClass('slick-disabled slick-arrow slick-hidden')\n                .removeAttr('aria-hidden aria-disabled tabindex')\n                .css('display','');\n\n            if ( _.htmlExpr.test( _.options.prevArrow )) {\n                _.$prevArrow.remove();\n            }\n        }\n\n        if ( _.$nextArrow && _.$nextArrow.length ) {\n\n            _.$nextArrow\n                .removeClass('slick-disabled slick-arrow slick-hidden')\n                .removeAttr('aria-hidden aria-disabled tabindex')\n                .css('display','');\n\n            if ( _.htmlExpr.test( _.options.nextArrow )) {\n                _.$nextArrow.remove();\n            }\n        }\n\n\n        if (_.$slides) {\n\n            _.$slides\n                .removeClass('slick-slide slick-active slick-center slick-visible slick-current')\n                .removeAttr('aria-hidden')\n                .removeAttr('data-slick-index')\n                .each(function(){\n                    $(this).attr('style', $(this).data('originalStyling'));\n                });\n\n            _.$slideTrack.children(this.options.slide).detach();\n\n            _.$slideTrack.detach();\n\n            _.$list.detach();\n\n            _.$slider.append(_.$slides);\n        }\n\n        _.cleanUpRows();\n\n        _.$slider.removeClass('slick-slider');\n        _.$slider.removeClass('slick-initialized');\n        _.$slider.removeClass('slick-dotted');\n\n        _.unslicked = true;\n\n        if(!refresh) {\n            _.$slider.trigger('destroy', [_]);\n        }\n\n    };\n\n    Slick.prototype.disableTransition = function(slide) {\n\n        var _ = this,\n            transition = {};\n\n        transition[_.transitionType] = '';\n\n        if (_.options.fade === false) {\n            _.$slideTrack.css(transition);\n        } else {\n            _.$slides.eq(slide).css(transition);\n        }\n\n    };\n\n    Slick.prototype.fadeSlide = function(slideIndex, callback) {\n\n        var _ = this;\n\n        if (_.cssTransitions === false) {\n\n            _.$slides.eq(slideIndex).css({\n                zIndex: _.options.zIndex\n            });\n\n            _.$slides.eq(slideIndex).animate({\n                opacity: 1\n            }, _.options.speed, _.options.easing, callback);\n\n        } else {\n\n            _.applyTransition(slideIndex);\n\n            _.$slides.eq(slideIndex).css({\n                opacity: 1,\n                zIndex: _.options.zIndex\n            });\n\n            if (callback) {\n                setTimeout(function() {\n\n                    _.disableTransition(slideIndex);\n\n                    callback.call();\n                }, _.options.speed);\n            }\n\n        }\n\n    };\n\n    Slick.prototype.fadeSlideOut = function(slideIndex) {\n\n        var _ = this;\n\n        if (_.cssTransitions === false) {\n\n            _.$slides.eq(slideIndex).animate({\n                opacity: 0,\n                zIndex: _.options.zIndex - 2\n            }, _.options.speed, _.options.easing);\n\n        } else {\n\n            _.applyTransition(slideIndex);\n\n            _.$slides.eq(slideIndex).css({\n                opacity: 0,\n                zIndex: _.options.zIndex - 2\n            });\n\n        }\n\n    };\n\n    Slick.prototype.filterSlides = Slick.prototype.slickFilter = function(filter) {\n\n        var _ = this;\n\n        if (filter !== null) {\n\n            _.$slidesCache = _.$slides;\n\n            _.unload();\n\n            _.$slideTrack.children(this.options.slide).detach();\n\n            _.$slidesCache.filter(filter).appendTo(_.$slideTrack);\n\n            _.reinit();\n\n        }\n\n    };\n\n    Slick.prototype.focusHandler = function() {\n\n        var _ = this;\n\n        _.$slider\n            .off('focus.slick blur.slick')\n            .on('focus.slick blur.slick', '*', function(event) {\n\n            event.stopImmediatePropagation();\n            var $sf = $(this);\n\n            setTimeout(function() {\n\n                if( _.options.pauseOnFocus ) {\n                    _.focussed = $sf.is(':focus');\n                    _.autoPlay();\n                }\n\n            }, 0);\n\n        });\n    };\n\n    Slick.prototype.getCurrent = Slick.prototype.slickCurrentSlide = function() {\n\n        var _ = this;\n        return _.currentSlide;\n\n    };\n\n    Slick.prototype.getDotCount = function() {\n\n        var _ = this;\n\n        var breakPoint = 0;\n        var counter = 0;\n        var pagerQty = 0;\n\n        if (_.options.infinite === true) {\n            if (_.slideCount <= _.options.slidesToShow) {\n                 ++pagerQty;\n            } else {\n                while (breakPoint < _.slideCount) {\n                    ++pagerQty;\n                    breakPoint = counter + _.options.slidesToScroll;\n                    counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;\n                }\n            }\n        } else if (_.options.centerMode === true) {\n            pagerQty = _.slideCount;\n        } else if(!_.options.asNavFor) {\n            pagerQty = 1 + Math.ceil((_.slideCount - _.options.slidesToShow) / _.options.slidesToScroll);\n        }else {\n            while (breakPoint < _.slideCount) {\n                ++pagerQty;\n                breakPoint = counter + _.options.slidesToScroll;\n                counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;\n            }\n        }\n\n        return pagerQty - 1;\n\n    };\n\n    Slick.prototype.getLeft = function(slideIndex) {\n\n        var _ = this,\n            targetLeft,\n            verticalHeight,\n            verticalOffset = 0,\n            targetSlide,\n            coef;\n\n        _.slideOffset = 0;\n        verticalHeight = _.$slides.first().outerHeight(true);\n\n        if (_.options.infinite === true) {\n            if (_.slideCount > _.options.slidesToShow) {\n                _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;\n                coef = -1\n\n                if (_.options.vertical === true && _.options.centerMode === true) {\n                    if (_.options.slidesToShow === 2) {\n                        coef = -1.5;\n                    } else if (_.options.slidesToShow === 1) {\n                        coef = -2\n                    }\n                }\n                verticalOffset = (verticalHeight * _.options.slidesToShow) * coef;\n            }\n            if (_.slideCount % _.options.slidesToScroll !== 0) {\n                if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {\n                    if (slideIndex > _.slideCount) {\n                        _.slideOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * _.slideWidth) * -1;\n                        verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;\n                    } else {\n                        _.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;\n                        verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;\n                    }\n                }\n            }\n        } else {\n            if (slideIndex + _.options.slidesToShow > _.slideCount) {\n                _.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;\n                verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;\n            }\n        }\n\n        if (_.slideCount <= _.options.slidesToShow) {\n            _.slideOffset = 0;\n            verticalOffset = 0;\n        }\n\n        if (_.options.centerMode === true && _.slideCount <= _.options.slidesToShow) {\n            _.slideOffset = ((_.slideWidth * Math.floor(_.options.slidesToShow)) / 2) - ((_.slideWidth * _.slideCount) / 2);\n        } else if (_.options.centerMode === true && _.options.infinite === true) {\n            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;\n        } else if (_.options.centerMode === true) {\n            _.slideOffset = 0;\n            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);\n        }\n\n        if (_.options.vertical === false) {\n            targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;\n        } else {\n            targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;\n        }\n\n        if (_.options.variableWidth === true) {\n\n            if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {\n                targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);\n            } else {\n                targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);\n            }\n\n            if (_.options.rtl === true) {\n                if (targetSlide[0]) {\n                    targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;\n                } else {\n                    targetLeft =  0;\n                }\n            } else {\n                targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;\n            }\n\n            if (_.options.centerMode === true) {\n                if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {\n                    targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);\n                } else {\n                    targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);\n                }\n\n                if (_.options.rtl === true) {\n                    if (targetSlide[0]) {\n                        targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;\n                    } else {\n                        targetLeft =  0;\n                    }\n                } else {\n                    targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;\n                }\n\n                targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;\n            }\n        }\n\n        return targetLeft;\n\n    };\n\n    Slick.prototype.getOption = Slick.prototype.slickGetOption = function(option) {\n\n        var _ = this;\n\n        return _.options[option];\n\n    };\n\n    Slick.prototype.getNavigableIndexes = function() {\n\n        var _ = this,\n            breakPoint = 0,\n            counter = 0,\n            indexes = [],\n            max;\n\n        if (_.options.infinite === false) {\n            max = _.slideCount;\n        } else {\n            breakPoint = _.options.slidesToScroll * -1;\n            counter = _.options.slidesToScroll * -1;\n            max = _.slideCount * 2;\n        }\n\n        while (breakPoint < max) {\n            indexes.push(breakPoint);\n            breakPoint = counter + _.options.slidesToScroll;\n            counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;\n        }\n\n        return indexes;\n\n    };\n\n    Slick.prototype.getSlick = function() {\n\n        return this;\n\n    };\n\n    Slick.prototype.getSlideCount = function() {\n\n        var _ = this,\n            slidesTraversed, swipedSlide, centerOffset;\n\n        centerOffset = _.options.centerMode === true ? _.slideWidth * Math.floor(_.options.slidesToShow / 2) : 0;\n\n        if (_.options.swipeToSlide === true) {\n            _.$slideTrack.find('.slick-slide').each(function(index, slide) {\n                if (slide.offsetLeft - centerOffset + ($(slide).outerWidth() / 2) > (_.swipeLeft * -1)) {\n                    swipedSlide = slide;\n                    return false;\n                }\n            });\n\n            slidesTraversed = Math.abs($(swipedSlide).attr('data-slick-index') - _.currentSlide) || 1;\n\n            return slidesTraversed;\n\n        } else {\n            return _.options.slidesToScroll;\n        }\n\n    };\n\n    Slick.prototype.goTo = Slick.prototype.slickGoTo = function(slide, dontAnimate) {\n\n        var _ = this;\n\n        _.changeSlide({\n            data: {\n                message: 'index',\n                index: parseInt(slide)\n            }\n        }, dontAnimate);\n\n    };\n\n    Slick.prototype.init = function(creation) {\n\n        var _ = this;\n\n        if (!$(_.$slider).hasClass('slick-initialized')) {\n\n            $(_.$slider).addClass('slick-initialized');\n\n            _.buildRows();\n            _.buildOut();\n            _.setProps();\n            _.startLoad();\n            _.loadSlider();\n            _.initializeEvents();\n            _.updateArrows();\n            _.updateDots();\n            _.checkResponsive(true);\n            _.focusHandler();\n\n        }\n\n        if (creation) {\n            _.$slider.trigger('init', [_]);\n        }\n\n        if (_.options.accessibility === true) {\n            _.initADA();\n        }\n\n        if ( _.options.autoplay ) {\n\n            _.paused = false;\n            _.autoPlay();\n\n        }\n\n    };\n\n    Slick.prototype.initADA = function() {\n        var _ = this,\n                numDotGroups = Math.ceil(_.slideCount / _.options.slidesToShow),\n                tabControlIndexes = _.getNavigableIndexes().filter(function(val) {\n                    return (val >= 0) && (val < _.slideCount);\n                });\n\n        _.$slides.add(_.$slideTrack.find('.slick-cloned')).attr({\n            'aria-hidden': 'true',\n            'tabindex': '-1'\n        }).find('a, input, button, select').attr({\n            'tabindex': '-1'\n        });\n\n        if (_.$dots !== null) {\n            _.$slides.not(_.$slideTrack.find('.slick-cloned')).each(function(i) {\n                var slideControlIndex = tabControlIndexes.indexOf(i);\n\n                $(this).attr({\n                    'role': 'tabpanel',\n                    'id': 'slick-slide' + _.instanceUid + i,\n                    'tabindex': -1\n                });\n\n                if (slideControlIndex !== -1) {\n                   var ariaButtonControl = 'slick-slide-control' + _.instanceUid + slideControlIndex\n                   if ($('#' + ariaButtonControl).length) {\n                     $(this).attr({\n                         'aria-describedby': ariaButtonControl\n                     });\n                   }\n                }\n            });\n\n            _.$dots.attr('role', 'tablist').find('li').each(function(i) {\n                var mappedSlideIndex = tabControlIndexes[i];\n\n                $(this).attr({\n                    'role': 'presentation'\n                });\n\n                $(this).find('button').first().attr({\n                    'role': 'tab',\n                    'id': 'slick-slide-control' + _.instanceUid + i,\n                    'aria-controls': 'slick-slide' + _.instanceUid + mappedSlideIndex,\n                    'aria-label': (i + 1) + ' of ' + numDotGroups,\n                    'aria-selected': null,\n                    'tabindex': '-1'\n                });\n\n            }).eq(_.currentSlide).find('button').attr({\n                'aria-selected': 'true',\n                'tabindex': '0'\n            }).end();\n        }\n\n        for (var i=_.currentSlide, max=i+_.options.slidesToShow; i < max; i++) {\n          if (_.options.focusOnChange) {\n            _.$slides.eq(i).attr({'tabindex': '0'});\n          } else {\n            _.$slides.eq(i).removeAttr('tabindex');\n          }\n        }\n\n        _.activateADA();\n\n    };\n\n    Slick.prototype.initArrowEvents = function() {\n\n        var _ = this;\n\n        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {\n            _.$prevArrow\n               .off('click.slick')\n               .on('click.slick', {\n                    message: 'previous'\n               }, _.changeSlide);\n            _.$nextArrow\n               .off('click.slick')\n               .on('click.slick', {\n                    message: 'next'\n               }, _.changeSlide);\n\n            if (_.options.accessibility === true) {\n                _.$prevArrow.on('keydown.slick', _.keyHandler);\n                _.$nextArrow.on('keydown.slick', _.keyHandler);\n            }\n        }\n\n    };\n\n    Slick.prototype.initDotEvents = function() {\n\n        var _ = this;\n\n        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {\n            $('li', _.$dots).on('click.slick', {\n                message: 'index'\n            }, _.changeSlide);\n\n            if (_.options.accessibility === true) {\n                _.$dots.on('keydown.slick', _.keyHandler);\n            }\n        }\n\n        if (_.options.dots === true && _.options.pauseOnDotsHover === true && _.slideCount > _.options.slidesToShow) {\n\n            $('li', _.$dots)\n                .on('mouseenter.slick', $.proxy(_.interrupt, _, true))\n                .on('mouseleave.slick', $.proxy(_.interrupt, _, false));\n\n        }\n\n    };\n\n    Slick.prototype.initSlideEvents = function() {\n\n        var _ = this;\n\n        if ( _.options.pauseOnHover ) {\n\n            _.$list.on('mouseenter.slick', $.proxy(_.interrupt, _, true));\n            _.$list.on('mouseleave.slick', $.proxy(_.interrupt, _, false));\n\n        }\n\n    };\n\n    Slick.prototype.initializeEvents = function() {\n\n        var _ = this;\n\n        _.initArrowEvents();\n\n        _.initDotEvents();\n        _.initSlideEvents();\n\n        _.$list.on('touchstart.slick mousedown.slick', {\n            action: 'start'\n        }, _.swipeHandler);\n        _.$list.on('touchmove.slick mousemove.slick', {\n            action: 'move'\n        }, _.swipeHandler);\n        _.$list.on('touchend.slick mouseup.slick', {\n            action: 'end'\n        }, _.swipeHandler);\n        _.$list.on('touchcancel.slick mouseleave.slick', {\n            action: 'end'\n        }, _.swipeHandler);\n\n        _.$list.on('click.slick', _.clickHandler);\n\n        $(document).on(_.visibilityChange, $.proxy(_.visibility, _));\n\n        if (_.options.accessibility === true) {\n            _.$list.on('keydown.slick', _.keyHandler);\n        }\n\n        if (_.options.focusOnSelect === true) {\n            $(_.$slideTrack).children().on('click.slick', _.selectHandler);\n        }\n\n        $(window).on('orientationchange.slick.slick-' + _.instanceUid, $.proxy(_.orientationChange, _));\n\n        $(window).on('resize.slick.slick-' + _.instanceUid, $.proxy(_.resize, _));\n\n        $('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault);\n\n        $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);\n        $(_.setPosition);\n\n    };\n\n    Slick.prototype.initUI = function() {\n\n        var _ = this;\n\n        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$prevArrow.show();\n            _.$nextArrow.show();\n\n        }\n\n        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$dots.show();\n\n        }\n\n    };\n\n    Slick.prototype.keyHandler = function(event) {\n\n        var _ = this;\n         //Dont slide if the cursor is inside the form fields and arrow keys are pressed\n        if(!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {\n            if (event.keyCode === 37 && _.options.accessibility === true) {\n                _.changeSlide({\n                    data: {\n                        message: _.options.rtl === true ? 'next' :  'previous'\n                    }\n                });\n            } else if (event.keyCode === 39 && _.options.accessibility === true) {\n                _.changeSlide({\n                    data: {\n                        message: _.options.rtl === true ? 'previous' : 'next'\n                    }\n                });\n            }\n        }\n\n    };\n\n    Slick.prototype.lazyLoad = function() {\n\n        var _ = this,\n            loadRange, cloneRange, rangeStart, rangeEnd;\n\n        function loadImages(imagesScope) {\n\n            $('img[data-lazy]', imagesScope).each(function() {\n\n                var image = $(this),\n                    imageSource = $(this).attr('data-lazy'),\n                    imageSrcSet = $(this).attr('data-srcset'),\n                    imageSizes  = $(this).attr('data-sizes') || _.$slider.attr('data-sizes'),\n                    imageToLoad = document.createElement('img');\n\n                imageToLoad.onload = function() {\n\n                    image\n                        .animate({ opacity: 0 }, 100, function() {\n\n                            if (imageSrcSet) {\n                                image\n                                    .attr('srcset', imageSrcSet );\n\n                                if (imageSizes) {\n                                    image\n                                        .attr('sizes', imageSizes );\n                                }\n                            }\n\n                            image\n                                .attr('src', imageSource)\n                                .animate({ opacity: 1 }, 200, function() {\n                                    image\n                                        .removeAttr('data-lazy data-srcset data-sizes')\n                                        .removeClass('slick-loading');\n                                });\n                            _.$slider.trigger('lazyLoaded', [_, image, imageSource]);\n                        });\n\n                };\n\n                imageToLoad.onerror = function() {\n\n                    image\n                        .removeAttr( 'data-lazy' )\n                        .removeClass( 'slick-loading' )\n                        .addClass( 'slick-lazyload-error' );\n\n                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);\n\n                };\n\n                imageToLoad.src = imageSource;\n\n            });\n\n        }\n\n        if (_.options.centerMode === true) {\n            if (_.options.infinite === true) {\n                rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1);\n                rangeEnd = rangeStart + _.options.slidesToShow + 2;\n            } else {\n                rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow / 2 + 1));\n                rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide;\n            }\n        } else {\n            rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;\n            rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow);\n            if (_.options.fade === true) {\n                if (rangeStart > 0) rangeStart--;\n                if (rangeEnd <= _.slideCount) rangeEnd++;\n            }\n        }\n\n        loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);\n\n        if (_.options.lazyLoad === 'anticipated') {\n            var prevSlide = rangeStart - 1,\n                nextSlide = rangeEnd,\n                $slides = _.$slider.find('.slick-slide');\n\n            for (var i = 0; i < _.options.slidesToScroll; i++) {\n                if (prevSlide < 0) prevSlide = _.slideCount - 1;\n                loadRange = loadRange.add($slides.eq(prevSlide));\n                loadRange = loadRange.add($slides.eq(nextSlide));\n                prevSlide--;\n                nextSlide++;\n            }\n        }\n\n        loadImages(loadRange);\n\n        if (_.slideCount <= _.options.slidesToShow) {\n            cloneRange = _.$slider.find('.slick-slide');\n            loadImages(cloneRange);\n        } else\n        if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {\n            cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);\n            loadImages(cloneRange);\n        } else if (_.currentSlide === 0) {\n            cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);\n            loadImages(cloneRange);\n        }\n\n    };\n\n    Slick.prototype.loadSlider = function() {\n\n        var _ = this;\n\n        _.setPosition();\n\n        _.$slideTrack.css({\n            opacity: 1\n        });\n\n        _.$slider.removeClass('slick-loading');\n\n        _.initUI();\n\n        if (_.options.lazyLoad === 'progressive') {\n            _.progressiveLazyLoad();\n        }\n\n    };\n\n    Slick.prototype.next = Slick.prototype.slickNext = function() {\n\n        var _ = this;\n\n        _.changeSlide({\n            data: {\n                message: 'next'\n            }\n        });\n\n    };\n\n    Slick.prototype.orientationChange = function() {\n\n        var _ = this;\n\n        _.checkResponsive();\n        _.setPosition();\n\n    };\n\n    Slick.prototype.pause = Slick.prototype.slickPause = function() {\n\n        var _ = this;\n\n        _.autoPlayClear();\n        _.paused = true;\n\n    };\n\n    Slick.prototype.play = Slick.prototype.slickPlay = function() {\n\n        var _ = this;\n\n        _.autoPlay();\n        _.options.autoplay = true;\n        _.paused = false;\n        _.focussed = false;\n        _.interrupted = false;\n\n    };\n\n    Slick.prototype.postSlide = function(index) {\n\n        var _ = this;\n\n        if( !_.unslicked ) {\n\n            _.$slider.trigger('afterChange', [_, index]);\n\n            _.animating = false;\n\n            if (_.slideCount > _.options.slidesToShow) {\n                _.setPosition();\n            }\n\n            _.swipeLeft = null;\n\n            if ( _.options.autoplay ) {\n                _.autoPlay();\n            }\n\n            if (_.options.accessibility === true) {\n                _.initADA();\n\n                if (_.options.focusOnChange) {\n                    var $currentSlide = $(_.$slides.get(_.currentSlide));\n                    $currentSlide.attr('tabindex', 0).focus();\n                }\n            }\n\n        }\n\n    };\n\n    Slick.prototype.prev = Slick.prototype.slickPrev = function() {\n\n        var _ = this;\n\n        _.changeSlide({\n            data: {\n                message: 'previous'\n            }\n        });\n\n    };\n\n    Slick.prototype.preventDefault = function(event) {\n\n        event.preventDefault();\n\n    };\n\n    Slick.prototype.progressiveLazyLoad = function( tryCount ) {\n\n        tryCount = tryCount || 1;\n\n        var _ = this,\n            $imgsToLoad = $( 'img[data-lazy]', _.$slider ),\n            image,\n            imageSource,\n            imageSrcSet,\n            imageSizes,\n            imageToLoad;\n\n        if ( $imgsToLoad.length ) {\n\n            image = $imgsToLoad.first();\n            imageSource = image.attr('data-lazy');\n            imageSrcSet = image.attr('data-srcset');\n            imageSizes  = image.attr('data-sizes') || _.$slider.attr('data-sizes');\n            imageToLoad = document.createElement('img');\n\n            imageToLoad.onload = function() {\n\n                if (imageSrcSet) {\n                    image\n                        .attr('srcset', imageSrcSet );\n\n                    if (imageSizes) {\n                        image\n                            .attr('sizes', imageSizes );\n                    }\n                }\n\n                image\n                    .attr( 'src', imageSource )\n                    .removeAttr('data-lazy data-srcset data-sizes')\n                    .removeClass('slick-loading');\n\n                if ( _.options.adaptiveHeight === true ) {\n                    _.setPosition();\n                }\n\n                _.$slider.trigger('lazyLoaded', [ _, image, imageSource ]);\n                _.progressiveLazyLoad();\n\n            };\n\n            imageToLoad.onerror = function() {\n\n                if ( tryCount < 3 ) {\n\n                    /**\n                     * try to load the image 3 times,\n                     * leave a slight delay so we don't get\n                     * servers blocking the request.\n                     */\n                    setTimeout( function() {\n                        _.progressiveLazyLoad( tryCount + 1 );\n                    }, 500 );\n\n                } else {\n\n                    image\n                        .removeAttr( 'data-lazy' )\n                        .removeClass( 'slick-loading' )\n                        .addClass( 'slick-lazyload-error' );\n\n                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);\n\n                    _.progressiveLazyLoad();\n\n                }\n\n            };\n\n            imageToLoad.src = imageSource;\n\n        } else {\n\n            _.$slider.trigger('allImagesLoaded', [ _ ]);\n\n        }\n\n    };\n\n    Slick.prototype.refresh = function( initializing ) {\n\n        var _ = this, currentSlide, lastVisibleIndex;\n\n        lastVisibleIndex = _.slideCount - _.options.slidesToShow;\n\n        // in non-infinite sliders, we don't want to go past the\n        // last visible index.\n        if( !_.options.infinite && ( _.currentSlide > lastVisibleIndex )) {\n            _.currentSlide = lastVisibleIndex;\n        }\n\n        // if less slides than to show, go to start.\n        if ( _.slideCount <= _.options.slidesToShow ) {\n            _.currentSlide = 0;\n\n        }\n\n        currentSlide = _.currentSlide;\n\n        _.destroy(true);\n\n        $.extend(_, _.initials, { currentSlide: currentSlide });\n\n        _.init();\n\n        if( !initializing ) {\n\n            _.changeSlide({\n                data: {\n                    message: 'index',\n                    index: currentSlide\n                }\n            }, false);\n\n        }\n\n    };\n\n    Slick.prototype.registerBreakpoints = function() {\n\n        var _ = this, breakpoint, currentBreakpoint, l,\n            responsiveSettings = _.options.responsive || null;\n\n        if ( $.type(responsiveSettings) === 'array' && responsiveSettings.length ) {\n\n            _.respondTo = _.options.respondTo || 'window';\n\n            for ( breakpoint in responsiveSettings ) {\n\n                l = _.breakpoints.length-1;\n\n                if (responsiveSettings.hasOwnProperty(breakpoint)) {\n                    currentBreakpoint = responsiveSettings[breakpoint].breakpoint;\n\n                    // loop through the breakpoints and cut out any existing\n                    // ones with the same breakpoint number, we don't want dupes.\n                    while( l >= 0 ) {\n                        if( _.breakpoints[l] && _.breakpoints[l] === currentBreakpoint ) {\n                            _.breakpoints.splice(l,1);\n                        }\n                        l--;\n                    }\n\n                    _.breakpoints.push(currentBreakpoint);\n                    _.breakpointSettings[currentBreakpoint] = responsiveSettings[breakpoint].settings;\n\n                }\n\n            }\n\n            _.breakpoints.sort(function(a, b) {\n                return ( _.options.mobileFirst ) ? a-b : b-a;\n            });\n\n        }\n\n    };\n\n    Slick.prototype.reinit = function() {\n\n        var _ = this;\n\n        _.$slides =\n            _.$slideTrack\n                .children(_.options.slide)\n                .addClass('slick-slide');\n\n        _.slideCount = _.$slides.length;\n\n        if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {\n            _.currentSlide = _.currentSlide - _.options.slidesToScroll;\n        }\n\n        if (_.slideCount <= _.options.slidesToShow) {\n            _.currentSlide = 0;\n        }\n\n        _.registerBreakpoints();\n\n        _.setProps();\n        _.setupInfinite();\n        _.buildArrows();\n        _.updateArrows();\n        _.initArrowEvents();\n        _.buildDots();\n        _.updateDots();\n        _.initDotEvents();\n        _.cleanUpSlideEvents();\n        _.initSlideEvents();\n\n        _.checkResponsive(false, true);\n\n        if (_.options.focusOnSelect === true) {\n            $(_.$slideTrack).children().on('click.slick', _.selectHandler);\n        }\n\n        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);\n\n        _.setPosition();\n        _.focusHandler();\n\n        _.paused = !_.options.autoplay;\n        _.autoPlay();\n\n        _.$slider.trigger('reInit', [_]);\n\n    };\n\n    Slick.prototype.resize = function() {\n\n        var _ = this;\n\n        if ($(window).width() !== _.windowWidth) {\n            clearTimeout(_.windowDelay);\n            _.windowDelay = window.setTimeout(function() {\n                _.windowWidth = $(window).width();\n                _.checkResponsive();\n                if( !_.unslicked ) { _.setPosition(); }\n            }, 50);\n        }\n    };\n\n    Slick.prototype.removeSlide = Slick.prototype.slickRemove = function(index, removeBefore, removeAll) {\n\n        var _ = this;\n\n        if (typeof(index) === 'boolean') {\n            removeBefore = index;\n            index = removeBefore === true ? 0 : _.slideCount - 1;\n        } else {\n            index = removeBefore === true ? --index : index;\n        }\n\n        if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {\n            return false;\n        }\n\n        _.unload();\n\n        if (removeAll === true) {\n            _.$slideTrack.children().remove();\n        } else {\n            _.$slideTrack.children(this.options.slide).eq(index).remove();\n        }\n\n        _.$slides = _.$slideTrack.children(this.options.slide);\n\n        _.$slideTrack.children(this.options.slide).detach();\n\n        _.$slideTrack.append(_.$slides);\n\n        _.$slidesCache = _.$slides;\n\n        _.reinit();\n\n    };\n\n    Slick.prototype.setCSS = function(position) {\n\n        var _ = this,\n            positionProps = {},\n            x, y;\n\n        if (_.options.rtl === true) {\n            position = -position;\n        }\n        x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';\n        y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';\n\n        positionProps[_.positionProp] = position;\n\n        if (_.transformsEnabled === false) {\n            _.$slideTrack.css(positionProps);\n        } else {\n            positionProps = {};\n            if (_.cssTransitions === false) {\n                positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';\n                _.$slideTrack.css(positionProps);\n            } else {\n                positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';\n                _.$slideTrack.css(positionProps);\n            }\n        }\n\n    };\n\n    Slick.prototype.setDimensions = function() {\n\n        var _ = this;\n\n        if (_.options.vertical === false) {\n            if (_.options.centerMode === true) {\n                _.$list.css({\n                    padding: ('0px ' + _.options.centerPadding)\n                });\n            }\n        } else {\n            _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);\n            if (_.options.centerMode === true) {\n                _.$list.css({\n                    padding: (_.options.centerPadding + ' 0px')\n                });\n            }\n        }\n\n        _.listWidth = _.$list.width();\n        _.listHeight = _.$list.height();\n\n\n        if (_.options.vertical === false && _.options.variableWidth === false) {\n            _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);\n            _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));\n\n        } else if (_.options.variableWidth === true) {\n            _.$slideTrack.width(5000 * _.slideCount);\n        } else {\n            _.slideWidth = Math.ceil(_.listWidth);\n            _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));\n        }\n\n        var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();\n        if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);\n\n    };\n\n    Slick.prototype.setFade = function() {\n\n        var _ = this,\n            targetLeft;\n\n        _.$slides.each(function(index, element) {\n            targetLeft = (_.slideWidth * index) * -1;\n            if (_.options.rtl === true) {\n                $(element).css({\n                    position: 'relative',\n                    right: targetLeft,\n                    top: 0,\n                    zIndex: _.options.zIndex - 2,\n                    opacity: 0\n                });\n            } else {\n                $(element).css({\n                    position: 'relative',\n                    left: targetLeft,\n                    top: 0,\n                    zIndex: _.options.zIndex - 2,\n                    opacity: 0\n                });\n            }\n        });\n\n        _.$slides.eq(_.currentSlide).css({\n            zIndex: _.options.zIndex - 1,\n            opacity: 1\n        });\n\n    };\n\n    Slick.prototype.setHeight = function() {\n\n        var _ = this;\n\n        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {\n            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);\n            _.$list.css('height', targetHeight);\n        }\n\n    };\n\n    Slick.prototype.setOption =\n    Slick.prototype.slickSetOption = function() {\n\n        /**\n         * accepts arguments in format of:\n         *\n         *  - for changing a single option's value:\n         *     .slick(\"setOption\", option, value, refresh )\n         *\n         *  - for changing a set of responsive options:\n         *     .slick(\"setOption\", 'responsive', [{}, ...], refresh )\n         *\n         *  - for updating multiple values at once (not responsive)\n         *     .slick(\"setOption\", { 'option': value, ... }, refresh )\n         */\n\n        var _ = this, l, item, option, value, refresh = false, type;\n\n        if( $.type( arguments[0] ) === 'object' ) {\n\n            option =  arguments[0];\n            refresh = arguments[1];\n            type = 'multiple';\n\n        } else if ( $.type( arguments[0] ) === 'string' ) {\n\n            option =  arguments[0];\n            value = arguments[1];\n            refresh = arguments[2];\n\n            if ( arguments[0] === 'responsive' && $.type( arguments[1] ) === 'array' ) {\n\n                type = 'responsive';\n\n            } else if ( typeof arguments[1] !== 'undefined' ) {\n\n                type = 'single';\n\n            }\n\n        }\n\n        if ( type === 'single' ) {\n\n            _.options[option] = value;\n\n\n        } else if ( type === 'multiple' ) {\n\n            $.each( option , function( opt, val ) {\n\n                _.options[opt] = val;\n\n            });\n\n\n        } else if ( type === 'responsive' ) {\n\n            for ( item in value ) {\n\n                if( $.type( _.options.responsive ) !== 'array' ) {\n\n                    _.options.responsive = [ value[item] ];\n\n                } else {\n\n                    l = _.options.responsive.length-1;\n\n                    // loop through the responsive object and splice out duplicates.\n                    while( l >= 0 ) {\n\n                        if( _.options.responsive[l].breakpoint === value[item].breakpoint ) {\n\n                            _.options.responsive.splice(l,1);\n\n                        }\n\n                        l--;\n\n                    }\n\n                    _.options.responsive.push( value[item] );\n\n                }\n\n            }\n\n        }\n\n        if ( refresh ) {\n\n            _.unload();\n            _.reinit();\n\n        }\n\n    };\n\n    Slick.prototype.setPosition = function() {\n\n        var _ = this;\n\n        _.setDimensions();\n\n        _.setHeight();\n\n        if (_.options.fade === false) {\n            _.setCSS(_.getLeft(_.currentSlide));\n        } else {\n            _.setFade();\n        }\n\n        _.$slider.trigger('setPosition', [_]);\n\n    };\n\n    Slick.prototype.setProps = function() {\n\n        var _ = this,\n            bodyStyle = document.body.style;\n\n        _.positionProp = _.options.vertical === true ? 'top' : 'left';\n\n        if (_.positionProp === 'top') {\n            _.$slider.addClass('slick-vertical');\n        } else {\n            _.$slider.removeClass('slick-vertical');\n        }\n\n        if (bodyStyle.WebkitTransition !== undefined ||\n            bodyStyle.MozTransition !== undefined ||\n            bodyStyle.msTransition !== undefined) {\n            if (_.options.useCSS === true) {\n                _.cssTransitions = true;\n            }\n        }\n\n        if ( _.options.fade ) {\n            if ( typeof _.options.zIndex === 'number' ) {\n                if( _.options.zIndex < 3 ) {\n                    _.options.zIndex = 3;\n                }\n            } else {\n                _.options.zIndex = _.defaults.zIndex;\n            }\n        }\n\n        if (bodyStyle.OTransform !== undefined) {\n            _.animType = 'OTransform';\n            _.transformType = '-o-transform';\n            _.transitionType = 'OTransition';\n            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;\n        }\n        if (bodyStyle.MozTransform !== undefined) {\n            _.animType = 'MozTransform';\n            _.transformType = '-moz-transform';\n            _.transitionType = 'MozTransition';\n            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;\n        }\n        if (bodyStyle.webkitTransform !== undefined) {\n            _.animType = 'webkitTransform';\n            _.transformType = '-webkit-transform';\n            _.transitionType = 'webkitTransition';\n            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;\n        }\n        if (bodyStyle.msTransform !== undefined) {\n            _.animType = 'msTransform';\n            _.transformType = '-ms-transform';\n            _.transitionType = 'msTransition';\n            if (bodyStyle.msTransform === undefined) _.animType = false;\n        }\n        if (bodyStyle.transform !== undefined && _.animType !== false) {\n            _.animType = 'transform';\n            _.transformType = 'transform';\n            _.transitionType = 'transition';\n        }\n        _.transformsEnabled = _.options.useTransform && (_.animType !== null && _.animType !== false);\n    };\n\n\n    Slick.prototype.setSlideClasses = function(index) {\n\n        var _ = this,\n            centerOffset, allSlides, indexOffset, remainder;\n\n        allSlides = _.$slider\n            .find('.slick-slide')\n            .removeClass('slick-active slick-center slick-current')\n            .attr('aria-hidden', 'true');\n\n        _.$slides\n            .eq(index)\n            .addClass('slick-current');\n\n        if (_.options.centerMode === true) {\n\n            var evenCoef = _.options.slidesToShow % 2 === 0 ? 1 : 0;\n\n            centerOffset = Math.floor(_.options.slidesToShow / 2);\n\n            if (_.options.infinite === true) {\n\n                if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {\n                    _.$slides\n                        .slice(index - centerOffset + evenCoef, index + centerOffset + 1)\n                        .addClass('slick-active')\n                        .attr('aria-hidden', 'false');\n\n                } else {\n\n                    indexOffset = _.options.slidesToShow + index;\n                    allSlides\n                        .slice(indexOffset - centerOffset + 1 + evenCoef, indexOffset + centerOffset + 2)\n                        .addClass('slick-active')\n                        .attr('aria-hidden', 'false');\n\n                }\n\n                if (index === 0) {\n\n                    allSlides\n                        .eq(allSlides.length - 1 - _.options.slidesToShow)\n                        .addClass('slick-center');\n\n                } else if (index === _.slideCount - 1) {\n\n                    allSlides\n                        .eq(_.options.slidesToShow)\n                        .addClass('slick-center');\n\n                }\n\n            }\n\n            _.$slides\n                .eq(index)\n                .addClass('slick-center');\n\n        } else {\n\n            if (index >= 0 && index <= (_.slideCount - _.options.slidesToShow)) {\n\n                _.$slides\n                    .slice(index, index + _.options.slidesToShow)\n                    .addClass('slick-active')\n                    .attr('aria-hidden', 'false');\n\n            } else if (allSlides.length <= _.options.slidesToShow) {\n\n                allSlides\n                    .addClass('slick-active')\n                    .attr('aria-hidden', 'false');\n\n            } else {\n\n                remainder = _.slideCount % _.options.slidesToShow;\n                indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;\n\n                if (_.options.slidesToShow == _.options.slidesToScroll && (_.slideCount - index) < _.options.slidesToShow) {\n\n                    allSlides\n                        .slice(indexOffset - (_.options.slidesToShow - remainder), indexOffset + remainder)\n                        .addClass('slick-active')\n                        .attr('aria-hidden', 'false');\n\n                } else {\n\n                    allSlides\n                        .slice(indexOffset, indexOffset + _.options.slidesToShow)\n                        .addClass('slick-active')\n                        .attr('aria-hidden', 'false');\n\n                }\n\n            }\n\n        }\n\n        if (_.options.lazyLoad === 'ondemand' || _.options.lazyLoad === 'anticipated') {\n            _.lazyLoad();\n        }\n    };\n\n    Slick.prototype.setupInfinite = function() {\n\n        var _ = this,\n            i, slideIndex, infiniteCount;\n\n        if (_.options.fade === true) {\n            _.options.centerMode = false;\n        }\n\n        if (_.options.infinite === true && _.options.fade === false) {\n\n            slideIndex = null;\n\n            if (_.slideCount > _.options.slidesToShow) {\n\n                if (_.options.centerMode === true) {\n                    infiniteCount = _.options.slidesToShow + 1;\n                } else {\n                    infiniteCount = _.options.slidesToShow;\n                }\n\n                for (i = _.slideCount; i > (_.slideCount -\n                        infiniteCount); i -= 1) {\n                    slideIndex = i - 1;\n                    $(_.$slides[slideIndex]).clone(true).attr('id', '')\n                        .attr('data-slick-index', slideIndex - _.slideCount)\n                        .prependTo(_.$slideTrack).addClass('slick-cloned');\n                }\n                for (i = 0; i < infiniteCount  + _.slideCount; i += 1) {\n                    slideIndex = i;\n                    $(_.$slides[slideIndex]).clone(true).attr('id', '')\n                        .attr('data-slick-index', slideIndex + _.slideCount)\n                        .appendTo(_.$slideTrack).addClass('slick-cloned');\n                }\n                _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {\n                    $(this).attr('id', '');\n                });\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.interrupt = function( toggle ) {\n\n        var _ = this;\n\n        if( !toggle ) {\n            _.autoPlay();\n        }\n        _.interrupted = toggle;\n\n    };\n\n    Slick.prototype.selectHandler = function(event) {\n\n        var _ = this;\n\n        var targetElement =\n            $(event.target).is('.slick-slide') ?\n                $(event.target) :\n                $(event.target).parents('.slick-slide');\n\n        var index = parseInt(targetElement.attr('data-slick-index'));\n\n        if (!index) index = 0;\n\n        if (_.slideCount <= _.options.slidesToShow) {\n\n            _.slideHandler(index, false, true);\n            return;\n\n        }\n\n        _.slideHandler(index);\n\n    };\n\n    Slick.prototype.slideHandler = function(index, sync, dontAnimate) {\n\n        var targetSlide, animSlide, oldSlide, slideLeft, targetLeft = null,\n            _ = this, navTarget;\n\n        sync = sync || false;\n\n        if (_.animating === true && _.options.waitForAnimate === true) {\n            return;\n        }\n\n        if (_.options.fade === true && _.currentSlide === index) {\n            return;\n        }\n\n        if (sync === false) {\n            _.asNavFor(index);\n        }\n\n        targetSlide = index;\n        targetLeft = _.getLeft(targetSlide);\n        slideLeft = _.getLeft(_.currentSlide);\n\n        _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;\n\n        if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > _.getDotCount() * _.options.slidesToScroll)) {\n            if (_.options.fade === false) {\n                targetSlide = _.currentSlide;\n                if (dontAnimate !== true && _.slideCount > _.options.slidesToShow) {\n                    _.animateSlide(slideLeft, function() {\n                        _.postSlide(targetSlide);\n                    });\n                } else {\n                    _.postSlide(targetSlide);\n                }\n            }\n            return;\n        } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {\n            if (_.options.fade === false) {\n                targetSlide = _.currentSlide;\n                if (dontAnimate !== true && _.slideCount > _.options.slidesToShow) {\n                    _.animateSlide(slideLeft, function() {\n                        _.postSlide(targetSlide);\n                    });\n                } else {\n                    _.postSlide(targetSlide);\n                }\n            }\n            return;\n        }\n\n        if ( _.options.autoplay ) {\n            clearInterval(_.autoPlayTimer);\n        }\n\n        if (targetSlide < 0) {\n            if (_.slideCount % _.options.slidesToScroll !== 0) {\n                animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);\n            } else {\n                animSlide = _.slideCount + targetSlide;\n            }\n        } else if (targetSlide >= _.slideCount) {\n            if (_.slideCount % _.options.slidesToScroll !== 0) {\n                animSlide = 0;\n            } else {\n                animSlide = targetSlide - _.slideCount;\n            }\n        } else {\n            animSlide = targetSlide;\n        }\n\n        _.animating = true;\n\n        _.$slider.trigger('beforeChange', [_, _.currentSlide, animSlide]);\n\n        oldSlide = _.currentSlide;\n        _.currentSlide = animSlide;\n\n        _.setSlideClasses(_.currentSlide);\n\n        if ( _.options.asNavFor ) {\n\n            navTarget = _.getNavTarget();\n            navTarget = navTarget.slick('getSlick');\n\n            if ( navTarget.slideCount <= navTarget.options.slidesToShow ) {\n                navTarget.setSlideClasses(_.currentSlide);\n            }\n\n        }\n\n        _.updateDots();\n        _.updateArrows();\n\n        if (_.options.fade === true) {\n            if (dontAnimate !== true) {\n\n                _.fadeSlideOut(oldSlide);\n\n                _.fadeSlide(animSlide, function() {\n                    _.postSlide(animSlide);\n                });\n\n            } else {\n                _.postSlide(animSlide);\n            }\n            _.animateHeight();\n            return;\n        }\n\n        if (dontAnimate !== true && _.slideCount > _.options.slidesToShow) {\n            _.animateSlide(targetLeft, function() {\n                _.postSlide(animSlide);\n            });\n        } else {\n            _.postSlide(animSlide);\n        }\n\n    };\n\n    Slick.prototype.startLoad = function() {\n\n        var _ = this;\n\n        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$prevArrow.hide();\n            _.$nextArrow.hide();\n\n        }\n\n        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$dots.hide();\n\n        }\n\n        _.$slider.addClass('slick-loading');\n\n    };\n\n    Slick.prototype.swipeDirection = function() {\n\n        var xDist, yDist, r, swipeAngle, _ = this;\n\n        xDist = _.touchObject.startX - _.touchObject.curX;\n        yDist = _.touchObject.startY - _.touchObject.curY;\n        r = Math.atan2(yDist, xDist);\n\n        swipeAngle = Math.round(r * 180 / Math.PI);\n        if (swipeAngle < 0) {\n            swipeAngle = 360 - Math.abs(swipeAngle);\n        }\n\n        if ((swipeAngle <= 45) && (swipeAngle >= 0)) {\n            return (_.options.rtl === false ? 'left' : 'right');\n        }\n        if ((swipeAngle <= 360) && (swipeAngle >= 315)) {\n            return (_.options.rtl === false ? 'left' : 'right');\n        }\n        if ((swipeAngle >= 135) && (swipeAngle <= 225)) {\n            return (_.options.rtl === false ? 'right' : 'left');\n        }\n        if (_.options.verticalSwiping === true) {\n            if ((swipeAngle >= 35) && (swipeAngle <= 135)) {\n                return 'down';\n            } else {\n                return 'up';\n            }\n        }\n\n        return 'vertical';\n\n    };\n\n    Slick.prototype.swipeEnd = function(event) {\n\n        var _ = this,\n            slideCount,\n            direction;\n\n        _.dragging = false;\n        _.swiping = false;\n\n        if (_.scrolling) {\n            _.scrolling = false;\n            return false;\n        }\n\n        _.interrupted = false;\n        _.shouldClick = ( _.touchObject.swipeLength > 10 ) ? false : true;\n\n        if ( _.touchObject.curX === undefined ) {\n            return false;\n        }\n\n        if ( _.touchObject.edgeHit === true ) {\n            _.$slider.trigger('edge', [_, _.swipeDirection() ]);\n        }\n\n        if ( _.touchObject.swipeLength >= _.touchObject.minSwipe ) {\n\n            direction = _.swipeDirection();\n\n            switch ( direction ) {\n\n                case 'left':\n                case 'down':\n\n                    slideCount =\n                        _.options.swipeToSlide ?\n                            _.checkNavigable( _.currentSlide + _.getSlideCount() ) :\n                            _.currentSlide + _.getSlideCount();\n\n                    _.currentDirection = 0;\n\n                    break;\n\n                case 'right':\n                case 'up':\n\n                    slideCount =\n                        _.options.swipeToSlide ?\n                            _.checkNavigable( _.currentSlide - _.getSlideCount() ) :\n                            _.currentSlide - _.getSlideCount();\n\n                    _.currentDirection = 1;\n\n                    break;\n\n                default:\n\n\n            }\n\n            if( direction != 'vertical' ) {\n\n                _.slideHandler( slideCount );\n                _.touchObject = {};\n                _.$slider.trigger('swipe', [_, direction ]);\n\n            }\n\n        } else {\n\n            if ( _.touchObject.startX !== _.touchObject.curX ) {\n\n                _.slideHandler( _.currentSlide );\n                _.touchObject = {};\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.swipeHandler = function(event) {\n\n        var _ = this;\n\n        if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {\n            return;\n        } else if (_.options.draggable === false && event.type.indexOf('mouse') !== -1) {\n            return;\n        }\n\n        _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?\n            event.originalEvent.touches.length : 1;\n\n        _.touchObject.minSwipe = _.listWidth / _.options\n            .touchThreshold;\n\n        if (_.options.verticalSwiping === true) {\n            _.touchObject.minSwipe = _.listHeight / _.options\n                .touchThreshold;\n        }\n\n        switch (event.data.action) {\n\n            case 'start':\n                _.swipeStart(event);\n                break;\n\n            case 'move':\n                _.swipeMove(event);\n                break;\n\n            case 'end':\n                _.swipeEnd(event);\n                break;\n\n        }\n\n    };\n\n    Slick.prototype.swipeMove = function(event) {\n\n        var _ = this,\n            edgeWasHit = false,\n            curLeft, swipeDirection, swipeLength, positionOffset, touches, verticalSwipeLength;\n\n        touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;\n\n        if (!_.dragging || _.scrolling || touches && touches.length !== 1) {\n            return false;\n        }\n\n        curLeft = _.getLeft(_.currentSlide);\n\n        _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;\n        _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;\n\n        _.touchObject.swipeLength = Math.round(Math.sqrt(\n            Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));\n\n        verticalSwipeLength = Math.round(Math.sqrt(\n            Math.pow(_.touchObject.curY - _.touchObject.startY, 2)));\n\n        if (!_.options.verticalSwiping && !_.swiping && verticalSwipeLength > 4) {\n            _.scrolling = true;\n            return false;\n        }\n\n        if (_.options.verticalSwiping === true) {\n            _.touchObject.swipeLength = verticalSwipeLength;\n        }\n\n        swipeDirection = _.swipeDirection();\n\n        if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {\n            _.swiping = true;\n            event.preventDefault();\n        }\n\n        positionOffset = (_.options.rtl === false ? 1 : -1) * (_.touchObject.curX > _.touchObject.startX ? 1 : -1);\n        if (_.options.verticalSwiping === true) {\n            positionOffset = _.touchObject.curY > _.touchObject.startY ? 1 : -1;\n        }\n\n\n        swipeLength = _.touchObject.swipeLength;\n\n        _.touchObject.edgeHit = false;\n\n        if (_.options.infinite === false) {\n            if ((_.currentSlide === 0 && swipeDirection === 'right') || (_.currentSlide >= _.getDotCount() && swipeDirection === 'left')) {\n                swipeLength = _.touchObject.swipeLength * _.options.edgeFriction;\n                _.touchObject.edgeHit = true;\n            }\n        }\n\n        if (_.options.vertical === false) {\n            _.swipeLeft = curLeft + swipeLength * positionOffset;\n        } else {\n            _.swipeLeft = curLeft + (swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;\n        }\n        if (_.options.verticalSwiping === true) {\n            _.swipeLeft = curLeft + swipeLength * positionOffset;\n        }\n\n        if (_.options.fade === true || _.options.touchMove === false) {\n            return false;\n        }\n\n        if (_.animating === true) {\n            _.swipeLeft = null;\n            return false;\n        }\n\n        _.setCSS(_.swipeLeft);\n\n    };\n\n    Slick.prototype.swipeStart = function(event) {\n\n        var _ = this,\n            touches;\n\n        _.interrupted = true;\n\n        if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {\n            _.touchObject = {};\n            return false;\n        }\n\n        if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {\n            touches = event.originalEvent.touches[0];\n        }\n\n        _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;\n        _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;\n\n        _.dragging = true;\n\n    };\n\n    Slick.prototype.unfilterSlides = Slick.prototype.slickUnfilter = function() {\n\n        var _ = this;\n\n        if (_.$slidesCache !== null) {\n\n            _.unload();\n\n            _.$slideTrack.children(this.options.slide).detach();\n\n            _.$slidesCache.appendTo(_.$slideTrack);\n\n            _.reinit();\n\n        }\n\n    };\n\n    Slick.prototype.unload = function() {\n\n        var _ = this;\n\n        $('.slick-cloned', _.$slider).remove();\n\n        if (_.$dots) {\n            _.$dots.remove();\n        }\n\n        if (_.$prevArrow && _.htmlExpr.test(_.options.prevArrow)) {\n            _.$prevArrow.remove();\n        }\n\n        if (_.$nextArrow && _.htmlExpr.test(_.options.nextArrow)) {\n            _.$nextArrow.remove();\n        }\n\n        _.$slides\n            .removeClass('slick-slide slick-active slick-visible slick-current')\n            .attr('aria-hidden', 'true')\n            .css('width', '');\n\n    };\n\n    Slick.prototype.unslick = function(fromBreakpoint) {\n\n        var _ = this;\n        _.$slider.trigger('unslick', [_, fromBreakpoint]);\n        _.destroy();\n\n    };\n\n    Slick.prototype.updateArrows = function() {\n\n        var _ = this,\n            centerOffset;\n\n        centerOffset = Math.floor(_.options.slidesToShow / 2);\n\n        if ( _.options.arrows === true &&\n            _.slideCount > _.options.slidesToShow &&\n            !_.options.infinite ) {\n\n            _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n            _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n\n            if (_.currentSlide === 0) {\n\n                _.$prevArrow.addClass('slick-disabled').attr('aria-disabled', 'true');\n                _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n\n            } else if (_.currentSlide >= _.slideCount - _.options.slidesToShow && _.options.centerMode === false) {\n\n                _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');\n                _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n\n            } else if (_.currentSlide >= _.slideCount - 1 && _.options.centerMode === true) {\n\n                _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');\n                _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.updateDots = function() {\n\n        var _ = this;\n\n        if (_.$dots !== null) {\n\n            _.$dots\n                .find('li')\n                    .removeClass('slick-active')\n                    .end();\n\n            _.$dots\n                .find('li')\n                .eq(Math.floor(_.currentSlide / _.options.slidesToScroll))\n                .addClass('slick-active');\n\n        }\n\n    };\n\n    Slick.prototype.visibility = function() {\n\n        var _ = this;\n\n        if ( _.options.autoplay ) {\n\n            if ( document[_.hidden] ) {\n\n                _.interrupted = true;\n\n            } else {\n\n                _.interrupted = false;\n\n            }\n\n        }\n\n    };\n\n    $.fn.slick = function() {\n        var _ = this,\n            opt = arguments[0],\n            args = Array.prototype.slice.call(arguments, 1),\n            l = _.length,\n            i,\n            ret;\n        for (i = 0; i < l; i++) {\n            if (typeof opt == 'object' || typeof opt == 'undefined')\n                _[i].slick = new Slick(_[i], opt);\n            else\n                ret = _[i].slick[opt].apply(_[i].slick, args);\n            if (typeof ret != 'undefined') return ret;\n        }\n        return _;\n    };\n\n}));\n","//     Underscore.js 1.8.3\n//     http://underscorejs.org\n//     (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Underscore may be freely distributed under the MIT license.\n\n(function() {\n\n  // Baseline setup\n  // --------------\n\n  // Establish the root object, `window` in the browser, or `exports` on the server.\n  var root = this;\n\n  // Save the previous value of the `_` variable.\n  var previousUnderscore = root._;\n\n  // Save bytes in the minified (but not gzipped) version:\n  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;\n\n  // Create quick reference variables for speed access to core prototypes.\n  var\n    push             = ArrayProto.push,\n    slice            = ArrayProto.slice,\n    toString         = ObjProto.toString,\n    hasOwnProperty   = ObjProto.hasOwnProperty;\n\n  // All **ECMAScript 5** native function implementations that we hope to use\n  // are declared here.\n  var\n    nativeIsArray      = Array.isArray,\n    nativeKeys         = Object.keys,\n    nativeBind         = FuncProto.bind,\n    nativeCreate       = Object.create;\n\n  // Naked function reference for surrogate-prototype-swapping.\n  var Ctor = function(){};\n\n  // Create a safe reference to the Underscore object for use below.\n  var _ = function(obj) {\n    if (obj instanceof _) return obj;\n    if (!(this instanceof _)) return new _(obj);\n    this._wrapped = obj;\n  };\n\n  // Export the Underscore object for **Node.js**, with\n  // backwards-compatibility for the old `require()` API. If we're in\n  // the browser, add `_` as a global object.\n  if (typeof exports !== 'undefined') {\n    if (typeof module !== 'undefined' && module.exports) {\n      exports = module.exports = _;\n    }\n    exports._ = _;\n  } else {\n    root._ = _;\n  }\n\n  // Current version.\n  _.VERSION = '1.8.3';\n\n  // Internal function that returns an efficient (for current engines) version\n  // of the passed-in callback, to be repeatedly applied in other Underscore\n  // functions.\n  var optimizeCb = function(func, context, argCount) {\n    if (context === void 0) return func;\n    switch (argCount == null ? 3 : argCount) {\n      case 1: return function(value) {\n        return func.call(context, value);\n      };\n      case 2: return function(value, other) {\n        return func.call(context, value, other);\n      };\n      case 3: return function(value, index, collection) {\n        return func.call(context, value, index, collection);\n      };\n      case 4: return function(accumulator, value, index, collection) {\n        return func.call(context, accumulator, value, index, collection);\n      };\n    }\n    return function() {\n      return func.apply(context, arguments);\n    };\n  };\n\n  // A mostly-internal function to generate callbacks that can be applied\n  // to each element in a collection, returning the desired result — either\n  // identity, an arbitrary callback, a property matcher, or a property accessor.\n  var cb = function(value, context, argCount) {\n    if (value == null) return _.identity;\n    if (_.isFunction(value)) return optimizeCb(value, context, argCount);\n    if (_.isObject(value)) return _.matcher(value);\n    return _.property(value);\n  };\n  _.iteratee = function(value, context) {\n    return cb(value, context, Infinity);\n  };\n\n  // An internal function for creating assigner functions.\n  var createAssigner = function(keysFunc, undefinedOnly) {\n    return function(obj) {\n      var length = arguments.length;\n      if (length < 2 || obj == null) return obj;\n      for (var index = 1; index < length; index++) {\n        var source = arguments[index],\n            keys = keysFunc(source),\n            l = keys.length;\n        for (var i = 0; i < l; i++) {\n          var key = keys[i];\n          if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];\n        }\n      }\n      return obj;\n    };\n  };\n\n  // An internal function for creating a new object that inherits from another.\n  var baseCreate = function(prototype) {\n    if (!_.isObject(prototype)) return {};\n    if (nativeCreate) return nativeCreate(prototype);\n    Ctor.prototype = prototype;\n    var result = new Ctor;\n    Ctor.prototype = null;\n    return result;\n  };\n\n  var property = function(key) {\n    return function(obj) {\n      return obj == null ? void 0 : obj[key];\n    };\n  };\n\n  // Helper for collection methods to determine whether a collection\n  // should be iterated as an array or as an object\n  // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n  // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\n  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n  var getLength = property('length');\n  var isArrayLike = function(collection) {\n    var length = getLength(collection);\n    return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;\n  };\n\n  // Collection Functions\n  // --------------------\n\n  // The cornerstone, an `each` implementation, aka `forEach`.\n  // Handles raw objects in addition to array-likes. Treats all\n  // sparse array-likes as if they were dense.\n  _.each = _.forEach = function(obj, iteratee, context) {\n    iteratee = optimizeCb(iteratee, context);\n    var i, length;\n    if (isArrayLike(obj)) {\n      for (i = 0, length = obj.length; i < length; i++) {\n        iteratee(obj[i], i, obj);\n      }\n    } else {\n      var keys = _.keys(obj);\n      for (i = 0, length = keys.length; i < length; i++) {\n        iteratee(obj[keys[i]], keys[i], obj);\n      }\n    }\n    return obj;\n  };\n\n  // Return the results of applying the iteratee to each element.\n  _.map = _.collect = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length,\n        results = Array(length);\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      results[index] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  };\n\n  // Create a reducing function iterating left or right.\n  function createReduce(dir) {\n    // Optimized iterator function as using arguments.length\n    // in the main function will deoptimize the, see #1991.\n    function iterator(obj, iteratee, memo, keys, index, length) {\n      for (; index >= 0 && index < length; index += dir) {\n        var currentKey = keys ? keys[index] : index;\n        memo = iteratee(memo, obj[currentKey], currentKey, obj);\n      }\n      return memo;\n    }\n\n    return function(obj, iteratee, memo, context) {\n      iteratee = optimizeCb(iteratee, context, 4);\n      var keys = !isArrayLike(obj) && _.keys(obj),\n          length = (keys || obj).length,\n          index = dir > 0 ? 0 : length - 1;\n      // Determine the initial value if none is provided.\n      if (arguments.length < 3) {\n        memo = obj[keys ? keys[index] : index];\n        index += dir;\n      }\n      return iterator(obj, iteratee, memo, keys, index, length);\n    };\n  }\n\n  // **Reduce** builds up a single result from a list of values, aka `inject`,\n  // or `foldl`.\n  _.reduce = _.foldl = _.inject = createReduce(1);\n\n  // The right-associative version of reduce, also known as `foldr`.\n  _.reduceRight = _.foldr = createReduce(-1);\n\n  // Return the first value which passes a truth test. Aliased as `detect`.\n  _.find = _.detect = function(obj, predicate, context) {\n    var key;\n    if (isArrayLike(obj)) {\n      key = _.findIndex(obj, predicate, context);\n    } else {\n      key = _.findKey(obj, predicate, context);\n    }\n    if (key !== void 0 && key !== -1) return obj[key];\n  };\n\n  // Return all the elements that pass a truth test.\n  // Aliased as `select`.\n  _.filter = _.select = function(obj, predicate, context) {\n    var results = [];\n    predicate = cb(predicate, context);\n    _.each(obj, function(value, index, list) {\n      if (predicate(value, index, list)) results.push(value);\n    });\n    return results;\n  };\n\n  // Return all the elements for which a truth test fails.\n  _.reject = function(obj, predicate, context) {\n    return _.filter(obj, _.negate(cb(predicate)), context);\n  };\n\n  // Determine whether all of the elements match a truth test.\n  // Aliased as `all`.\n  _.every = _.all = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (!predicate(obj[currentKey], currentKey, obj)) return false;\n    }\n    return true;\n  };\n\n  // Determine if at least one element in the object matches a truth test.\n  // Aliased as `any`.\n  _.some = _.any = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (predicate(obj[currentKey], currentKey, obj)) return true;\n    }\n    return false;\n  };\n\n  // Determine if the array or object contains a given item (using `===`).\n  // Aliased as `includes` and `include`.\n  _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {\n    if (!isArrayLike(obj)) obj = _.values(obj);\n    if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n    return _.indexOf(obj, item, fromIndex) >= 0;\n  };\n\n  // Invoke a method (with arguments) on every item in a collection.\n  _.invoke = function(obj, method) {\n    var args = slice.call(arguments, 2);\n    var isFunc = _.isFunction(method);\n    return _.map(obj, function(value) {\n      var func = isFunc ? method : value[method];\n      return func == null ? func : func.apply(value, args);\n    });\n  };\n\n  // Convenience version of a common use case of `map`: fetching a property.\n  _.pluck = function(obj, key) {\n    return _.map(obj, _.property(key));\n  };\n\n  // Convenience version of a common use case of `filter`: selecting only objects\n  // containing specific `key:value` pairs.\n  _.where = function(obj, attrs) {\n    return _.filter(obj, _.matcher(attrs));\n  };\n\n  // Convenience version of a common use case of `find`: getting the first object\n  // containing specific `key:value` pairs.\n  _.findWhere = function(obj, attrs) {\n    return _.find(obj, _.matcher(attrs));\n  };\n\n  // Return the maximum element (or element-based computation).\n  _.max = function(obj, iteratee, context) {\n    var result = -Infinity, lastComputed = -Infinity,\n        value, computed;\n    if (iteratee == null && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value > result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index, list) {\n        computed = iteratee(value, index, list);\n        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\n          result = value;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Return the minimum element (or element-based computation).\n  _.min = function(obj, iteratee, context) {\n    var result = Infinity, lastComputed = Infinity,\n        value, computed;\n    if (iteratee == null && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value < result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index, list) {\n        computed = iteratee(value, index, list);\n        if (computed < lastComputed || computed === Infinity && result === Infinity) {\n          result = value;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Shuffle a collection, using the modern version of the\n  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n  _.shuffle = function(obj) {\n    var set = isArrayLike(obj) ? obj : _.values(obj);\n    var length = set.length;\n    var shuffled = Array(length);\n    for (var index = 0, rand; index < length; index++) {\n      rand = _.random(0, index);\n      if (rand !== index) shuffled[index] = shuffled[rand];\n      shuffled[rand] = set[index];\n    }\n    return shuffled;\n  };\n\n  // Sample **n** random values from a collection.\n  // If **n** is not specified, returns a single random element.\n  // The internal `guard` argument allows it to work with `map`.\n  _.sample = function(obj, n, guard) {\n    if (n == null || guard) {\n      if (!isArrayLike(obj)) obj = _.values(obj);\n      return obj[_.random(obj.length - 1)];\n    }\n    return _.shuffle(obj).slice(0, Math.max(0, n));\n  };\n\n  // Sort the object's values by a criterion produced by an iteratee.\n  _.sortBy = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    return _.pluck(_.map(obj, function(value, index, list) {\n      return {\n        value: value,\n        index: index,\n        criteria: iteratee(value, index, list)\n      };\n    }).sort(function(left, right) {\n      var a = left.criteria;\n      var b = right.criteria;\n      if (a !== b) {\n        if (a > b || a === void 0) return 1;\n        if (a < b || b === void 0) return -1;\n      }\n      return left.index - right.index;\n    }), 'value');\n  };\n\n  // An internal function used for aggregate \"group by\" operations.\n  var group = function(behavior) {\n    return function(obj, iteratee, context) {\n      var result = {};\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index) {\n        var key = iteratee(value, index, obj);\n        behavior(result, value, key);\n      });\n      return result;\n    };\n  };\n\n  // Groups the object's values by a criterion. Pass either a string attribute\n  // to group by, or a function that returns the criterion.\n  _.groupBy = group(function(result, value, key) {\n    if (_.has(result, key)) result[key].push(value); else result[key] = [value];\n  });\n\n  // Indexes the object's values by a criterion, similar to `groupBy`, but for\n  // when you know that your index values will be unique.\n  _.indexBy = group(function(result, value, key) {\n    result[key] = value;\n  });\n\n  // Counts instances of an object that group by a certain criterion. Pass\n  // either a string attribute to count by, or a function that returns the\n  // criterion.\n  _.countBy = group(function(result, value, key) {\n    if (_.has(result, key)) result[key]++; else result[key] = 1;\n  });\n\n  // Safely create a real, live array from anything iterable.\n  _.toArray = function(obj) {\n    if (!obj) return [];\n    if (_.isArray(obj)) return slice.call(obj);\n    if (isArrayLike(obj)) return _.map(obj, _.identity);\n    return _.values(obj);\n  };\n\n  // Return the number of elements in an object.\n  _.size = function(obj) {\n    if (obj == null) return 0;\n    return isArrayLike(obj) ? obj.length : _.keys(obj).length;\n  };\n\n  // Split a collection into two arrays: one whose elements all satisfy the given\n  // predicate, and one whose elements all do not satisfy the predicate.\n  _.partition = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var pass = [], fail = [];\n    _.each(obj, function(value, key, obj) {\n      (predicate(value, key, obj) ? pass : fail).push(value);\n    });\n    return [pass, fail];\n  };\n\n  // Array Functions\n  // ---------------\n\n  // Get the first element of an array. Passing **n** will return the first N\n  // values in the array. Aliased as `head` and `take`. The **guard** check\n  // allows it to work with `_.map`.\n  _.first = _.head = _.take = function(array, n, guard) {\n    if (array == null) return void 0;\n    if (n == null || guard) return array[0];\n    return _.initial(array, array.length - n);\n  };\n\n  // Returns everything but the last entry of the array. Especially useful on\n  // the arguments object. Passing **n** will return all the values in\n  // the array, excluding the last N.\n  _.initial = function(array, n, guard) {\n    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n  };\n\n  // Get the last element of an array. Passing **n** will return the last N\n  // values in the array.\n  _.last = function(array, n, guard) {\n    if (array == null) return void 0;\n    if (n == null || guard) return array[array.length - 1];\n    return _.rest(array, Math.max(0, array.length - n));\n  };\n\n  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\n  // Especially useful on the arguments object. Passing an **n** will return\n  // the rest N values in the array.\n  _.rest = _.tail = _.drop = function(array, n, guard) {\n    return slice.call(array, n == null || guard ? 1 : n);\n  };\n\n  // Trim out all falsy values from an array.\n  _.compact = function(array) {\n    return _.filter(array, _.identity);\n  };\n\n  // Internal implementation of a recursive `flatten` function.\n  var flatten = function(input, shallow, strict, startIndex) {\n    var output = [], idx = 0;\n    for (var i = startIndex || 0, length = getLength(input); i < length; i++) {\n      var value = input[i];\n      if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {\n        //flatten current level of array or arguments object\n        if (!shallow) value = flatten(value, shallow, strict);\n        var j = 0, len = value.length;\n        output.length += len;\n        while (j < len) {\n          output[idx++] = value[j++];\n        }\n      } else if (!strict) {\n        output[idx++] = value;\n      }\n    }\n    return output;\n  };\n\n  // Flatten out an array, either recursively (by default), or just one level.\n  _.flatten = function(array, shallow) {\n    return flatten(array, shallow, false);\n  };\n\n  // Return a version of the array that does not contain the specified value(s).\n  _.without = function(array) {\n    return _.difference(array, slice.call(arguments, 1));\n  };\n\n  // Produce a duplicate-free version of the array. If the array has already\n  // been sorted, you have the option of using a faster algorithm.\n  // Aliased as `unique`.\n  _.uniq = _.unique = function(array, isSorted, iteratee, context) {\n    if (!_.isBoolean(isSorted)) {\n      context = iteratee;\n      iteratee = isSorted;\n      isSorted = false;\n    }\n    if (iteratee != null) iteratee = cb(iteratee, context);\n    var result = [];\n    var seen = [];\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var value = array[i],\n          computed = iteratee ? iteratee(value, i, array) : value;\n      if (isSorted) {\n        if (!i || seen !== computed) result.push(value);\n        seen = computed;\n      } else if (iteratee) {\n        if (!_.contains(seen, computed)) {\n          seen.push(computed);\n          result.push(value);\n        }\n      } else if (!_.contains(result, value)) {\n        result.push(value);\n      }\n    }\n    return result;\n  };\n\n  // Produce an array that contains the union: each distinct element from all of\n  // the passed-in arrays.\n  _.union = function() {\n    return _.uniq(flatten(arguments, true, true));\n  };\n\n  // Produce an array that contains every item shared between all the\n  // passed-in arrays.\n  _.intersection = function(array) {\n    var result = [];\n    var argsLength = arguments.length;\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var item = array[i];\n      if (_.contains(result, item)) continue;\n      for (var j = 1; j < argsLength; j++) {\n        if (!_.contains(arguments[j], item)) break;\n      }\n      if (j === argsLength) result.push(item);\n    }\n    return result;\n  };\n\n  // Take the difference between one array and a number of other arrays.\n  // Only the elements present in just the first array will remain.\n  _.difference = function(array) {\n    var rest = flatten(arguments, true, true, 1);\n    return _.filter(array, function(value){\n      return !_.contains(rest, value);\n    });\n  };\n\n  // Zip together multiple lists into a single array -- elements that share\n  // an index go together.\n  _.zip = function() {\n    return _.unzip(arguments);\n  };\n\n  // Complement of _.zip. Unzip accepts an array of arrays and groups\n  // each array's elements on shared indices\n  _.unzip = function(array) {\n    var length = array && _.max(array, getLength).length || 0;\n    var result = Array(length);\n\n    for (var index = 0; index < length; index++) {\n      result[index] = _.pluck(array, index);\n    }\n    return result;\n  };\n\n  // Converts lists into objects. Pass either a single array of `[key, value]`\n  // pairs, or two parallel arrays of the same length -- one of keys, and one of\n  // the corresponding values.\n  _.object = function(list, values) {\n    var result = {};\n    for (var i = 0, length = getLength(list); i < length; i++) {\n      if (values) {\n        result[list[i]] = values[i];\n      } else {\n        result[list[i][0]] = list[i][1];\n      }\n    }\n    return result;\n  };\n\n  // Generator function to create the findIndex and findLastIndex functions\n  function createPredicateIndexFinder(dir) {\n    return function(array, predicate, context) {\n      predicate = cb(predicate, context);\n      var length = getLength(array);\n      var index = dir > 0 ? 0 : length - 1;\n      for (; index >= 0 && index < length; index += dir) {\n        if (predicate(array[index], index, array)) return index;\n      }\n      return -1;\n    };\n  }\n\n  // Returns the first index on an array-like that passes a predicate test\n  _.findIndex = createPredicateIndexFinder(1);\n  _.findLastIndex = createPredicateIndexFinder(-1);\n\n  // Use a comparator function to figure out the smallest index at which\n  // an object should be inserted so as to maintain order. Uses binary search.\n  _.sortedIndex = function(array, obj, iteratee, context) {\n    iteratee = cb(iteratee, context, 1);\n    var value = iteratee(obj);\n    var low = 0, high = getLength(array);\n    while (low < high) {\n      var mid = Math.floor((low + high) / 2);\n      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n    }\n    return low;\n  };\n\n  // Generator function to create the indexOf and lastIndexOf functions\n  function createIndexFinder(dir, predicateFind, sortedIndex) {\n    return function(array, item, idx) {\n      var i = 0, length = getLength(array);\n      if (typeof idx == 'number') {\n        if (dir > 0) {\n            i = idx >= 0 ? idx : Math.max(idx + length, i);\n        } else {\n            length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n        }\n      } else if (sortedIndex && idx && length) {\n        idx = sortedIndex(array, item);\n        return array[idx] === item ? idx : -1;\n      }\n      if (item !== item) {\n        idx = predicateFind(slice.call(array, i, length), _.isNaN);\n        return idx >= 0 ? idx + i : -1;\n      }\n      for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n        if (array[idx] === item) return idx;\n      }\n      return -1;\n    };\n  }\n\n  // Return the position of the first occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  // If the array is large and already in sort order, pass `true`\n  // for **isSorted** to use binary search.\n  _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);\n  _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);\n\n  // Generate an integer Array containing an arithmetic progression. A port of\n  // the native Python `range()` function. See\n  // [the Python documentation](http://docs.python.org/library/functions.html#range).\n  _.range = function(start, stop, step) {\n    if (stop == null) {\n      stop = start || 0;\n      start = 0;\n    }\n    step = step || 1;\n\n    var length = Math.max(Math.ceil((stop - start) / step), 0);\n    var range = Array(length);\n\n    for (var idx = 0; idx < length; idx++, start += step) {\n      range[idx] = start;\n    }\n\n    return range;\n  };\n\n  // Function (ahem) Functions\n  // ------------------\n\n  // Determines whether to execute a function as a constructor\n  // or a normal function with the provided arguments\n  var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {\n    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n    var self = baseCreate(sourceFunc.prototype);\n    var result = sourceFunc.apply(self, args);\n    if (_.isObject(result)) return result;\n    return self;\n  };\n\n  // Create a function bound to a given object (assigning `this`, and arguments,\n  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\n  // available.\n  _.bind = function(func, context) {\n    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));\n    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');\n    var args = slice.call(arguments, 2);\n    var bound = function() {\n      return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));\n    };\n    return bound;\n  };\n\n  // Partially apply a function by creating a version that has had some of its\n  // arguments pre-filled, without changing its dynamic `this` context. _ acts\n  // as a placeholder, allowing any combination of arguments to be pre-filled.\n  _.partial = function(func) {\n    var boundArgs = slice.call(arguments, 1);\n    var bound = function() {\n      var position = 0, length = boundArgs.length;\n      var args = Array(length);\n      for (var i = 0; i < length; i++) {\n        args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];\n      }\n      while (position < arguments.length) args.push(arguments[position++]);\n      return executeBound(func, bound, this, this, args);\n    };\n    return bound;\n  };\n\n  // Bind a number of an object's methods to that object. Remaining arguments\n  // are the method names to be bound. Useful for ensuring that all callbacks\n  // defined on an object belong to it.\n  _.bindAll = function(obj) {\n    var i, length = arguments.length, key;\n    if (length <= 1) throw new Error('bindAll must be passed function names');\n    for (i = 1; i < length; i++) {\n      key = arguments[i];\n      obj[key] = _.bind(obj[key], obj);\n    }\n    return obj;\n  };\n\n  // Memoize an expensive function by storing its results.\n  _.memoize = function(func, hasher) {\n    var memoize = function(key) {\n      var cache = memoize.cache;\n      var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n      if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);\n      return cache[address];\n    };\n    memoize.cache = {};\n    return memoize;\n  };\n\n  // Delays a function for the given number of milliseconds, and then calls\n  // it with the arguments supplied.\n  _.delay = function(func, wait) {\n    var args = slice.call(arguments, 2);\n    return setTimeout(function(){\n      return func.apply(null, args);\n    }, wait);\n  };\n\n  // Defers a function, scheduling it to run after the current call stack has\n  // cleared.\n  _.defer = _.partial(_.delay, _, 1);\n\n  // Returns a function, that, when invoked, will only be triggered at most once\n  // during a given window of time. Normally, the throttled function will run\n  // as much as it can, without ever going more than once per `wait` duration;\n  // but if you'd like to disable the execution on the leading edge, pass\n  // `{leading: false}`. To disable execution on the trailing edge, ditto.\n  _.throttle = function(func, wait, options) {\n    var context, args, result;\n    var timeout = null;\n    var previous = 0;\n    if (!options) options = {};\n    var later = function() {\n      previous = options.leading === false ? 0 : _.now();\n      timeout = null;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    };\n    return function() {\n      var now = _.now();\n      if (!previous && options.leading === false) previous = now;\n      var remaining = wait - (now - previous);\n      context = this;\n      args = arguments;\n      if (remaining <= 0 || remaining > wait) {\n        if (timeout) {\n          clearTimeout(timeout);\n          timeout = null;\n        }\n        previous = now;\n        result = func.apply(context, args);\n        if (!timeout) context = args = null;\n      } else if (!timeout && options.trailing !== false) {\n        timeout = setTimeout(later, remaining);\n      }\n      return result;\n    };\n  };\n\n  // Returns a function, that, as long as it continues to be invoked, will not\n  // be triggered. The function will be called after it stops being called for\n  // N milliseconds. If `immediate` is passed, trigger the function on the\n  // leading edge, instead of the trailing.\n  _.debounce = function(func, wait, immediate) {\n    var timeout, args, context, timestamp, result;\n\n    var later = function() {\n      var last = _.now() - timestamp;\n\n      if (last < wait && last >= 0) {\n        timeout = setTimeout(later, wait - last);\n      } else {\n        timeout = null;\n        if (!immediate) {\n          result = func.apply(context, args);\n          if (!timeout) context = args = null;\n        }\n      }\n    };\n\n    return function() {\n      context = this;\n      args = arguments;\n      timestamp = _.now();\n      var callNow = immediate && !timeout;\n      if (!timeout) timeout = setTimeout(later, wait);\n      if (callNow) {\n        result = func.apply(context, args);\n        context = args = null;\n      }\n\n      return result;\n    };\n  };\n\n  // Returns the first function passed as an argument to the second,\n  // allowing you to adjust arguments, run code before and after, and\n  // conditionally execute the original function.\n  _.wrap = function(func, wrapper) {\n    return _.partial(wrapper, func);\n  };\n\n  // Returns a negated version of the passed-in predicate.\n  _.negate = function(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    };\n  };\n\n  // Returns a function that is the composition of a list of functions, each\n  // consuming the return value of the function that follows.\n  _.compose = function() {\n    var args = arguments;\n    var start = args.length - 1;\n    return function() {\n      var i = start;\n      var result = args[start].apply(this, arguments);\n      while (i--) result = args[i].call(this, result);\n      return result;\n    };\n  };\n\n  // Returns a function that will only be executed on and after the Nth call.\n  _.after = function(times, func) {\n    return function() {\n      if (--times < 1) {\n        return func.apply(this, arguments);\n      }\n    };\n  };\n\n  // Returns a function that will only be executed up to (but not including) the Nth call.\n  _.before = function(times, func) {\n    var memo;\n    return function() {\n      if (--times > 0) {\n        memo = func.apply(this, arguments);\n      }\n      if (times <= 1) func = null;\n      return memo;\n    };\n  };\n\n  // Returns a function that will be executed at most one time, no matter how\n  // often you call it. Useful for lazy initialization.\n  _.once = _.partial(_.before, 2);\n\n  // Object Functions\n  // ----------------\n\n  // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\n  var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n                      'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  function collectNonEnumProps(obj, keys) {\n    var nonEnumIdx = nonEnumerableProps.length;\n    var constructor = obj.constructor;\n    var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;\n\n    // Constructor is a special case.\n    var prop = 'constructor';\n    if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);\n\n    while (nonEnumIdx--) {\n      prop = nonEnumerableProps[nonEnumIdx];\n      if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {\n        keys.push(prop);\n      }\n    }\n  }\n\n  // Retrieve the names of an object's own properties.\n  // Delegates to **ECMAScript 5**'s native `Object.keys`\n  _.keys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    if (nativeKeys) return nativeKeys(obj);\n    var keys = [];\n    for (var key in obj) if (_.has(obj, key)) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve all the property names of an object.\n  _.allKeys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    var keys = [];\n    for (var key in obj) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve the values of an object's properties.\n  _.values = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var values = Array(length);\n    for (var i = 0; i < length; i++) {\n      values[i] = obj[keys[i]];\n    }\n    return values;\n  };\n\n  // Returns the results of applying the iteratee to each element of the object\n  // In contrast to _.map it returns an object\n  _.mapObject = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys =  _.keys(obj),\n          length = keys.length,\n          results = {},\n          currentKey;\n      for (var index = 0; index < length; index++) {\n        currentKey = keys[index];\n        results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n      }\n      return results;\n  };\n\n  // Convert an object into a list of `[key, value]` pairs.\n  _.pairs = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var pairs = Array(length);\n    for (var i = 0; i < length; i++) {\n      pairs[i] = [keys[i], obj[keys[i]]];\n    }\n    return pairs;\n  };\n\n  // Invert the keys and values of an object. The values must be serializable.\n  _.invert = function(obj) {\n    var result = {};\n    var keys = _.keys(obj);\n    for (var i = 0, length = keys.length; i < length; i++) {\n      result[obj[keys[i]]] = keys[i];\n    }\n    return result;\n  };\n\n  // Return a sorted list of the function names available on the object.\n  // Aliased as `methods`\n  _.functions = _.methods = function(obj) {\n    var names = [];\n    for (var key in obj) {\n      if (_.isFunction(obj[key])) names.push(key);\n    }\n    return names.sort();\n  };\n\n  // Extend a given object with all the properties in passed-in object(s).\n  _.extend = createAssigner(_.allKeys);\n\n  // Assigns a given object with all the own properties in the passed-in object(s)\n  // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\n  _.extendOwn = _.assign = createAssigner(_.keys);\n\n  // Returns the first key on an object that passes a predicate test\n  _.findKey = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = _.keys(obj), key;\n    for (var i = 0, length = keys.length; i < length; i++) {\n      key = keys[i];\n      if (predicate(obj[key], key, obj)) return key;\n    }\n  };\n\n  // Return a copy of the object only containing the whitelisted properties.\n  _.pick = function(object, oiteratee, context) {\n    var result = {}, obj = object, iteratee, keys;\n    if (obj == null) return result;\n    if (_.isFunction(oiteratee)) {\n      keys = _.allKeys(obj);\n      iteratee = optimizeCb(oiteratee, context);\n    } else {\n      keys = flatten(arguments, false, false, 1);\n      iteratee = function(value, key, obj) { return key in obj; };\n      obj = Object(obj);\n    }\n    for (var i = 0, length = keys.length; i < length; i++) {\n      var key = keys[i];\n      var value = obj[key];\n      if (iteratee(value, key, obj)) result[key] = value;\n    }\n    return result;\n  };\n\n   // Return a copy of the object without the blacklisted properties.\n  _.omit = function(obj, iteratee, context) {\n    if (_.isFunction(iteratee)) {\n      iteratee = _.negate(iteratee);\n    } else {\n      var keys = _.map(flatten(arguments, false, false, 1), String);\n      iteratee = function(value, key) {\n        return !_.contains(keys, key);\n      };\n    }\n    return _.pick(obj, iteratee, context);\n  };\n\n  // Fill in a given object with default properties.\n  _.defaults = createAssigner(_.allKeys, true);\n\n  // Creates an object that inherits from the given prototype object.\n  // If additional properties are provided then they will be added to the\n  // created object.\n  _.create = function(prototype, props) {\n    var result = baseCreate(prototype);\n    if (props) _.extendOwn(result, props);\n    return result;\n  };\n\n  // Create a (shallow-cloned) duplicate of an object.\n  _.clone = function(obj) {\n    if (!_.isObject(obj)) return obj;\n    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n  };\n\n  // Invokes interceptor with the obj, and then returns obj.\n  // The primary purpose of this method is to \"tap into\" a method chain, in\n  // order to perform operations on intermediate results within the chain.\n  _.tap = function(obj, interceptor) {\n    interceptor(obj);\n    return obj;\n  };\n\n  // Returns whether an object has a given set of `key:value` pairs.\n  _.isMatch = function(object, attrs) {\n    var keys = _.keys(attrs), length = keys.length;\n    if (object == null) return !length;\n    var obj = Object(object);\n    for (var i = 0; i < length; i++) {\n      var key = keys[i];\n      if (attrs[key] !== obj[key] || !(key in obj)) return false;\n    }\n    return true;\n  };\n\n\n  // Internal recursive comparison function for `isEqual`.\n  var eq = function(a, b, aStack, bStack) {\n    // Identical objects are equal. `0 === -0`, but they aren't identical.\n    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n    if (a === b) return a !== 0 || 1 / a === 1 / b;\n    // A strict comparison is necessary because `null == undefined`.\n    if (a == null || b == null) return a === b;\n    // Unwrap any wrapped objects.\n    if (a instanceof _) a = a._wrapped;\n    if (b instanceof _) b = b._wrapped;\n    // Compare `[[Class]]` names.\n    var className = toString.call(a);\n    if (className !== toString.call(b)) return false;\n    switch (className) {\n      // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n      case '[object RegExp]':\n      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n      case '[object String]':\n        // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n        // equivalent to `new String(\"5\")`.\n        return '' + a === '' + b;\n      case '[object Number]':\n        // `NaN`s are equivalent, but non-reflexive.\n        // Object(NaN) is equivalent to NaN\n        if (+a !== +a) return +b !== +b;\n        // An `egal` comparison is performed for other numeric values.\n        return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n      case '[object Date]':\n      case '[object Boolean]':\n        // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n        // millisecond representations. Note that invalid dates with millisecond representations\n        // of `NaN` are not equivalent.\n        return +a === +b;\n    }\n\n    var areArrays = className === '[object Array]';\n    if (!areArrays) {\n      if (typeof a != 'object' || typeof b != 'object') return false;\n\n      // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n      // from different frames are.\n      var aCtor = a.constructor, bCtor = b.constructor;\n      if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&\n                               _.isFunction(bCtor) && bCtor instanceof bCtor)\n                          && ('constructor' in a && 'constructor' in b)) {\n        return false;\n      }\n    }\n    // Assume equality for cyclic structures. The algorithm for detecting cyclic\n    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n    // Initializing stack of traversed objects.\n    // It's done here since we only need them for objects and arrays comparison.\n    aStack = aStack || [];\n    bStack = bStack || [];\n    var length = aStack.length;\n    while (length--) {\n      // Linear search. Performance is inversely proportional to the number of\n      // unique nested structures.\n      if (aStack[length] === a) return bStack[length] === b;\n    }\n\n    // Add the first object to the stack of traversed objects.\n    aStack.push(a);\n    bStack.push(b);\n\n    // Recursively compare objects and arrays.\n    if (areArrays) {\n      // Compare array lengths to determine if a deep comparison is necessary.\n      length = a.length;\n      if (length !== b.length) return false;\n      // Deep compare the contents, ignoring non-numeric properties.\n      while (length--) {\n        if (!eq(a[length], b[length], aStack, bStack)) return false;\n      }\n    } else {\n      // Deep compare objects.\n      var keys = _.keys(a), key;\n      length = keys.length;\n      // Ensure that both objects contain the same number of properties before comparing deep equality.\n      if (_.keys(b).length !== length) return false;\n      while (length--) {\n        // Deep compare each member\n        key = keys[length];\n        if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n      }\n    }\n    // Remove the first object from the stack of traversed objects.\n    aStack.pop();\n    bStack.pop();\n    return true;\n  };\n\n  // Perform a deep comparison to check if two objects are equal.\n  _.isEqual = function(a, b) {\n    return eq(a, b);\n  };\n\n  // Is a given array, string, or object empty?\n  // An \"empty\" object has no enumerable own-properties.\n  _.isEmpty = function(obj) {\n    if (obj == null) return true;\n    if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;\n    return _.keys(obj).length === 0;\n  };\n\n  // Is a given value a DOM element?\n  _.isElement = function(obj) {\n    return !!(obj && obj.nodeType === 1);\n  };\n\n  // Is a given value an array?\n  // Delegates to ECMA5's native Array.isArray\n  _.isArray = nativeIsArray || function(obj) {\n    return toString.call(obj) === '[object Array]';\n  };\n\n  // Is a given variable an object?\n  _.isObject = function(obj) {\n    var type = typeof obj;\n    return type === 'function' || type === 'object' && !!obj;\n  };\n\n  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.\n  _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) {\n    _['is' + name] = function(obj) {\n      return toString.call(obj) === '[object ' + name + ']';\n    };\n  });\n\n  // Define a fallback version of the method in browsers (ahem, IE < 9), where\n  // there isn't any inspectable \"Arguments\" type.\n  if (!_.isArguments(arguments)) {\n    _.isArguments = function(obj) {\n      return _.has(obj, 'callee');\n    };\n  }\n\n  // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,\n  // IE 11 (#1621), and in Safari 8 (#1929).\n  if (typeof /./ != 'function' && typeof Int8Array != 'object') {\n    _.isFunction = function(obj) {\n      return typeof obj == 'function' || false;\n    };\n  }\n\n  // Is a given object a finite number?\n  _.isFinite = function(obj) {\n    return isFinite(obj) && !isNaN(parseFloat(obj));\n  };\n\n  // Is the given value `NaN`? (NaN is the only number which does not equal itself).\n  _.isNaN = function(obj) {\n    return _.isNumber(obj) && obj !== +obj;\n  };\n\n  // Is a given value a boolean?\n  _.isBoolean = function(obj) {\n    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n  };\n\n  // Is a given value equal to null?\n  _.isNull = function(obj) {\n    return obj === null;\n  };\n\n  // Is a given variable undefined?\n  _.isUndefined = function(obj) {\n    return obj === void 0;\n  };\n\n  // Shortcut function for checking if an object has a given property directly\n  // on itself (in other words, not on a prototype).\n  _.has = function(obj, key) {\n    return obj != null && hasOwnProperty.call(obj, key);\n  };\n\n  // Utility Functions\n  // -----------------\n\n  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n  // previous owner. Returns a reference to the Underscore object.\n  _.noConflict = function() {\n    root._ = previousUnderscore;\n    return this;\n  };\n\n  // Keep the identity function around for default iteratees.\n  _.identity = function(value) {\n    return value;\n  };\n\n  // Predicate-generating functions. Often useful outside of Underscore.\n  _.constant = function(value) {\n    return function() {\n      return value;\n    };\n  };\n\n  _.noop = function(){};\n\n  _.property = property;\n\n  // Generates a function for a given object that returns a given property.\n  _.propertyOf = function(obj) {\n    return obj == null ? function(){} : function(key) {\n      return obj[key];\n    };\n  };\n\n  // Returns a predicate for checking whether an object has a given set of\n  // `key:value` pairs.\n  _.matcher = _.matches = function(attrs) {\n    attrs = _.extendOwn({}, attrs);\n    return function(obj) {\n      return _.isMatch(obj, attrs);\n    };\n  };\n\n  // Run a function **n** times.\n  _.times = function(n, iteratee, context) {\n    var accum = Array(Math.max(0, n));\n    iteratee = optimizeCb(iteratee, context, 1);\n    for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n    return accum;\n  };\n\n  // Return a random integer between min and max (inclusive).\n  _.random = function(min, max) {\n    if (max == null) {\n      max = min;\n      min = 0;\n    }\n    return min + Math.floor(Math.random() * (max - min + 1));\n  };\n\n  // A (possibly faster) way to get the current timestamp as an integer.\n  _.now = Date.now || function() {\n    return new Date().getTime();\n  };\n\n   // List of HTML entities for escaping.\n  var escapeMap = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#x27;',\n    '`': '&#x60;'\n  };\n  var unescapeMap = _.invert(escapeMap);\n\n  // Functions for escaping and unescaping strings to/from HTML interpolation.\n  var createEscaper = function(map) {\n    var escaper = function(match) {\n      return map[match];\n    };\n    // Regexes for identifying a key that needs to be escaped\n    var source = '(?:' + _.keys(map).join('|') + ')';\n    var testRegexp = RegExp(source);\n    var replaceRegexp = RegExp(source, 'g');\n    return function(string) {\n      string = string == null ? '' : '' + string;\n      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n    };\n  };\n  _.escape = createEscaper(escapeMap);\n  _.unescape = createEscaper(unescapeMap);\n\n  // If the value of the named `property` is a function then invoke it with the\n  // `object` as context; otherwise, return it.\n  _.result = function(object, property, fallback) {\n    var value = object == null ? void 0 : object[property];\n    if (value === void 0) {\n      value = fallback;\n    }\n    return _.isFunction(value) ? value.call(object) : value;\n  };\n\n  // Generate a unique integer id (unique within the entire client session).\n  // Useful for temporary DOM ids.\n  var idCounter = 0;\n  _.uniqueId = function(prefix) {\n    var id = ++idCounter + '';\n    return prefix ? prefix + id : id;\n  };\n\n  // By default, Underscore uses ERB-style template delimiters, change the\n  // following template settings to use alternative delimiters.\n  _.templateSettings = {\n    evaluate    : /<%([\\s\\S]+?)%>/g,\n    interpolate : /<%=([\\s\\S]+?)%>/g,\n    escape      : /<%-([\\s\\S]+?)%>/g\n  };\n\n  // When customizing `templateSettings`, if you don't want to define an\n  // interpolation, evaluation or escaping regex, we need one that is\n  // guaranteed not to match.\n  var noMatch = /(.)^/;\n\n  // Certain characters need to be escaped so that they can be put into a\n  // string literal.\n  var escapes = {\n    \"'\":      \"'\",\n    '\\\\':     '\\\\',\n    '\\r':     'r',\n    '\\n':     'n',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  var escaper = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\n  var escapeChar = function(match) {\n    return '\\\\' + escapes[match];\n  };\n\n  // JavaScript micro-templating, similar to John Resig's implementation.\n  // Underscore templating handles arbitrary delimiters, preserves whitespace,\n  // and correctly escapes quotes within interpolated code.\n  // NB: `oldSettings` only exists for backwards compatibility.\n  _.template = function(text, settings, oldSettings) {\n    if (!settings && oldSettings) settings = oldSettings;\n    settings = _.defaults({}, settings, _.templateSettings);\n\n    // Combine delimiters into one regular expression via alternation.\n    var matcher = RegExp([\n      (settings.escape || noMatch).source,\n      (settings.interpolate || noMatch).source,\n      (settings.evaluate || noMatch).source\n    ].join('|') + '|$', 'g');\n\n    // Compile the template source, escaping string literals appropriately.\n    var index = 0;\n    var source = \"__p+='\";\n    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n      source += text.slice(index, offset).replace(escaper, escapeChar);\n      index = offset + match.length;\n\n      if (escape) {\n        source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n      } else if (interpolate) {\n        source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n      } else if (evaluate) {\n        source += \"';\\n\" + evaluate + \"\\n__p+='\";\n      }\n\n      // Adobe VMs need the match returned to produce the correct offest.\n      return match;\n    });\n    source += \"';\\n\";\n\n    // If a variable is not specified, place data values in local scope.\n    if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\n\n    source = \"var __t,__p='',__j=Array.prototype.join,\" +\n      \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n      source + 'return __p;\\n';\n\n    try {\n      var render = new Function(settings.variable || 'obj', '_', source);\n    } catch (e) {\n      e.source = source;\n      throw e;\n    }\n\n    var template = function(data) {\n      return render.call(this, data, _);\n    };\n\n    // Provide the compiled source as a convenience for precompilation.\n    var argument = settings.variable || 'obj';\n    template.source = 'function(' + argument + '){\\n' + source + '}';\n\n    return template;\n  };\n\n  // Add a \"chain\" function. Start chaining a wrapped Underscore object.\n  _.chain = function(obj) {\n    var instance = _(obj);\n    instance._chain = true;\n    return instance;\n  };\n\n  // OOP\n  // ---------------\n  // If Underscore is called as a function, it returns a wrapped object that\n  // can be used OO-style. This wrapper holds altered versions of all the\n  // underscore functions. Wrapped objects may be chained.\n\n  // Helper function to continue chaining intermediate results.\n  var result = function(instance, obj) {\n    return instance._chain ? _(obj).chain() : obj;\n  };\n\n  // Add your own custom functions to the Underscore object.\n  _.mixin = function(obj) {\n    _.each(_.functions(obj), function(name) {\n      var func = _[name] = obj[name];\n      _.prototype[name] = function() {\n        var args = [this._wrapped];\n        push.apply(args, arguments);\n        return result(this, func.apply(_, args));\n      };\n    });\n  };\n\n  // Add all of the Underscore functions to the wrapper object.\n  _.mixin(_);\n\n  // Add all mutator Array functions to the wrapper.\n  _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      var obj = this._wrapped;\n      method.apply(obj, arguments);\n      if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];\n      return result(this, obj);\n    };\n  });\n\n  // Add all accessor Array functions to the wrapper.\n  _.each(['concat', 'join', 'slice'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      return result(this, method.apply(this._wrapped, arguments));\n    };\n  });\n\n  // Extracts the result from a wrapped and chained object.\n  _.prototype.value = function() {\n    return this._wrapped;\n  };\n\n  // Provide unwrapping proxy for some methods used in engine operations\n  // such as arithmetic and JSON stringification.\n  _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\n\n  _.prototype.toString = function() {\n    return '' + this._wrapped;\n  };\n\n  // AMD registration happens at the end for compatibility with AMD loaders\n  // that may not enforce next-turn semantics on modules. Even though general\n  // practice for AMD registration is to be anonymous, underscore registers\n  // as a named module because, like jQuery, it is a base library that is\n  // popular enough to be bundled in a third party lib, but not be part of\n  // an AMD load request. Those cases could generate an error when an\n  // anonymous define() is called outside of a loader request.\n  if (typeof define === 'function' && define.amd) {\n    define('underscore', [], function() {\n      return _;\n    });\n  }\n}.call(this));\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","// Chosen 1.6.1\n// https://github.com/harvesthq/chosen\n//\n// Copyright (c) Harvest\n//\n// Permission is hereby granted, free of charge, to any person\n// obtaining a copy of this software and associated documentation\n// files (the \"Software\"), to deal in the Software without\n// restriction, including without limitation the rights to use,\n// copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the\n// Software is furnished to do so, subject to the following\n// conditions:\n//\n// The above copyright notice and this permission notice shall be\n// included in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n// OTHER DEALINGS IN THE SOFTWARE.\n\nimport jQuery from 'jquery';\n\n(function() {\n  var $, AbstractChosen, Chosen, SelectParser, _ref,\n    __hasProp = {}.hasOwnProperty,\n    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };\n\n  SelectParser = (function() {\n    function SelectParser() {\n      this.options_index = 0;\n      this.parsed = [];\n    }\n\n    SelectParser.prototype.add_node = function(child) {\n      if (child.nodeName.toUpperCase() === \"OPTGROUP\") {\n        return this.add_group(child);\n      } else {\n        return this.add_option(child);\n      }\n    };\n\n    SelectParser.prototype.add_group = function(group) {\n      var group_position, option, _i, _len, _ref, _results;\n      group_position = this.parsed.length;\n      this.parsed.push({\n        array_index: group_position,\n        group: true,\n        label: this.escapeExpression(group.label),\n        title: group.title ? group.title : void 0,\n        children: 0,\n        disabled: group.disabled,\n        classes: group.className\n      });\n      _ref = group.childNodes;\n      _results = [];\n      for (_i = 0, _len = _ref.length; _i < _len; _i++) {\n        option = _ref[_i];\n        _results.push(this.add_option(option, group_position, group.disabled));\n      }\n      return _results;\n    };\n\n    SelectParser.prototype.add_option = function(option, group_position, group_disabled) {\n      if (option.nodeName.toUpperCase() === \"OPTION\") {\n        if (option.text !== \"\") {\n          if (group_position != null) {\n            this.parsed[group_position].children += 1;\n          }\n          this.parsed.push({\n            array_index: this.parsed.length,\n            options_index: this.options_index,\n            value: option.value,\n            text: option.text,\n            html: option.innerHTML,\n            title: option.title ? option.title : void 0,\n            selected: option.selected,\n            disabled: group_disabled === true ? group_disabled : option.disabled,\n            group_array_index: group_position,\n            group_label: group_position != null ? this.parsed[group_position].label : null,\n            classes: option.className,\n            style: option.style.cssText\n          });\n        } else {\n          this.parsed.push({\n            array_index: this.parsed.length,\n            options_index: this.options_index,\n            empty: true\n          });\n        }\n        return this.options_index += 1;\n      }\n    };\n\n    SelectParser.prototype.escapeExpression = function(text) {\n      var map, unsafe_chars;\n      if ((text == null) || text === false) {\n        return \"\";\n      }\n      if (!/[\\&\\<\\>\\\"\\'\\`]/.test(text)) {\n        return text;\n      }\n      map = {\n        \"<\": \"&lt;\",\n        \">\": \"&gt;\",\n        '\"': \"&quot;\",\n        \"'\": \"&#x27;\",\n        \"`\": \"&#x60;\"\n      };\n      unsafe_chars = /&(?!\\w+;)|[\\<\\>\\\"\\'\\`]/g;\n      return text.replace(unsafe_chars, function(chr) {\n        return map[chr] || \"&amp;\";\n      });\n    };\n\n    return SelectParser;\n\n  })();\n\n  SelectParser.select_to_array = function(select) {\n    var child, parser, _i, _len, _ref;\n    parser = new SelectParser();\n    _ref = select.childNodes;\n    for (_i = 0, _len = _ref.length; _i < _len; _i++) {\n      child = _ref[_i];\n      parser.add_node(child);\n    }\n    return parser.parsed;\n  };\n\n  AbstractChosen = (function() {\n    function AbstractChosen(form_field, options) {\n      this.form_field = form_field;\n      this.options = options != null ? options : {};\n      if (!AbstractChosen.browser_is_supported()) {\n        return;\n      }\n      this.is_multiple = this.form_field.multiple;\n      this.set_default_text();\n      this.set_default_values();\n      this.setup();\n      this.set_up_html();\n      this.register_observers();\n      this.on_ready();\n    }\n\n    AbstractChosen.prototype.set_default_values = function() {\n      var _this = this;\n      this.click_test_action = function(evt) {\n        return _this.test_active_click(evt);\n      };\n      this.activate_action = function(evt) {\n        return _this.activate_field(evt);\n      };\n      this.active_field = false;\n      this.mouse_on_container = false;\n      this.results_showing = false;\n      this.result_highlighted = null;\n      this.allow_single_deselect = (this.options.allow_single_deselect != null) && (this.form_field.options[0] != null) && this.form_field.options[0].text === \"\" ? this.options.allow_single_deselect : false;\n      this.disable_search_threshold = this.options.disable_search_threshold || 0;\n      this.disable_search = this.options.disable_search || false;\n      this.enable_split_word_search = this.options.enable_split_word_search != null ? this.options.enable_split_word_search : true;\n      this.group_search = this.options.group_search != null ? this.options.group_search : true;\n      this.search_contains = this.options.search_contains || false;\n      this.single_backstroke_delete = this.options.single_backstroke_delete != null ? this.options.single_backstroke_delete : true;\n      this.max_selected_options = this.options.max_selected_options || Infinity;\n      this.inherit_select_classes = this.options.inherit_select_classes || false;\n      this.display_selected_options = this.options.display_selected_options != null ? this.options.display_selected_options : true;\n      this.display_disabled_options = this.options.display_disabled_options != null ? this.options.display_disabled_options : true;\n      this.include_group_label_in_selected = this.options.include_group_label_in_selected || false;\n      this.max_shown_results = this.options.max_shown_results || Number.POSITIVE_INFINITY;\n      return this.case_sensitive_search = this.options.case_sensitive_search || false;\n    };\n\n    AbstractChosen.prototype.set_default_text = function() {\n      if (this.form_field.getAttribute(\"data-placeholder\")) {\n        this.default_text = this.form_field.getAttribute(\"data-placeholder\");\n      } else if (this.is_multiple) {\n        this.default_text = this.options.placeholder_text_multiple || this.options.placeholder_text || AbstractChosen.default_multiple_text;\n      } else {\n        this.default_text = this.options.placeholder_text_single || this.options.placeholder_text || AbstractChosen.default_single_text;\n      }\n      return this.results_none_found = this.form_field.getAttribute(\"data-no_results_text\") || this.options.no_results_text || AbstractChosen.default_no_result_text;\n    };\n\n    AbstractChosen.prototype.choice_label = function(item) {\n      if (this.include_group_label_in_selected && (item.group_label != null)) {\n        return \"<b class='group-name'>\" + item.group_label + \"</b>\" + item.html;\n      } else {\n        return item.html;\n      }\n    };\n\n    AbstractChosen.prototype.mouse_enter = function() {\n      return this.mouse_on_container = true;\n    };\n\n    AbstractChosen.prototype.mouse_leave = function() {\n      return this.mouse_on_container = false;\n    };\n\n    AbstractChosen.prototype.input_focus = function(evt) {\n      var _this = this;\n      if (this.is_multiple) {\n        if (!this.active_field) {\n          return setTimeout((function() {\n            return _this.container_mousedown();\n          }), 50);\n        }\n      } else {\n        if (!this.active_field) {\n          return this.activate_field();\n        }\n      }\n    };\n\n    AbstractChosen.prototype.input_blur = function(evt) {\n      var _this = this;\n      if (!this.mouse_on_container) {\n        this.active_field = false;\n        return setTimeout((function() {\n          return _this.blur_test();\n        }), 100);\n      }\n    };\n\n    AbstractChosen.prototype.results_option_build = function(options) {\n      var content, data, data_content, shown_results, _i, _len, _ref;\n      content = '';\n      shown_results = 0;\n      _ref = this.results_data;\n      for (_i = 0, _len = _ref.length; _i < _len; _i++) {\n        data = _ref[_i];\n        data_content = '';\n        if (data.group) {\n          data_content = this.result_add_group(data);\n        } else {\n          data_content = this.result_add_option(data);\n        }\n        if (data_content !== '') {\n          shown_results++;\n          content += data_content;\n        }\n        if (options != null ? options.first : void 0) {\n          if (data.selected && this.is_multiple) {\n            this.choice_build(data);\n          } else if (data.selected && !this.is_multiple) {\n            this.single_set_selected_text(this.choice_label(data));\n          }\n        }\n        if (shown_results >= this.max_shown_results) {\n          break;\n        }\n      }\n      return content;\n    };\n\n    AbstractChosen.prototype.result_add_option = function(option) {\n      var classes, option_el;\n      if (!option.search_match) {\n        return '';\n      }\n      if (!this.include_option_in_results(option)) {\n        return '';\n      }\n      classes = [];\n      if (!option.disabled && !(option.selected && this.is_multiple)) {\n        classes.push(\"active-result\");\n      }\n      if (option.disabled && !(option.selected && this.is_multiple)) {\n        classes.push(\"disabled-result\");\n      }\n      if (option.selected) {\n        classes.push(\"result-selected\");\n      }\n      if (option.group_array_index != null) {\n        classes.push(\"group-option\");\n      }\n      if (option.classes !== \"\") {\n        classes.push(option.classes);\n      }\n      option_el = document.createElement(\"li\");\n      option_el.className = classes.join(\" \");\n      option_el.style.cssText = option.style;\n      option_el.setAttribute(\"data-option-array-index\", option.array_index);\n      option_el.innerHTML = option.search_text;\n      if (option.title) {\n        option_el.title = option.title;\n      }\n      return this.outerHTML(option_el);\n    };\n\n    AbstractChosen.prototype.result_add_group = function(group) {\n      var classes, group_el;\n      if (!(group.search_match || group.group_match)) {\n        return '';\n      }\n      if (!(group.active_options > 0)) {\n        return '';\n      }\n      classes = [];\n      classes.push(\"group-result\");\n      if (group.classes) {\n        classes.push(group.classes);\n      }\n      group_el = document.createElement(\"li\");\n      group_el.className = classes.join(\" \");\n      group_el.innerHTML = group.search_text;\n      if (group.title) {\n        group_el.title = group.title;\n      }\n      return this.outerHTML(group_el);\n    };\n\n    AbstractChosen.prototype.results_update_field = function() {\n      this.set_default_text();\n      if (!this.is_multiple) {\n        this.results_reset_cleanup();\n      }\n      this.result_clear_highlight();\n      this.results_build();\n      if (this.results_showing) {\n        return this.winnow_results();\n      }\n    };\n\n    AbstractChosen.prototype.reset_single_select_options = function() {\n      var result, _i, _len, _ref, _results;\n      _ref = this.results_data;\n      _results = [];\n      for (_i = 0, _len = _ref.length; _i < _len; _i++) {\n        result = _ref[_i];\n        if (result.selected) {\n          _results.push(result.selected = false);\n        } else {\n          _results.push(void 0);\n        }\n      }\n      return _results;\n    };\n\n    AbstractChosen.prototype.results_toggle = function() {\n      if (this.results_showing) {\n        return this.results_hide();\n      } else {\n        return this.results_show();\n      }\n    };\n\n    AbstractChosen.prototype.results_search = function(evt) {\n      if (this.results_showing) {\n        return this.winnow_results();\n      } else {\n        return this.results_show();\n      }\n    };\n\n    AbstractChosen.prototype.winnow_results = function() {\n      var escapedSearchText, option, regex, results, results_group, searchText, startpos, text, zregex, _i, _len, _ref;\n      this.no_results_clear();\n      results = 0;\n      searchText = this.get_search_text();\n      escapedSearchText = searchText.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, \"\\\\$&\");\n      zregex = new RegExp(escapedSearchText, 'i');\n      regex = this.get_search_regex(escapedSearchText);\n      _ref = this.results_data;\n      for (_i = 0, _len = _ref.length; _i < _len; _i++) {\n        option = _ref[_i];\n        option.search_match = false;\n        results_group = null;\n        if (this.include_option_in_results(option)) {\n          if (option.group) {\n            option.group_match = false;\n            option.active_options = 0;\n          }\n          if ((option.group_array_index != null) && this.results_data[option.group_array_index]) {\n            results_group = this.results_data[option.group_array_index];\n            if (results_group.active_options === 0 && results_group.search_match) {\n              results += 1;\n            }\n            results_group.active_options += 1;\n          }\n          option.search_text = option.group ? option.label : option.html;\n          if (!(option.group && !this.group_search)) {\n            option.search_match = this.search_string_match(option.search_text, regex);\n            if (option.search_match && !option.group) {\n              results += 1;\n            }\n            if (option.search_match) {\n              if (searchText.length) {\n                startpos = option.search_text.search(zregex);\n                text = option.search_text.substr(0, startpos + searchText.length) + '</em>' + option.search_text.substr(startpos + searchText.length);\n                option.search_text = text.substr(0, startpos) + '<em>' + text.substr(startpos);\n              }\n              if (results_group != null) {\n                results_group.group_match = true;\n              }\n            } else if ((option.group_array_index != null) && this.results_data[option.group_array_index].search_match) {\n              option.search_match = true;\n            }\n          }\n        }\n      }\n      this.result_clear_highlight();\n      if (results < 1 && searchText.length) {\n        this.update_results_content(\"\");\n        return this.no_results(searchText);\n      } else {\n        this.update_results_content(this.results_option_build());\n        return this.winnow_results_set_highlight();\n      }\n    };\n\n    AbstractChosen.prototype.get_search_regex = function(escaped_search_string) {\n      var regex_anchor, regex_flag;\n      regex_anchor = this.search_contains ? \"\" : \"^\";\n      regex_flag = this.case_sensitive_search ? \"\" : \"i\";\n      return new RegExp(regex_anchor + escaped_search_string, regex_flag);\n    };\n\n    AbstractChosen.prototype.search_string_match = function(search_string, regex) {\n      var part, parts, _i, _len;\n      if (regex.test(search_string)) {\n        return true;\n      } else if (this.enable_split_word_search && (search_string.indexOf(\" \") >= 0 || search_string.indexOf(\"[\") === 0)) {\n        parts = search_string.replace(/\\[|\\]/g, \"\").split(\" \");\n        if (parts.length) {\n          for (_i = 0, _len = parts.length; _i < _len; _i++) {\n            part = parts[_i];\n            if (regex.test(part)) {\n              return true;\n            }\n          }\n        }\n      }\n    };\n\n    AbstractChosen.prototype.choices_count = function() {\n      var option, _i, _len, _ref;\n      if (this.selected_option_count != null) {\n        return this.selected_option_count;\n      }\n      this.selected_option_count = 0;\n      _ref = this.form_field.options;\n      for (_i = 0, _len = _ref.length; _i < _len; _i++) {\n        option = _ref[_i];\n        if (option.selected) {\n          this.selected_option_count += 1;\n        }\n      }\n      return this.selected_option_count;\n    };\n\n    AbstractChosen.prototype.choices_click = function(evt) {\n      evt.preventDefault();\n      if (!(this.results_showing || this.is_disabled)) {\n        return this.results_show();\n      }\n    };\n\n    AbstractChosen.prototype.keyup_checker = function(evt) {\n      var stroke, _ref;\n      stroke = (_ref = evt.which) != null ? _ref : evt.keyCode;\n      this.search_field_scale();\n      switch (stroke) {\n        case 8:\n          if (this.is_multiple && this.backstroke_length < 1 && this.choices_count() > 0) {\n            return this.keydown_backstroke();\n          } else if (!this.pending_backstroke) {\n            this.result_clear_highlight();\n            return this.results_search();\n          }\n          break;\n        case 13:\n          evt.preventDefault();\n          if (this.results_showing) {\n            return this.result_select(evt);\n          }\n          break;\n        case 27:\n          if (this.results_showing) {\n            this.results_hide();\n          }\n          return true;\n        case 9:\n        case 38:\n        case 40:\n        case 16:\n        case 91:\n        case 17:\n        case 18:\n          break;\n        default:\n          return this.results_search();\n      }\n    };\n\n    AbstractChosen.prototype.clipboard_event_checker = function(evt) {\n      var _this = this;\n      return setTimeout((function() {\n        return _this.results_search();\n      }), 50);\n    };\n\n    AbstractChosen.prototype.container_width = function() {\n      if (this.options.width != null) {\n        return this.options.width;\n      } else {\n        return \"\" + this.form_field.offsetWidth + \"px\";\n      }\n    };\n\n    AbstractChosen.prototype.include_option_in_results = function(option) {\n      if (this.is_multiple && (!this.display_selected_options && option.selected)) {\n        return false;\n      }\n      if (!this.display_disabled_options && option.disabled) {\n        return false;\n      }\n      if (option.empty) {\n        return false;\n      }\n      return true;\n    };\n\n    AbstractChosen.prototype.search_results_touchstart = function(evt) {\n      this.touch_started = true;\n      return this.search_results_mouseover(evt);\n    };\n\n    AbstractChosen.prototype.search_results_touchmove = function(evt) {\n      this.touch_started = false;\n      return this.search_results_mouseout(evt);\n    };\n\n    AbstractChosen.prototype.search_results_touchend = function(evt) {\n      if (this.touch_started) {\n        return this.search_results_mouseup(evt);\n      }\n    };\n\n    AbstractChosen.prototype.outerHTML = function(element) {\n      var tmp;\n      if (element.outerHTML) {\n        return element.outerHTML;\n      }\n      tmp = document.createElement(\"div\");\n      tmp.appendChild(element);\n      return tmp.innerHTML;\n    };\n\n    AbstractChosen.browser_is_supported = function() {\n      if (\"Microsoft Internet Explorer\" === window.navigator.appName) {\n        return document.documentMode >= 8;\n      }\n      if (/iP(od|hone)/i.test(window.navigator.userAgent) || /IEMobile/i.test(window.navigator.userAgent) || /Windows Phone/i.test(window.navigator.userAgent) || /BlackBerry/i.test(window.navigator.userAgent) || /BB10/i.test(window.navigator.userAgent) || /Android.*Mobile/i.test(window.navigator.userAgent)) {\n        return false;\n      }\n      return true;\n    };\n\n    AbstractChosen.default_multiple_text = \"Select Some Options\";\n\n    AbstractChosen.default_single_text = \"Select an Option\";\n\n    AbstractChosen.default_no_result_text = \"No results match\";\n\n    return AbstractChosen;\n\n  })();\n\n  $ = jQuery;\n\n  $.fn.extend({\n    chosen: function(options) {\n      if (!AbstractChosen.browser_is_supported()) {\n        return this;\n      }\n      return this.each(function(input_field) {\n        var $this, chosen;\n        $this = $(this);\n        chosen = $this.data('chosen');\n        if (options === 'destroy') {\n          if (chosen instanceof Chosen) {\n            chosen.destroy();\n          }\n          return;\n        }\n        if (!(chosen instanceof Chosen)) {\n          $this.data('chosen', new Chosen(this, options));\n        }\n      });\n    }\n  });\n\n  Chosen = (function(_super) {\n    __extends(Chosen, _super);\n\n    function Chosen() {\n      _ref = Chosen.__super__.constructor.apply(this, arguments);\n      return _ref;\n    }\n\n    Chosen.prototype.setup = function() {\n      this.form_field_jq = $(this.form_field);\n      this.current_selectedIndex = this.form_field.selectedIndex;\n      return this.is_rtl = this.form_field_jq.hasClass(\"chosen-rtl\");\n    };\n\n    Chosen.prototype.set_up_html = function() {\n      var container_classes, container_props;\n      container_classes = [\"chosen-container\"];\n      container_classes.push(\"chosen-container-\" + (this.is_multiple ? \"multi\" : \"single\"));\n      if (this.inherit_select_classes && this.form_field.className) {\n        container_classes.push(this.form_field.className);\n      }\n      if (this.is_rtl) {\n        container_classes.push(\"chosen-rtl\");\n      }\n      container_props = {\n        'class': container_classes.join(' '),\n        'style': \"width: \" + (this.container_width()) + \";\",\n        'title': this.form_field.title\n      };\n      if (this.form_field.id.length) {\n        container_props.id = this.form_field.id.replace(/[^\\w]/g, '_') + \"_chosen\";\n      }\n      this.container = $(\"<div />\", container_props);\n      if (this.is_multiple) {\n        this.container.html('<ul class=\"chosen-choices\"><li class=\"search-field\"><input type=\"text\" value=\"' + this.default_text + '\" class=\"default\" autocomplete=\"off\" style=\"width:25px;\" /></li></ul><div class=\"chosen-drop\"><ul class=\"chosen-results\"></ul></div>');\n      } else {\n        this.container.html('<a class=\"chosen-single chosen-default\"><span>' + this.default_text + '</span><div><b></b></div></a><div class=\"chosen-drop\"><div class=\"chosen-search\"><input type=\"text\" autocomplete=\"off\" /></div><ul class=\"chosen-results\"></ul></div>');\n      }\n      this.form_field_jq.hide().after(this.container);\n      this.dropdown = this.container.find('div.chosen-drop').first();\n      this.search_field = this.container.find('input').first();\n      this.search_results = this.container.find('ul.chosen-results').first();\n      this.search_field_scale();\n      this.search_no_results = this.container.find('li.no-results').first();\n      if (this.is_multiple) {\n        this.search_choices = this.container.find('ul.chosen-choices').first();\n        this.search_container = this.container.find('li.search-field').first();\n      } else {\n        this.search_container = this.container.find('div.chosen-search').first();\n        this.selected_item = this.container.find('.chosen-single').first();\n      }\n      this.results_build();\n      this.set_tab_index();\n      return this.set_label_behavior();\n    };\n\n    Chosen.prototype.on_ready = function() {\n      return this.form_field_jq.trigger(\"chosen:ready\", {\n        chosen: this\n      });\n    };\n\n    Chosen.prototype.register_observers = function() {\n      var _this = this;\n      this.container.bind('touchstart.chosen', function(evt) {\n        _this.container_mousedown(evt);\n        return evt.preventDefault();\n      });\n      this.container.bind('touchend.chosen', function(evt) {\n        _this.container_mouseup(evt);\n        return evt.preventDefault();\n      });\n      this.container.bind('mousedown.chosen', function(evt) {\n        _this.container_mousedown(evt);\n      });\n      this.container.bind('mouseup.chosen', function(evt) {\n        _this.container_mouseup(evt);\n      });\n      this.container.bind('mouseenter.chosen', function(evt) {\n        _this.mouse_enter(evt);\n      });\n      this.container.bind('mouseleave.chosen', function(evt) {\n        _this.mouse_leave(evt);\n      });\n      this.search_results.bind('mouseup.chosen', function(evt) {\n        _this.search_results_mouseup(evt);\n      });\n      this.search_results.bind('mouseover.chosen', function(evt) {\n        _this.search_results_mouseover(evt);\n      });\n      this.search_results.bind('mouseout.chosen', function(evt) {\n        _this.search_results_mouseout(evt);\n      });\n      this.search_results.bind('mousewheel.chosen DOMMouseScroll.chosen', function(evt) {\n        _this.search_results_mousewheel(evt);\n      });\n      this.search_results.bind('touchstart.chosen', function(evt) {\n        _this.search_results_touchstart(evt);\n      });\n      this.search_results.bind('touchmove.chosen', function(evt) {\n        _this.search_results_touchmove(evt);\n      });\n      this.search_results.bind('touchend.chosen', function(evt) {\n        _this.search_results_touchend(evt);\n      });\n      this.form_field_jq.bind(\"chosen:updated.chosen\", function(evt) {\n        _this.results_update_field(evt);\n      });\n      this.form_field_jq.bind(\"chosen:activate.chosen\", function(evt) {\n        _this.activate_field(evt);\n      });\n      this.form_field_jq.bind(\"chosen:open.chosen\", function(evt) {\n        _this.container_mousedown(evt);\n      });\n      this.form_field_jq.bind(\"chosen:close.chosen\", function(evt) {\n        _this.input_blur(evt);\n      });\n      this.search_field.bind('blur.chosen', function(evt) {\n        _this.input_blur(evt);\n      });\n      this.search_field.bind('keyup.chosen', function(evt) {\n        _this.keyup_checker(evt);\n      });\n      this.search_field.bind('keydown.chosen', function(evt) {\n        _this.keydown_checker(evt);\n      });\n      this.search_field.bind('focus.chosen', function(evt) {\n        _this.input_focus(evt);\n      });\n      this.search_field.bind('cut.chosen', function(evt) {\n        _this.clipboard_event_checker(evt);\n      });\n      this.search_field.bind('paste.chosen', function(evt) {\n        _this.clipboard_event_checker(evt);\n      });\n      if (this.is_multiple) {\n        return this.search_choices.bind('click.chosen', function(evt) {\n          _this.choices_click(evt);\n        });\n      } else {\n        return this.container.bind('click.chosen', function(evt) {\n          evt.preventDefault();\n        });\n      }\n    };\n\n    Chosen.prototype.destroy = function() {\n      $(this.container[0].ownerDocument).unbind(\"click.chosen\", this.click_test_action);\n      if (this.search_field[0].tabIndex) {\n        this.form_field_jq[0].tabIndex = this.search_field[0].tabIndex;\n      }\n      this.container.remove();\n      this.form_field_jq.removeData('chosen');\n      return this.form_field_jq.show();\n    };\n\n    Chosen.prototype.search_field_disabled = function() {\n      this.is_disabled = this.form_field_jq[0].disabled;\n      if (this.is_disabled) {\n        this.container.addClass('chosen-disabled');\n        this.search_field[0].disabled = true;\n        if (!this.is_multiple) {\n          this.selected_item.unbind(\"focus.chosen\", this.activate_action);\n        }\n        return this.close_field();\n      } else {\n        this.container.removeClass('chosen-disabled');\n        this.search_field[0].disabled = false;\n        if (!this.is_multiple) {\n          return this.selected_item.bind(\"focus.chosen\", this.activate_action);\n        }\n      }\n    };\n\n    Chosen.prototype.container_mousedown = function(evt) {\n      if (!this.is_disabled) {\n        if (evt && evt.type === \"mousedown\" && !this.results_showing) {\n          evt.preventDefault();\n        }\n        if (!((evt != null) && ($(evt.target)).hasClass(\"search-choice-close\"))) {\n          if (!this.active_field) {\n            if (this.is_multiple) {\n              this.search_field.val(\"\");\n            }\n            $(this.container[0].ownerDocument).bind('click.chosen', this.click_test_action);\n            this.results_show();\n          } else if (!this.is_multiple && evt && (($(evt.target)[0] === this.selected_item[0]) || $(evt.target).parents(\"a.chosen-single\").length)) {\n            evt.preventDefault();\n            this.results_toggle();\n          }\n          return this.activate_field();\n        }\n      }\n    };\n\n    Chosen.prototype.container_mouseup = function(evt) {\n      if (evt.target.nodeName === \"ABBR\" && !this.is_disabled) {\n        return this.results_reset(evt);\n      }\n    };\n\n    Chosen.prototype.search_results_mousewheel = function(evt) {\n      var delta;\n      if (evt.originalEvent) {\n        delta = evt.originalEvent.deltaY || -evt.originalEvent.wheelDelta || evt.originalEvent.detail;\n      }\n      if (delta != null) {\n        evt.preventDefault();\n        if (evt.type === 'DOMMouseScroll') {\n          delta = delta * 40;\n        }\n        return this.search_results.scrollTop(delta + this.search_results.scrollTop());\n      }\n    };\n\n    Chosen.prototype.blur_test = function(evt) {\n      if (!this.active_field && this.container.hasClass(\"chosen-container-active\")) {\n        return this.close_field();\n      }\n    };\n\n    Chosen.prototype.close_field = function() {\n      $(this.container[0].ownerDocument).unbind(\"click.chosen\", this.click_test_action);\n      this.active_field = false;\n      this.results_hide();\n      this.container.removeClass(\"chosen-container-active\");\n      this.clear_backstroke();\n      this.show_search_field_default();\n      return this.search_field_scale();\n    };\n\n    Chosen.prototype.activate_field = function() {\n      this.container.addClass(\"chosen-container-active\");\n      this.active_field = true;\n      this.search_field.val(this.search_field.val());\n      return this.search_field.focus();\n    };\n\n    Chosen.prototype.test_active_click = function(evt) {\n      var active_container;\n      active_container = $(evt.target).closest('.chosen-container');\n      if (active_container.length && this.container[0] === active_container[0]) {\n        return this.active_field = true;\n      } else {\n        return this.close_field();\n      }\n    };\n\n    Chosen.prototype.results_build = function() {\n      this.parsing = true;\n      this.selected_option_count = null;\n      this.results_data = SelectParser.select_to_array(this.form_field);\n      if (this.is_multiple) {\n        this.search_choices.find(\"li.search-choice\").remove();\n      } else if (!this.is_multiple) {\n        this.single_set_selected_text();\n        if (this.disable_search || this.form_field.options.length <= this.disable_search_threshold) {\n          this.search_field[0].readOnly = true;\n          this.container.addClass(\"chosen-container-single-nosearch\");\n        } else {\n          this.search_field[0].readOnly = false;\n          this.container.removeClass(\"chosen-container-single-nosearch\");\n        }\n      }\n      this.update_results_content(this.results_option_build({\n        first: true\n      }));\n      this.search_field_disabled();\n      this.show_search_field_default();\n      this.search_field_scale();\n      return this.parsing = false;\n    };\n\n    Chosen.prototype.result_do_highlight = function(el) {\n      var high_bottom, high_top, maxHeight, visible_bottom, visible_top;\n      if (el.length) {\n        this.result_clear_highlight();\n        this.result_highlight = el;\n        this.result_highlight.addClass(\"highlighted\");\n        maxHeight = parseInt(this.search_results.css(\"maxHeight\"), 10);\n        visible_top = this.search_results.scrollTop();\n        visible_bottom = maxHeight + visible_top;\n        high_top = this.result_highlight.position().top + this.search_results.scrollTop();\n        high_bottom = high_top + this.result_highlight.outerHeight();\n        if (high_bottom >= visible_bottom) {\n          return this.search_results.scrollTop((high_bottom - maxHeight) > 0 ? high_bottom - maxHeight : 0);\n        } else if (high_top < visible_top) {\n          return this.search_results.scrollTop(high_top);\n        }\n      }\n    };\n\n    Chosen.prototype.result_clear_highlight = function() {\n      if (this.result_highlight) {\n        this.result_highlight.removeClass(\"highlighted\");\n      }\n      return this.result_highlight = null;\n    };\n\n    Chosen.prototype.results_show = function() {\n      if (this.is_multiple && this.max_selected_options <= this.choices_count()) {\n        this.form_field_jq.trigger(\"chosen:maxselected\", {\n          chosen: this\n        });\n        return false;\n      }\n      this.container.addClass(\"chosen-with-drop\");\n      this.results_showing = true;\n      this.search_field.focus();\n      this.search_field.val(this.search_field.val());\n      this.winnow_results();\n      return this.form_field_jq.trigger(\"chosen:showing_dropdown\", {\n        chosen: this\n      });\n    };\n\n    Chosen.prototype.update_results_content = function(content) {\n      return this.search_results.html(content);\n    };\n\n    Chosen.prototype.results_hide = function() {\n      if (this.results_showing) {\n        this.result_clear_highlight();\n        this.container.removeClass(\"chosen-with-drop\");\n        this.form_field_jq.trigger(\"chosen:hiding_dropdown\", {\n          chosen: this\n        });\n      }\n      return this.results_showing = false;\n    };\n\n    Chosen.prototype.set_tab_index = function(el) {\n      var ti;\n      if (this.form_field.tabIndex) {\n        ti = this.form_field.tabIndex;\n        this.form_field.tabIndex = -1;\n        return this.search_field[0].tabIndex = ti;\n      }\n    };\n\n    Chosen.prototype.set_label_behavior = function() {\n      var _this = this;\n      this.form_field_label = this.form_field_jq.parents(\"label\");\n      if (!this.form_field_label.length && this.form_field.id.length) {\n        this.form_field_label = $(\"label[for='\" + this.form_field.id + \"']\");\n      }\n      if (this.form_field_label.length > 0) {\n        return this.form_field_label.bind('click.chosen', function(evt) {\n          if (_this.is_multiple) {\n            return _this.container_mousedown(evt);\n          } else {\n            return _this.activate_field();\n          }\n        });\n      }\n    };\n\n    Chosen.prototype.show_search_field_default = function() {\n      if (this.is_multiple && this.choices_count() < 1 && !this.active_field) {\n        this.search_field.val(this.default_text);\n        return this.search_field.addClass(\"default\");\n      } else {\n        this.search_field.val(\"\");\n        return this.search_field.removeClass(\"default\");\n      }\n    };\n\n    Chosen.prototype.search_results_mouseup = function(evt) {\n      var target;\n      target = $(evt.target).hasClass(\"active-result\") ? $(evt.target) : $(evt.target).parents(\".active-result\").first();\n      if (target.length) {\n        this.result_highlight = target;\n        this.result_select(evt);\n        return this.search_field.focus();\n      }\n    };\n\n    Chosen.prototype.search_results_mouseover = function(evt) {\n      var target;\n      target = $(evt.target).hasClass(\"active-result\") ? $(evt.target) : $(evt.target).parents(\".active-result\").first();\n      if (target) {\n        return this.result_do_highlight(target);\n      }\n    };\n\n    Chosen.prototype.search_results_mouseout = function(evt) {\n      if ($(evt.target).hasClass(\"active-result\" || $(evt.target).parents('.active-result').first())) {\n        return this.result_clear_highlight();\n      }\n    };\n\n    Chosen.prototype.choice_build = function(item) {\n      var choice, close_link,\n        _this = this;\n      choice = $('<li />', {\n        \"class\": \"search-choice\"\n      }).html(\"<span>\" + (this.choice_label(item)) + \"</span>\");\n      if (item.disabled) {\n        choice.addClass('search-choice-disabled');\n      } else {\n        close_link = $('<a />', {\n          \"class\": 'search-choice-close',\n          'data-option-array-index': item.array_index\n        });\n        close_link.bind('click.chosen', function(evt) {\n          return _this.choice_destroy_link_click(evt);\n        });\n        choice.append(close_link);\n      }\n      return this.search_container.before(choice);\n    };\n\n    Chosen.prototype.choice_destroy_link_click = function(evt) {\n      evt.preventDefault();\n      evt.stopPropagation();\n      if (!this.is_disabled) {\n        return this.choice_destroy($(evt.target));\n      }\n    };\n\n    Chosen.prototype.choice_destroy = function(link) {\n      if (this.result_deselect(link[0].getAttribute(\"data-option-array-index\"))) {\n        this.show_search_field_default();\n        if (this.is_multiple && this.choices_count() > 0 && this.search_field.val().length < 1) {\n          this.results_hide();\n        }\n        link.parents('li').first().remove();\n        return this.search_field_scale();\n      }\n    };\n\n    Chosen.prototype.results_reset = function() {\n      this.reset_single_select_options();\n      this.form_field.options[0].selected = true;\n      this.single_set_selected_text();\n      this.show_search_field_default();\n      this.results_reset_cleanup();\n      this.form_field_jq.trigger(\"change\");\n      if (this.active_field) {\n        return this.results_hide();\n      }\n    };\n\n    Chosen.prototype.results_reset_cleanup = function() {\n      this.current_selectedIndex = this.form_field.selectedIndex;\n      return this.selected_item.find(\"abbr\").remove();\n    };\n\n    Chosen.prototype.result_select = function(evt) {\n      var high, item;\n      if (this.result_highlight) {\n        high = this.result_highlight;\n        this.result_clear_highlight();\n        if (this.is_multiple && this.max_selected_options <= this.choices_count()) {\n          this.form_field_jq.trigger(\"chosen:maxselected\", {\n            chosen: this\n          });\n          return false;\n        }\n        if (this.is_multiple) {\n          high.removeClass(\"active-result\");\n        } else {\n          this.reset_single_select_options();\n        }\n        high.addClass(\"result-selected\");\n        item = this.results_data[high[0].getAttribute(\"data-option-array-index\")];\n        item.selected = true;\n        this.form_field.options[item.options_index].selected = true;\n        this.selected_option_count = null;\n        if (this.is_multiple) {\n          this.choice_build(item);\n        } else {\n          this.single_set_selected_text(this.choice_label(item));\n        }\n        if (!((evt.metaKey || evt.ctrlKey) && this.is_multiple)) {\n          this.results_hide();\n        }\n        this.show_search_field_default();\n        if (this.is_multiple || this.form_field.selectedIndex !== this.current_selectedIndex) {\n          this.form_field_jq.trigger(\"change\", {\n            'selected': this.form_field.options[item.options_index].value\n          });\n        }\n        this.current_selectedIndex = this.form_field.selectedIndex;\n        evt.preventDefault();\n        return this.search_field_scale();\n      }\n    };\n\n    Chosen.prototype.single_set_selected_text = function(text) {\n      if (text == null) {\n        text = this.default_text;\n      }\n      if (text === this.default_text) {\n        this.selected_item.addClass(\"chosen-default\");\n      } else {\n        this.single_deselect_control_build();\n        this.selected_item.removeClass(\"chosen-default\");\n      }\n      return this.selected_item.find(\"span\").html(text);\n    };\n\n    Chosen.prototype.result_deselect = function(pos) {\n      var result_data;\n      result_data = this.results_data[pos];\n      if (!this.form_field.options[result_data.options_index].disabled) {\n        result_data.selected = false;\n        this.form_field.options[result_data.options_index].selected = false;\n        this.selected_option_count = null;\n        this.result_clear_highlight();\n        if (this.results_showing) {\n          this.winnow_results();\n        }\n        this.form_field_jq.trigger(\"change\", {\n          deselected: this.form_field.options[result_data.options_index].value\n        });\n        this.search_field_scale();\n        return true;\n      } else {\n        return false;\n      }\n    };\n\n    Chosen.prototype.single_deselect_control_build = function() {\n      if (!this.allow_single_deselect) {\n        return;\n      }\n      if (!this.selected_item.find(\"abbr\").length) {\n        this.selected_item.find(\"span\").first().after(\"<abbr class=\\\"search-choice-close\\\"></abbr>\");\n      }\n      return this.selected_item.addClass(\"chosen-single-with-deselect\");\n    };\n\n    Chosen.prototype.get_search_text = function() {\n      return $('<div/>').text($.trim(this.search_field.val())).html();\n    };\n\n    Chosen.prototype.winnow_results_set_highlight = function() {\n      var do_high, selected_results;\n      selected_results = !this.is_multiple ? this.search_results.find(\".result-selected.active-result\") : [];\n      do_high = selected_results.length ? selected_results.first() : this.search_results.find(\".active-result\").first();\n      if (do_high != null) {\n        return this.result_do_highlight(do_high);\n      }\n    };\n\n    Chosen.prototype.no_results = function(terms) {\n      var no_results_html;\n      no_results_html = $('<li class=\"no-results\">' + this.results_none_found + ' \"<span></span>\"</li>');\n      no_results_html.find(\"span\").first().html(terms);\n      this.search_results.append(no_results_html);\n      return this.form_field_jq.trigger(\"chosen:no_results\", {\n        chosen: this\n      });\n    };\n\n    Chosen.prototype.no_results_clear = function() {\n      return this.search_results.find(\".no-results\").remove();\n    };\n\n    Chosen.prototype.keydown_arrow = function() {\n      var next_sib;\n      if (this.results_showing && this.result_highlight) {\n        next_sib = this.result_highlight.nextAll(\"li.active-result\").first();\n        if (next_sib) {\n          return this.result_do_highlight(next_sib);\n        }\n      } else {\n        return this.results_show();\n      }\n    };\n\n    Chosen.prototype.keyup_arrow = function() {\n      var prev_sibs;\n      if (!this.results_showing && !this.is_multiple) {\n        return this.results_show();\n      } else if (this.result_highlight) {\n        prev_sibs = this.result_highlight.prevAll(\"li.active-result\");\n        if (prev_sibs.length) {\n          return this.result_do_highlight(prev_sibs.first());\n        } else {\n          if (this.choices_count() > 0) {\n            this.results_hide();\n          }\n          return this.result_clear_highlight();\n        }\n      }\n    };\n\n    Chosen.prototype.keydown_backstroke = function() {\n      var next_available_destroy;\n      if (this.pending_backstroke) {\n        this.choice_destroy(this.pending_backstroke.find(\"a\").first());\n        return this.clear_backstroke();\n      } else {\n        next_available_destroy = this.search_container.siblings(\"li.search-choice\").last();\n        if (next_available_destroy.length && !next_available_destroy.hasClass(\"search-choice-disabled\")) {\n          this.pending_backstroke = next_available_destroy;\n          if (this.single_backstroke_delete) {\n            return this.keydown_backstroke();\n          } else {\n            return this.pending_backstroke.addClass(\"search-choice-focus\");\n          }\n        }\n      }\n    };\n\n    Chosen.prototype.clear_backstroke = function() {\n      if (this.pending_backstroke) {\n        this.pending_backstroke.removeClass(\"search-choice-focus\");\n      }\n      return this.pending_backstroke = null;\n    };\n\n    Chosen.prototype.keydown_checker = function(evt) {\n      var stroke, _ref1;\n      stroke = (_ref1 = evt.which) != null ? _ref1 : evt.keyCode;\n      this.search_field_scale();\n      if (stroke !== 8 && this.pending_backstroke) {\n        this.clear_backstroke();\n      }\n      switch (stroke) {\n        case 8:\n          this.backstroke_length = this.search_field.val().length;\n          break;\n        case 9:\n          if (this.results_showing && !this.is_multiple) {\n            this.result_select(evt);\n          }\n          this.mouse_on_container = false;\n          break;\n        case 13:\n          if (this.results_showing) {\n            evt.preventDefault();\n          }\n          break;\n        case 32:\n          if (this.disable_search) {\n            evt.preventDefault();\n          }\n          break;\n        case 38:\n          evt.preventDefault();\n          this.keyup_arrow();\n          break;\n        case 40:\n          evt.preventDefault();\n          this.keydown_arrow();\n          break;\n      }\n    };\n\n    Chosen.prototype.search_field_scale = function() {\n      var div, f_width, h, style, style_block, styles, w, _i, _len;\n      if (this.is_multiple) {\n        h = 0;\n        w = 0;\n        style_block = \"position:absolute; left: -1000px; top: -1000px; display:none;\";\n        styles = ['font-size', 'font-style', 'font-weight', 'font-family', 'line-height', 'text-transform', 'letter-spacing'];\n        for (_i = 0, _len = styles.length; _i < _len; _i++) {\n          style = styles[_i];\n          style_block += style + \":\" + this.search_field.css(style) + \";\";\n        }\n        div = $('<div />', {\n          'style': style_block\n        });\n        div.text(this.search_field.val());\n        $('body').append(div);\n        w = div.width() + 25;\n        div.remove();\n        f_width = this.container.outerWidth();\n        if (w > f_width - 10) {\n          w = f_width - 10;\n        }\n        return this.search_field.css({\n          'width': w + 'px'\n        });\n      }\n    };\n\n    return Chosen;\n\n  })(AbstractChosen);\n\n}).call(this);\n","//------------------------------------------------------------------------\n// Applies current <picture> image source as “background-image” on the target wrapper\n//\n// Requires “object-fit” test in Modernizr\n//\n// Example:\n//\n// <div class=\"js-background-image\">\n//   <picture>\n//     <!--[if IE 9]><video style=\"display: none;\"><![endif]-->\n//     <source srcset=\"<%= asset_path(\"dev/800x450.png\") %>\" media=\"(min-width: 400px)\">\n//     <!--[if IE 9]></video><![endif]-->\n//     <img src=\"<%= asset_path(\"dev/400x225.png\") %>\">\n//   </picture>\n// </div>\n//------------------------------------------------------------------------\n'use strict';\nimport Backbone from 'backbone';\n\nvar documentClasses = document.documentElement.className;\n\n// Check for Modernizr “object-fit” classes (most resilient method)\n// We could also check Modernizr.objectfit assuming Modernizr is in the global scope,\n// or we could use CSS.supports('object-fit', 'cover') once it’s fully supported.\nvar supportsObjectFit = documentClasses.indexOf(' object-fit') !== -1;\nvar noObjectFit = documentClasses.indexOf('no-object-fit') !== -1;\n\n// Warn if “object-fit” test is not being performed by Modernizr\nif ( !supportsObjectFit && !noObjectFit ) {\n  console.warn('Modernizr is missing the “object-fit” test');\n}\n\nvar bgPicture = Backbone.View.extend({\n  initialize: function() {\n    // Don’t run if “object-fit” is supported\n    if ( supportsObjectFit ) {\n      return false; \n    }\n\n    var self = this;\n\n    // Save reference to <img> tag\n    this.img = this.el.getElementsByTagName('img')[0];\n\n    // Check if “currentSrc” is supported\n    this.isModern = typeof this.img.currentSrc !== 'undefined';\n\n    // Bind to onload event, which will fire whenever the source changes\n    this.img.onload = function() {\n      self.update('onload');\n    }\n\n    // Update if “onload” event fired before this script was parsed\n    // (we know this happened if “currentSrc” has already been set)\n    if ( this.isModern && this.img.currentSrc.length ) {\n      this.update('init');\n    }\n    else if ( this.img.src.length ) {\n      this.update('old init');\n    }\n  },\n\n  // Update parent wrapper\n  update: function(msg) {\n    // console.log(msg, 'currentSrc: ' + this.img.currentSrc, 'src: ' + this.img.src);\n    var source = this.isModern ? this.img.currentSrc : this.img.src;\n\n    if ( !source.length ) {\n      this.el.style.backgroundImage = '';\n    }\n    else {\n      this.el.style.backgroundImage = \"url('\" + source + \"')\";\n    }\n  }\n});\n\n// Only run if CSS “object-fit” isn’t supported\nif ( !supportsObjectFit ) {\n  var els = document.querySelectorAll('.js-background-image');\n\n  for ( var i=0, len=els.length; i<len; i++ ) {\n    new bgPicture({ el: els[i] });\n  }\n}\n\nexport default bgPicture;\n","//------------------------------------------------------------------------\n// Custom select helper\n//\n// Wraps all selects in a div so we can style them better, since selects\n// don’t support :before/:after pseudo elements.\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\n\n$(\".js-custom-select\").each(function() {\n  $(this).removeClass('js-custom-select').wrap('<div class=\"js-custom-select\"></div>');\n});\n","//------------------------------------------------------------------------\n// Autosubmit form data on checkbox or radio change\n//\n// NOTE: Avoid using this unless absolutely necessary due to accessibility issues.\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\n\n// Find forms that should auto-submit\n$(\"form[data-autosubmit]\").each( function() {\n  var $this = $(this);\n  var $inputs = $this.find('input[type=\"checkbox\"], input[type=\"radio\"], select');\n\n  if ( $inputs.length ) {\n    // Submit form when inputs are changed\n    $inputs.on('change', function() {\n      $this.submit();\n    });\n  }\n});\n","//------------------------------------------------------------------------\n// User agent string functions\n//\n// Note: UA strings aren’t always 100% accurrate and shouldn’t be relied\n//       upon for critical functionality.\n//------------------------------------------------------------------------\n\"use strict\";\n\nexport default {\n  ua: window.navigator.userAgent,\n\n  // Detect Android, returns version as float number if true\n  // http://www.ainixon.me/how-to-detect-android-version-using-js/\n  isAndroid: function() {\n    var matches = this.ua.match(/Android\\s([0-9\\.]*)/);\n    return matches ? parseFloat(matches[1], 10) : false;\n  },\n\n  // Detect IE, returns version number as integer if true\n  // https://codepen.io/gapcode/pen/vEJNZN/?editors=0010\n  isIE: function() {\n    var msie = this.ua.indexOf('MSIE ');\n    if (msie > 0) {\n      // IE 10 or older\n      return parseInt(this.ua.substring(msie + 5, this.ua.indexOf('.', msie)), 10);\n    }\n\n    var trident = this.ua.indexOf('Trident/');\n    if (trident > 0) {\n      // IE 11\n      var rv = this.ua.indexOf('rv:');\n      return parseInt(this.ua.substring(rv + 3, this.ua.indexOf('.', rv)), 10);\n    }\n\n    var edge = this.ua.indexOf('Edge/');\n    if (edge > 0) {\n      // Edge (IE 12+)\n      return parseInt(this.ua.substring(edge + 5, this.ua.indexOf('.', edge)), 10);\n    }\n\n    // not IE\n    return false;\n  },\n\n  // Detect iOS, returns version number as float if true\n  // Test page https://regex101.com/r/nG7lH4/1\n  isIOS: function() {\n    var matches = this.ua.match(/((\\d+_?){2,3})\\slike\\sMac\\sOS\\sX/);\n    return matches ? parseFloat(matches[1].replace('_','.').replace('_',''), 10) : false;\n  },\n\n  // Detect Samsung Internet browser, boolean\n  isSamsung: function() {\n    return /SamsungBrowser/.test(this.ua);\n  }\n};\n","//------------------------------------------------------------------------\n// Smooth scrolling\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\nimport ua from './user-agent';\n\n// Add custom jQuery easing\n// https://github.com/gdsmith/jquery.easing\n$.extend($.easing, {\n  easeOutExpo: function(x, t, b, c, d) {\n    return (t == d) ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b;\n  }\n});\n\nexport default function( target, speed, isSmooth, callback ) {\n  var hasTargetEl = false;\n  var harTargetPos = false;\n  var targetPos = 0;\n  var $window = $(window);\n  var topPos = $window.scrollTop();\n  var offset = 0;\n  var androidVersion = ua.isAndroid();\n  var isAndroid = !!androidVersion;\n  var isOldAndroid = isAndroid && androidVersion <= 2;\n\n  // If a number was provided, use that as scroll position\n  if ( typeof target == 'number' ) {\n    harTargetPos = true;\n    targetPos = target;\n  }\n  // If a jQuery element was passed, get its top offset\n  else if ( target instanceof $ && target.length ) {\n    hasTargetEl = true;\n    targetPos = Math.floor( target.offset().top );\n  }\n  else {\n    console.warn('Cannot find element to scroll to');\n    return false;\n  }\n\n  // Default to no animation\n  if ( typeof isSmooth == 'undefined' ) {\n    isSmooth = true;\n  }\n\n  // Don't scroll if already at target position\n  if ( topPos == targetPos ) {\n    // Shift focus to target element\n    if ( hasTargetEl ) {\n      // http://www.bignerdranch.com/blog/web-accessibility-skip-navigation-links/\n      target.attr('tabindex', '-1').on('blur focusout', function() {\n        $(this).removeAttr('tabindex');\n      }).focus();// focus on the content container\n    }\n\n    return false;\n  }\n\n  // Smooth scroll if target is an element and not old Android\n  if ( (hasTargetEl || harTargetPos) && isSmooth && !isOldAndroid ) {\n\n    // Animate both html and body for cross-browser compatibility\n    $('html, body').stop(true,true).animate({ scrollTop: targetPos - offset },\n      (typeof speed == 'undefined' ? 800 : speed), 'easeOutExpo',\n      // This animation complete will run twice since we're animating 2 elements\n      function() {\n\n        // Don't run focus on the same element twice\n        if ( hasTargetEl && target.attr('tabindex') !== '-1' ) {\n          // Shift focus to target element\n          // http://www.bignerdranch.com/blog/web-accessibility-skip-navigation-links/\n          target.attr('tabindex', '-1').on('blur focusout', function() {\n            $(this).removeAttr('tabindex');\n          }).focus();// focus on the content container\n        }\n\n        // Remove hash if scroll to top (still shows “#” in URL)\n        if ( $window.scrollTop() <= 1 ) {\n          window.location.hash = '';\n        }\n        // Add hash back to URL after scroll animation complete\n        else if ( hasTargetEl && !!target.attr('id') ) {\n          var targetId = target.attr('id');\n          window.location.hash = targetId;\n        }\n\n        // Optional callback\n        if ( typeof callback !== \"undefined\" ) {\n          callback();\n        }\n      });\n\n    return false;\n  }\n  // Jump to target position\n  else {\n    $window.scrollTop( targetPos );\n  }\n};\n","//------------------------------------------------------------------------\n// Basic form validation\n//\n// Usage Info:\n// • Add “js-validate” to <form>\n// • Add appropriate data-validate value to each input\n//   - data-validate=\"email\"\n//   - data-validate=\"phone\"\n//   - data-validate=\"number\"\n//   - data-validate=\"zip\"\n//   - data-validate=\"notempty\"\n// • Add error message markup inside of <label>\n//     <span class=\"is-hidden\" data-validate=\"error\" role=\"alert\">Please enter a valid email address</span>\n// • Add `data-validate=\"submit\"` to submit button\n//     <button type=\"submit\" data-validate=\"submit\">Submit</button>\n// • Required fields should use `aria-required=\"true\"` when possible, but `required` and `data-validate-required` will also work\n//  • For groups of checkboxes, wrap in <fieldset data-validate-required> and add appropriate `data-validate-group` value (see examples below)\n//    - data-validate-group=\"min-1\"\n//    - data-validate-group=\"max-2\"\n//    - data-validate-group=\"notempty\"\n//  • For groups of radios, wrap in <fieldset role=\"radiogroup\" aria-required=\"true\"> and add appropriate `data-validate-group` value (see examples above)\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\nimport smoothScroll from './smoothScroll';\n\nvar ValidateForm = Backbone.View.extend({\n  events: {\n    'blur [data-validate]': 'validate',// check for errors on blur\n    'change [data-validate]': 'validate',// for selects, radios, and checkboxes\n    'change [data-validate-group] input': 'validateGroup',// for selects, radios, and checkboxes\n    'input input[data-validate]': 'clearError',// hide error while typing\n    'input textarea[data-validate]': 'clearError',// hide error while typing\n    'keypress [data-validate=\"number\"]': 'numberEvent',// prevent non-number characters\n    'submit': 'submitHandler'// validate prior to submitting form\n  },\n\n  initialize: function() {\n    var self = this;\n\n    // Add the “novalidate” attribute to form to disable default browser error messages if using “required” attribute\n    // Note: `prop('novalidate', true)` doesn't work for some reason ¯\\_(ツ)_/¯\n    this.$el.attr('novalidate', 'novalidate');\n\n    // Find error messages\n    this.$errorMsg = this.$el.find('[data-validate=\"error\"]');\n\n    // Submit button\n    this.$submit = this.$el.find('[data-validate=\"submit\"]');\n    this.shouldScroll = !this.$submit.is('[data-no-jump]');\n    this.submitText = this.$submit.text();// initial text\n    this.submittedText = this.$submit.data('validate-success') || false;// text to show on submit\n\n    // Elements that require validation, set to `aria-invalid=\"true\"` on load\n    this.$validateEls = this.$el.find('[data-validate]').not(this.$submit).not(this.$errorMsg);\n\n    // Groups of checkboxes/radios that require validation\n    this.$groups = this.$el.find('[data-validate-group]');\n\n    // Store previously focused checkbox/radio group, validate when focus changes\n    this.$prevGroup = false;\n\n    // Validating every possible email is a fool’s errand and not necessary.\n    // Instead, just check for at least one “@” and “.”\n    // https://davidcel.is/posts/stop-validating-email-addresses-with-regex/\n    this.emailRegex =  /^.+@.+\\..+$/;\n\n    // If more validation is desired, we can check for only one “@”\n    // Based on https://github.com/plataformatec/devise/blob/593ae41f9dac165a404b05cd3abd959245c64908/lib/devise.rb#L109-L113\n    // this.emailRegex =  /^[^@\\s]+@([^@\\s]+\\.)+[^@\\s]+$/;\n\n    // Numeric value test (allows single decimal)\n    this.numericRegex = /^((\\d+)|(\\.\\d+)|(\\d+\\.\\d+))%?$/;\n\n    // Phone number test (very loose, allows everything except line breaks)\n    this.phoneRegex = /^.+$/;\n\n    // Postal code RegEx, allows from 2–12 letters, numbers, spaces, or dashes\n    this.zipRegex = /^[\\w\\d\\- ]{2,12}$/;\n\n    // Using the back button in Firefox and Safari displays a cached page with the submit button still disabled, so we have to manually reenable it.\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=443289\n    // http://stackoverflow.com/a/13123626/\n    $(window).on('pageshow', function(evt) {\n      if ( evt.originalEvent.persisted ) {\n        self.$submit.prop('disabled', false).text(self.submitText);\n      }\n    });\n  },\n\n  isEmail: function(str) {\n    return this.emailRegex.test(str);\n  },\n\n  isNumeric: function(str) {\n    return this.numericRegex.test(str);\n  },\n\n  isPhone: function(str) {\n    return this.phoneRegex.test(str);\n  },\n\n  isZip: function(str) {\n    return this.zipRegex.test(str);\n  },\n\n  isEmpty: function($el) {\n    // Check if checkbox or radio button\n    if ( $el.is('[type=\"checkbox\"]') || $el.is('[type=\"radio\"]') ) {\n      return !$el.is(':checked');\n    }\n    // For all other elements, get the value\n    else {\n      return !$el.val();\n    }\n  },\n\n  isRequired: function($el) {\n    // We can’t apply the “required” attribute or “aria-required=\"true\"” on checkbox inputs, or groups of them, so we have to use the  custom “data-validate-required” attribute\n    // https://github.com/GoogleChrome/accessibility-developer-tools/issues/283\n    return $el.is('[aria-required=\"true\"]') || $el.is('[required]') || $el.is('[data-validate-required]');\n  },\n\n  numberEvent: function(evt) {\n    // Get typed character\n    var key = String.fromCharCode(evt.which);\n    var allowedChars = /[,.0-9%]/;\n\n    // Don't allow non-number characters to be entered\n    if ( !allowedChars.test(key) ) {\n      evt.preventDefault();\n    }\n  },\n\n  // Get label element whose “for” attribute matches current element’s “id” attribute\n  getErrorMsgParent: function($el) {\n    // If element has an id, look for an associated label\n    if ( !!$el.attr('id') ) {\n      return this.$el.find('[for=\"' + $el.attr('id') + '\"]');\n    }\n    // Groups don’t have ids and associated labels, so get error message parent\n    else {\n      var $error = $el.find('[data-validate=\"error\"]');\n      return $error.length ? $error.parent() : false;\n    }\n  },\n\n  // Get error message element associated with form element\n  getErrorMsg: function($el) {\n    return this.getErrorMsgParent($el).find('[data-validate=\"error\"]');\n  },\n\n  // Show an element’s error message and update its “aria-invalid” state\n  showErrorMsg: function($el) {\n    this.getErrorMsg($el).removeClass('is-hidden');\n    $el.addClass('is-invalid').attr('aria-invalid', 'true');\n  },\n\n  // Hide an element’s error message and update its “aria-invalid” state\n  hideErrorMsg: function($el) {\n    this.getErrorMsg($el).addClass('is-hidden');\n    $el.removeClass('is-invalid').attr('aria-invalid', 'false');\n  },\n\n  // Show group error\n  showGroupErroMsg: function($el) {\n    $el.attr('aria-invalid', 'true').find('[data-validate=\"error\"]').removeClass('is-hidden');\n  },\n\n  // Clear group error\n  hideGroupErrorMsg: function($el) {\n    $el.attr('aria-invalid', 'false').find('[data-validate=\"error\"]').addClass('is-hidden');\n  },\n\n  // Toggle error message\n  toggleErrorMsg: function(isValid, $el) {\n    if ( isValid ) {\n      this.hideErrorMsg($el);\n    }\n    else {\n      this.showErrorMsg($el);\n    }\n  },\n\n  // Event handler to hide error messages while typing in text inputs\n  clearError: function(evt) {\n    var $target = $(evt.target);\n    this.hideErrorMsg($target);\n  },\n\n  isFormValid: function() {\n    // Check for required and invalid fields\n    var $invalidEls = this.$validateEls.add(this.$groups).filter('[aria-invalid=\"true\"]');\n\n    return !$invalidEls.length;\n  },\n\n  // Test if element is valid and toggle error msg\n  validateEl: function($el) {\n    var type = $el.data('validate');\n    var val = $el.val();\n\n    // Email\n    if ( type === 'email' ) {\n      this.toggleErrorMsg(this.isEmail(val), $el);\n    }\n\n    // Numbers (allows single decimal and/or % sign)\n    else if ( type === 'number' ) {\n      // Strip commas\n      val = val.replace(/,/g, '');\n      $el.val(val);\n      this.toggleErrorMsg(this.isNumeric(val), $el);\n    }\n\n    // Phone number (allows everything except line breaks)\n    else if ( type === 'phone' ) {\n      this.toggleErrorMsg(this.isPhone(val), $el);\n    }\n\n    // ZIP code (from 2–12 letters, numbers, dashes, or spaces)\n    else if ( type === 'zip' ) {\n      this.toggleErrorMsg(this.isZip(val), $el);\n    }\n\n    // Not empty\n    else if ( type === 'notempty' ) {\n      // TODO: Allow on fieldsets containing radio buttons\n\n      this.toggleErrorMsg(!this.isEmpty($el), $el);\n    }\n  },\n\n  // Event handler to validate elements on blur or change\n  validate: function(evt) {\n    var $target = $(evt.target);\n\n    // Exclude blank optional fields\n    if ( this.isRequired($target) || !this.isEmpty($target) ) {\n      this.validateEl( $(evt.target) );\n    }\n\n    // Reset current group (the elements that trigger this function aren’t part of a group)\n    this.$currentGroup = false;\n  },\n\n  // Validate all single elements\n  validateAll: function() {\n    var self = this;\n\n    this.$validateEls.each( function() {\n      var $this = $(this);\n      // Exclude blank optional fields\n      if ( self.isRequired($this) || !self.isEmpty($this) ) {\n        self.validateEl($this);\n      }\n    });\n  },\n\n  // Validate group when focus leaves (can’t detect blur on fieldsets)\n  validateGroupEl: function($el) {\n    var condition = $el.data('validate-group');\n    var isExact = typeof condition === 'number';\n    var selectedEls = $el.find('input:checked').length;\n\n    // If checked inputs match required number, clear error\n    if ( isExact && condition === selectedEls ) {\n      // console.log('matches exact number');\n      this.hideGroupErrorMsg($el);\n    }\n    // Check condition string\n    else if ( !isExact ) {\n      // “notempty”\n      if ( condition === 'notempty' ) {\n        if ( selectedEls === 0 ) {\n          this.showGroupErroMsg($el)\n        }\n        else {\n          // console.log('valid notempty');\n          this.hideGroupErrorMsg($el);\n        }\n      }\n      // min/max\n      else {\n        condition = condition.split('-');\n\n        if ( condition.length !== 2 ) {\n          console.warn('data-validate-group value is malformed: ' + condition);\n        }\n        else {\n          var type = condition[0];\n          var value = parseInt(condition[1], 10);\n\n          if ( type !== 'min' &&  type !== 'max' ) {\n            console.warn('data-validate-group value is malformed: ' + condition);\n          }\n          // Min\n          else if ( type === \"min\" && selectedEls >= value ) {\n            // console.log('valid min', condition, value);\n            this.hideGroupErrorMsg($el);\n          }\n          // Max\n          else if ( type === \"max\" && selectedEls <= value ) {\n            // console.log('valid max', condition, value);\n            this.hideGroupErrorMsg($el);\n          }\n          // Show error\n          else {\n            this.showGroupErroMsg($el)\n          }\n        }\n      }\n    }\n    // Show error\n    else {\n      this.showGroupErroMsg($el)\n    }\n  },\n\n  // Event handler to validate group on change\n  validateGroup: function(evt) {\n    var $target = $(evt.target);\n    var $currentGroup = $target.closest('[data-validate-group]');\n\n    // Clear error on current group\n    this.hideGroupErrorMsg($currentGroup);\n\n    // If no previous group, set it to current group\n    if ( !this.$prevGroup ) {\n      this.$prevGroup = $currentGroup;\n    }\n    // If group has changed, validate the previous group\n    else if ( !!this.$prevGroup && !$currentGroup.is(this.$prevGroup) ) {\n      this.validateGroupEl( this.$prevGroup );\n\n      // Update previous group\n      this.$prevGroup = $currentGroup;\n    }\n  },\n\n  // Validate all groups\n  validateAllGroups: function() {\n    var self = this;\n\n    this.$groups.each( function() {\n      var $this = $(this);\n\n      // Validate required groups and those with selected items\n      // (non-required groups without any selected items will be ignored)\n      if ( self.isRequired($this) || $this.find(':checked').length ) {\n        self.validateGroupEl($this);\n      }\n    });\n  },\n\n  // Don't allow submit if validation errors are present\n  submitHandler: function(evt) {\n    var self = this;\n\n    // Validate all single elements\n    this.validateAll();\n\n    // Validate all groups\n    this.validateAllGroups();\n\n    // If form is invalid, scroll to first error message\n    if ( !this.isFormValid() ) {\n      // Prevent form submission\n      evt.preventDefault();\n\n      // Add invalid class\n      this.$el.addClass('is-invalid');\n\n      // Find first error message\n      var $errMsg = this.getErrorMsgParent( $('[aria-invalid=\"true\"]').first() );\n\n      // Scroll to first error\n      if ( this.shouldScroll ) {\n        smoothScroll($errMsg, 1000, true);\n      }\n    }\n    // Form is valid\n    else {\n      // Remove invalid class\n      this.$el.removeClass('is-invalid');\n\n      // Disable submit button to prevent multiple submissions\n      this.$submit.prop('disabled', true);\n\n      // Update submit button text if provided\n      if ( !!this.submittedText ) {\n        this.$submit.text( this.submittedText );\n      }\n\n      // Optional: Trigger “form-valid” event for other modules\n      // Backbone.trigger('form-valid', $(evt.target));\n    }\n  }\n});\n\n$('form.js-validate').each(function() {\n  new ValidateForm({el: this});\n});\n","//------------------------------------------------------------------------\n// Smooth scroll jump links\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\nimport smoothScroll from './smoothScroll';\n\nvar JumpLinks = Backbone.View.extend({\n  el: 'body',\n\n  events: {\n    'click a[href^=\"#\"]': 'clickHandler'\n  },\n\n  initialize: function() {\n    var self = this;\n    this.scrollSpeed = 800;// scroll speed in milliseconds\n    this.$window = $(window);\n\n    // Force browser to scroll to top of target element when using the back/forward buttons\n    this.$window.on('hashchange', function(evt) {\n      // Get current hash\n      var hash = evt.originalEvent.newURL.split('#')[1];\n\n      // Scroll to top if no hash\n      if ( !hash ) {\n        self.$window.scrollTop(0);\n      }\n      // Scroll to element with mathcing ID if it exists\n      else {\n        var $target = $('#' + hash);\n\n        if ( $target.length ) {\n          self.$window.scrollTop( $target.offset().top );\n        }\n      }\n    });\n  },\n\n  clickHandler: function(evt) {\n    var $target = $(evt.currentTarget);\n    var shouldJump = typeof $target.attr('data-no-jump') === 'undefined';\n    var shouldClearHash = typeof $target.attr('data-clear-hash') !== 'undefined';\n\n    // Check if link should open in a new window\n    var opensNewWindow = $target.is('[target=\"_blank\"]') || evt.which > 1 || evt.metaKey || evt.ctrlKey || evt.shiftKey || evt.altKey;\n\n    // Ignore links that open in a new window or that have a “data-no-jump” attribute\n    if ( !opensNewWindow && shouldJump ) {\n\n      // Prevent default to stop page jump\n      evt.preventDefault();\n\n      // Find element to scroll to (assumes using “id” attribute, not “name”)\n      var selector = $target.attr('href');\n\n      // Check if href contains only “#”\n      if ( selector === '#' ) {\n        // Scroll to top\n        smoothScroll(0, this.scrollSpeed, true);\n\n        // Remove hash only if one is present\n        if ( window.location.hash.length > 0 ) {\n          if ( history.pushState ) {\n            history.pushState(null, '', window.location.pathname);\n          }\n          else {\n            window.location.hash = '';\n          }\n        }\n      }\n      // Check if target element exists\n      else {\n        var $el = $(selector);\n\n        if ( $el.length ) {\n          // Smooth scroll\n          smoothScroll($el, this.scrollSpeed, true);\n\n          // Shift focus to target element\n          // http://www.bignerdranch.com/blog/web-accessibility-skip-navigation-links/\n          $el.attr('tabindex', '-1').on('blur focusout', function() {\n            $(this).removeAttr('tabindex');\n          }).focus();// focus on the content container\n\n          // Update URL hash after smooth scroll completes\n          // NOTE: Using pushState doesn’t trigger :target styles so only use it when clearing the hash\n          if ( shouldClearHash ) {\n            if ( history.pushState ) {\n              history.pushState(null, '', window.location.pathname);\n            }\n            else {\n              window.location.hash = '';\n            }\n          }\n          // Add hash\n          else {\n            window.location.hash = selector;\n          }\n        }\n        else {\n          console.warn('There is no element matching “' + selector + '” to scroll to');\n        }\n      }\n    }\n  }\n\n});\n\nvar jumpLinks = new JumpLinks();\n","// mailto.js\n\n// Looks for all elements with a \"data-email\" attribute and converts them to mailto links, using the value of that attribute as the email address. Inner HTML is preserved and any occurrences of \"[at]\" are converted to \"@\".\n\n// Exmaple: <span data-email=\"hello[at]threespot.com\">Contact Us</span>\n// Becomes: <a href=\"mailto:hello@threespot.com\">Contact Us</a>\n\n// Works with inner HTML\n// Exmaple: <span data-email=\"hello[at]threespot.com\"><b>hello[at]threespot.com</b></span>\n// Becomes: <a href=\"mailto:hello@threespot.com\"><b>hello@threespot.com</b></a>\n\n'use strict';\nimport $ from 'jquery';\n\n// Find all instances of [data-email] and generate mailto links from obfuscated code\n$('[data-email]').each( function() {\n  var $el = $(this);\n\n  // Generate mailto href\n  var href = 'mailto:' + $el.attr('data-email').replace('[at]', '@');\n\n  // Replace [at] with @ in link text\n  var linkHtml = $el.html();\n  if ( linkHtml.indexOf('[at]') > 0 ) {\n    linkHtml = linkHtml.replace('[at]', '@');\n    $el.html(linkHtml);\n  }\n\n  // Add mailto href to link tags\n  if ( $el.is('a') ) {\n    $el.attr('href', href);\n  }\n  // Create link tag, remove original element\n  else {\n    var $link = $('<a/>', {\n      'href': href,\n      'html': linkHtml\n    });\n\n    // Add classes to generated link if present\n    var classNames = $el.attr('class');\n    if ( !!classNames ) {\n      $link.attr('class', classNames);\n    }\n\n    // Insert link and remove original element\n    $el.before($link).remove();\n  }\n});\n","// Global event emitter\n// Window resize, scroll, and body click\n'use strict';\nimport $ from 'jquery';\nimport _ from 'lodash';\nimport debounce from 'lodash/debounce';\nimport Backbone from 'backbone';\n\nvar Events = _.extend({\n\n  initialize: function() {\n    var self = this;\n    this.$window = $(window);\n    this.$body = $('body');\n    this.scrollTimer = null;\n\n    // Save current dimensions to compare on resize\n    this.oldWidth = this.getWinWidth();\n    this.oldHeight = this.getWinHeight();\n\n    // Add a listener to the window.resize event, pass “this” as the scope\n    this.$window.resize( $.proxy( debounce( this.handleResize, 200 ), this ) );\n\n    // Add keyboard listeners\n    this.$window.on('keydown', function(evt) {\n      self.trigger('keydown', evt);\n    });\n    this.$window.on('keyup', function(evt) {\n      self.trigger('keyup', evt);\n    });\n\n    // Listen to scroll event, debounce by 10ms\n    // this.$window.scroll( $.proxy( debounce( this.handleScroll, 10 ), this ) );\n\n    // Add listener to the body\n    this.$body.on('click', function(evt) {\n      self.trigger('bodyClick', evt);\n    });\n\n    return this;\n  },\n\n  // Disable pointer events on scroll to improve performance\n  // http://www.thecssninja.com/javascript/pointer-events-60fps\n  //\n  // Requires the following CSS:\n  //\n  // .disable-hover {\n  //   pointer-events: none;\n  // }\n  //---------------------------------\n  // disableHover: function() {\n  //   var self = this;\n  //\n  //   clearTimeout( this.scrollTimer );\n  //\n  //   if ( !this.$body.hasClass('disable-hover') ) {\n  //     this.$body.addClass('disable-hover');\n  //   }\n  //\n  //   this.scrollTimer = setTimeout( function() {\n  //     self.$body.removeClass('disable-hover');\n  //   }, 200 );\n  // },\n\n  handleResize: function() {\n    var winWidth = this.getWinWidth();\n    var winHeight = this.getWinHeight();\n\n    var widthChanged = winWidth !== this.oldWidth;\n    var heightChanged = winHeight !== this.oldHeight;\n\n    if ( widthChanged ) {\n      // Emit resize event, pass window width\n      this.trigger('resize', winWidth);\n\n      // Update window width\n      this.oldWidth = winWidth;\n    }\n\n    if ( heightChanged ) {\n      // Emit vertical resize event, pass window height\n      this.trigger('resize-height', winHeight);\n\n      // Update window height\n      this.oldHeight = winHeight;\n    }\n  },\n\n  // handleScroll: function() {\n  //   // Emit scroll event, pass current scroll position\n  //   this.trigger('scroll', this.$window.scrollTop());\n  //\n  //   // Disable pointer events while scrolling\n  //   this.disableHover();\n  // },\n\n  getWinWidth: function() {\n    return this.$window.width();\n  },\n\n  getWinHeight: function() {\n    return this.$window.height();\n  }\n\n}, Backbone.Events );\n\nexport default Events.initialize();\n","//------------------------------------------------------------------------\n// Megamenu functionality for Publication Collection pages\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\nimport events from './events';\n\nvar Megamenu = Backbone.View.extend({\n  events: {\n    \"click .Megamenu-close\": \"toggle\",\n    \"click .Megamenu-open\": \"toggle\",\n    \"change .Megamenu-form-dropdown\": \"changeTab\",\n  },\n\n  initialize: function() {\n    var self = this;\n    var section = '#' + ($('.Megamenu-form-dropdown')[0].value).toString();\n    $(section).addClass('open-section');\n  },\n\n  toggle: function() {\n    $('.Megamenu-content').slideToggle();\n    // $('.Megamenu-content').toggleClass('is-active');\n    $('.Megamenu-open').toggleClass('is-active');\n    $('.Megamenu-close').toggleClass('is-active');\n  },\n\n  changeTab: function() {\n    var section = '#' + ($('.Megamenu-form-dropdown')[0].value).toString();\n    $('.open-section').removeClass('open-section');\n    $(section).addClass('open-section');\n  },\n\n});\n\n// Initialize\n$('.Megamenu').each(function() {\n  var megamenu = new Megamenu({ el: this });\n});\n\n// Return constructor so it can be used by other modules\nexport default Megamenu;\n","//------------------------------------------------------------------------\n// Disable scrolling (used by modals)\n//\n// Requires these styles:\n//\n// /*html*/.js-no-scroll {\n//   height: 100% !important;\n//\n//   body {\n//     height: 100% !important;\n//     overflow: hidden !important;\n//     position: fixed !important;\n//     width: 100% !important;\n//   }\n// }\n//\n//------------------------------------------------------------------------\n// We have to set \"body { position: fixed; }\" to prevent iOS from scrolling when modal is open,\n// which normally causes the browser to scroll back up to the top. To prevent this, we must set\n// inline styles on the body based on the curretn scroll position.\nexport default {\n  _docClasses: document.documentElement.className,\n  _scrollPos: 0,\n\n  _saveScrollPos: function() {\n    this._scrollPos = window.pageYOffset || document.documentElement.scrollTop;\n  },\n\n  // Disable scrolling\n  disable: function() {\n    this._saveScrollPos();\n\n    // Add class to prevent page scrolling (sets fixed position on body)\n    document.documentElement.className = this._docClasses + ' js-no-scroll';\n\n    // Add inline styles if not already at top of page\n    if ( this._scrollPos > 0 ) {\n      document.body.style.height = 'calc(100% + ' + this._scrollPos + 'px)';\n      document.body.style.top = -this._scrollPos + 'px';\n    }\n  },\n\n  // Enable scrolling\n  enable: function() {\n    // Remove js-no-scroll class\n    document.documentElement.className = this._docClasses.replace('js-no-scroll', '');\n\n    // Remove body styles, reset scrolling\n    if ( this._scrollPos > 0 ) {\n      document.body.style.height = '';\n      document.body.style.top = '';\n      window.scrollTo(0, this._scrollPos);\n    }\n  }\n};\n","//------------------------------------------------------------------------\n// Modal windows (for modal toggle buttons, see modal-toggles.js)\n//\n// Note: Progressively enhanced, works with pure CSS thanks to the `:target` pseudo selector\n//\n// Inspired by https://www.smashingmagazine.com/2016/09/building-social-a-case-study-on-progressive-enhancement/#challenge-4-pure-css-modal-box-form-enhanced-with-javascript\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\nimport events from './events';\nimport key from './keycodes';\nimport ua from './user-agent';\nimport scrolling from './freeze-scroll';\n\nvar Modal = Backbone.View.extend({\n  events: {\n    // Events defined in modalEvents()\n  },\n\n  initialize: function() {\n    var self = this;\n    // Use variable to store state instead of creating a model\n    this.isOpen = false;\n    this.$prevFocused = false;\n    this.$window = $(window);\n    this.$body = $('body');\n    this.$document = $('html').add( this.$body );\n    this.$video = false;\n    this.videoIsReady = false;\n\n    // Find close button\n    this.$close = this.$el.find('.Modal-close');\n\n    // Get modal name from data-modal attribute\n    this.name = this.$el.data('modal') || false;\n\n    // If no name, exit\n    if ( !this.name ) {\n      console.warn('Modal window has no “data-modal” value', this.$el);\n      return false;\n    }\n\n    // Find toggles (can have multiple toggles for one modal)\n    this.$toggles = $('[data-modal-toggle=\"' + this.name + '\"]');\n\n    // Get toggle text, use first if multiple\n    this.toggleText = $.trim(this.$toggles.first().text());\n\n    // Modals must be labeled, use toggle text if not defined\n    this.ariaLabel = !!this.$el.attr('aria-label') ? this.$el.attr('aria-label') : this.toggleText;\n\n    // Setup modal window\n    this.setup();\n\n    // Check if modal was opened on load (from hash in URL)\n    if ( window.location.hash.length && window.location.hash.substring(1) == this.name ) {\n      this.open();\n    }\n  },\n\n  setup: function() {\n    // Add ARIA attributes to modal content\n    this.$el.attr({\n      'aria-expanded': 'false',\n      'aria-hidden': 'true',\n      'aria-label': this.ariaLabel,\n      'role': 'dialog',\n      'tabindex': '-1'// disable tabbing until open\n    }).addClass('js-init');\n\n    this.$close.attr('role', 'button');\n\n    // Bind modal events\n    this.modalEvents();\n  },\n\n  modalEvents: function() {\n    var self = this;\n\n    // Close button event\n    this.$close.on('click', function(evt) {\n      self.close(evt);\n    });\n\n    // Hide if click outside of modal\n    this.$body.on('click.modal', function(evt) {\n      var $target = $(evt.target);\n      if ( self.isOpen && !$target.closest('.About-nav').length && !$target.closest('.Modal-content').length && !$target.closest('[data-modal-toggle]').length ) {\n        self.close(evt);\n      }\n    });\n\n    // The keyup event isn't triggered when tabbing from the last focusable element to the browser's GUI, so use the keydown event instead\n    events.on('keydown', function(evt) {\n\n      // Do nothing if modal is closed\n      if ( self.isOpen ) {\n\n        // Close with escape key\n        if ( evt.which === key.ESCAPE ) {\n          self.close(evt);\n        }\n\n        // Listen for tab key when modal is open to manage focus\n        if ( evt.which === key.TAB ) {\n\n          // Find currently focused element\n          var $focused = $(':focus');\n\n          // Update tabbables\n          self.$tabbables = self.$el.find('a, button, input, textarea, select').not('[tabindex=\"-1\"]').filter(':visible');\n          // console.log(self.$tabbables);\n\n          // Get index of focused element\n          var index = self.$tabbables.index( $focused );\n\n          // If item outside of modal is focused, or last item in modal, focus the first item in modal\n          if ( index === -1 || (!evt.shiftKey && index === self.$tabbables.length - 1) ) {\n            // Prevent default since we're manually focusing the first element\n            evt.preventDefault();\n            self.$tabbables.eq(0).focus();\n          }\n\n          // If tabbing backwards and first element is focused, go to last element\n          else if ( evt.shiftKey && index <= 0 ) {\n            // Prevent default since we're manually focusing the last element\n            evt.preventDefault();\n            self.$tabbables.eq(self.$tabbables.length - 1).focus();\n          }\n        }\n      }\n    });\n\n    // Listen for toggle event\n    events.on('modal-toggle', function(evt, name) {\n      if ( name === self.name ) {\n        self.toggle(evt);\n      }\n    });\n\n  },\n\n  // Expand expandable\n  open: function() {\n    // Save currently focused element to focus on close\n    this.$prevFocused = $(':focus');\n\n    // Disable scrolling\n    scrolling.disable();\n\n    // Update modal ARIA attributes, show and focus\n    this.$el.attr({\n      'aria-expanded': 'true',\n      'aria-hidden': 'false',\n      'tabindex': ''\n    }).addClass('is-active').focus();\n\n    // Update toggles\n    this.$toggles.attr({\n      'aria-pressed': 'true',\n      'aria-expanded': 'true'\n    });\n\n    // Update URL hash so users can link directly to the modal window content\n    // Use history.replaceState() to prevent adding a new history entry\n    // Note: If replaceState isn’t supported, modal-toggles.js won’t prevent the\n    // default click event, causing the hash to update and creating a new history entry.\n    if ( history.replaceState ) {\n      history.replaceState(null, '', '#' + this.name);\n    }\n\n    // Update state\n    this.isOpen = true;\n  },\n\n  // Collapse expandable\n  close: function(evt) {\n    var self = this;\n\n    // Prevent default so we don’t see toggle button’s ID in the hash\n    evt.preventDefault();\n\n    // Enable scrolling\n    scrolling.enable();\n\n    // Update nav ARIA attributes, hide\n    this.$el.attr({\n      'aria-expanded': 'false',\n      'aria-hidden': 'true',\n      'tabindex': '-1'\n    }).removeClass('is-active').removeAttr('tabindex');\n\n    // Update toggles\n    this.$toggles.attr({\n      'aria-pressed': 'false',\n      'aria-expanded': 'false'\n    });\n\n    // Get previously focused element\n    var $focusEl = this.$prevFocused;\n\n    // If no previously focused element, use modal toggle\n    if ( !this.$prevFocused.length ) {\n      $focusEl = this.$toggles.first();\n    }\n\n    // Focus element\n    $focusEl.attr('tabindex', '-1').on('blur focusout', function() {\n      $(this).removeAttr('tabindex');\n    }).focus();\n\n    // Clear hash using replaceState() to prevent adding a new history entry\n    if ( history.replaceState ) {\n      history.replaceState(null, '', window.location.pathname);\n    }\n\n    // Trigger close event, used by slidehsow to reset\n    events.trigger('close-modal', this.name);\n\n    // Update state\n    this.isOpen = false;\n  },\n\n  // Toggle expandable\n  toggle: function(evt) {\n    if ( this.isOpen ) {\n      this.close(evt);\n    }\n    else {\n      this.open();\n    }\n  }\n});\n\n// Initialize\n$('[data-modal]').each(function() {\n  var modal = new Modal({ el: this });\n});\n\n// Return constructor so it can be used by other modules\nexport default Modal;\n","// Keycode values\n\"use strict\";\n\nexport default {\n  DOWN: 40,\n  ENTER: 13,\n  ESCAPE: 27,\n  LEFT: 37,\n  PAGE_DOWN: 34,\n  PAGE_UP: 33,\n  RIGHT: 39,\n  SHIFT: 16,\n  SPACE: 32,\n  TAB: 9,\n  UP: 38\n};\n","//------------------------------------------------------------------------\n// Modal window toggle buttons (see modals.js for modal window content)\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\nimport events from './events';\n\nvar ModalToggle = Backbone.View.extend({\n  events: {\n    'click': 'toggle'\n  },\n\n  initialize: function() {\n    var self = this;\n\n    // Get target modal name\n    this.name = this.$el.data('modal-toggle');\n\n    // Check if modal exists\n    this.$modal = $('#' + this.name);\n\n    if ( !this.$modal.length ) {\n      console.warn('Can’t find modal window “' + this.name + '” for toggle', this.$el);\n      return false;\n    }\n\n    this.setup();\n  },\n\n  setup: function() {\n    // Add ARIA attributes to toggle\n    // Don’t use “aria-controls” http://www.heydonworks.com/article/aria-controls-is-poop\n    this.$el.attr({\n      'aria-expanded': 'false',\n      'role': 'button'\n    });\n  },\n\n  toggle: function(evt) {\n    // If replaceState() is supported, prevent default to avoid adding an entry to the history\n    if ( history.replaceState ) {\n      evt.preventDefault();\n    }\n\n    // Trigger modal toggle event for modals.js\n    events.trigger('modal-toggle', evt, this.name);\n  }\n});\n\n// Initialize\n$('[data-modal-toggle]').each(function() {\n  new ModalToggle({ el: this });\n});\n\n// Return constructor so it can be used by other modules\nexport default ModalToggle;\n","//------------------------------------------------------------------------\n// Multi-select dropdown menu functionality\n//------------------------------------------------------------------------\n\n'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\n\nvar MultiSelect = Backbone.View.extend({\n  // See http://harvesthq.github.io/chosen/options.html\n  // for help with these options\n  chosenOptions: {\n    allow_single_deselect: false,\n    disable_search: false,\n    disable_search_threshold: 5,\n    enable_split_word_search: true,\n    inherit_select_classes: true,\n    max_selected_options: Infinity,\n    no_results_text: \"Nothing matched\",\n    placeholder_text_multiple: \"Select one or many\",\n    placeholder_text_single:\t\"Select one\",\n    search_contains: true,\n    single_backstroke_delete: true,\n    display_disabled_options: true,\n    display_selected_options: true,\n    include_group_label_in_selected: false,\n    width: \"100%\"\n  },\n\n  // This function is stolen from Chosen.js because it does\n  // not expose any kind of API for communicating that it will not run\n  chosenSupported: function() {\n    if (window.navigator.appName === \"Microsoft Internet Explorer\") {\n      return document.documentMode >= 8;\n    }\n    if (/iP(od|hone)/i.test(window.navigator.userAgent)) {\n      return false;\n    }\n    if (/Android/i.test(window.navigator.userAgent)) {\n      if (/Mobile/i.test(window.navigator.userAgent)) {\n        return false;\n      }\n    }\n    return true;\n  },\n\n  initialize: function() {\n\n    var self = this;\n\n    if (self.chosenSupported()) {\n      self.$select = self.$(\"select\");\n      var placeholderValue = self.$select.attr(\"placeholder\");\n\n      if (!!placeholderValue) {\n        self.chosenOptions.placeholder_text_multiple = placeholderValue;\n        self.chosenOptions.placeholder_text_single = placeholderValue;\n      }\n\n      self.$select.on(\"chosen:ready\", function(event) {\n        self.$el.attr(\"style\",\"\");\n      });\n\n      self.$select.chosen(self.chosenOptions);\n\n    }\n    else {\n      // Chosen isn't going to run\n      self.$el.attr(\"style\",\"\");\n    }\n\n  }\n\n});\n\n// Initialize\n$('.multi-select').each(function() {\n  var multiSelect = new MultiSelect({ el: this });\n})\n","//------------------------------------------------------------------------\n// Wrap words to prevent orphans\n//\n// Based on https://github.com/simeydotme/jquery-unorphanize\n//------------------------------------------------------------------------\n// Basic example:\n//\n//   <p data-orphans>Lorem ipsum dolor sit amet</p>\n//\n// Output:\n//\n//   <p>Lorem ipsum dolor <span class=\"u-nowrap\">sit amet</span></p>\n//\n//------------------------------------------------------------------------\n// Custom word count:\n//\n//   <p data-orphans=\"3\">Lorem ipsum dolor sit amet</p>\n//\n// Output:\n//\n//   <p>Lorem ipsum <span class=\"u-nowrap\">dolor sit amet</span></p>\n//\n//------------------------------------------------------------------------\n// Requires the following CSS rule:\n//\n//   &-nowrap {\n//     @include fs-min-width(320px) {\n//       display: inline-block !important;\n//       white-space: nowrap !important;\n//     }\n//   }\n//\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\nimport 'jquery-unorphanize';\n\nvar Orphans = Backbone.View.extend({\n  initialize: function() {\n    // Get word count if provided, otherwise default to 2\n    this.words = this.$el.data('orphans') || 2;\n\n    // Wrap words\n    this.$el.unorphanize({\n      words: this.words,\n      wrapEl: 'span',\n      className: 'u-nowrap'\n    });\n\n    // Remove attribute to prevent recursion\n    this.$el.removeAttr('data-orphans');\n  }\n});\n\n$('[data-orphans]').each( function(i) {\n  var orphans = new Orphans({ el: this });\n});\n\nexport default Orphans;\n","//------------------------------------------------------------------------\n// Poll functionality\n//\n// Designed for yes/no responses\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\n\nvar Poll = Backbone.View.extend({\n  events: {\n    'submit': 'submitHandler'\n  },\n\n  initialize: function() {\n    this.pollID = this.$el.data('poll');\n    this.$submitButton = this.$el.find('[data-validate=\"submit\"]');\n    this.$results = $('[data-poll-results=\"' + this.pollID + '\"]');\n    this.$resultsData = this.$results.find('.Poll-results-data');\n    this.$yesPercentage = this.$results.find('[data-poll-results-yes]');\n    this.$noPercentage = this.$results.find('[data-poll-results-no]');\n    this.$totalCount = this.$results.find('[data-poll-results-total]');\n    this.$yesResource = this.$results.find('.Poll-results-resource--yes');\n    this.$noResource = this.$results.find('.Poll-results-resource--no');\n    this.$pollQuestionID = this.$(\"#poll-question-id\");\n  },\n\n  showResults: function() {\n    this.$el.attr('aria-hidden', 'true');\n    this.$results.attr('aria-hidden', 'false');\n  },\n\n  submitHandler: function(evt) {\n    var self = this;\n\n    // Prevent form from submitting since we don’t want to force a page refresh\n    evt.preventDefault();\n\n    // Check if form is valid\n    if ( !this.$el.hasClass('is-invalid') ) {\n      // Get radio value\n      var pollResponse = parseInt(this.$el.find('[type=\"radio\"]:checked').val(), 10);\n      var AUTH_TOKEN = $('meta[name=csrf-token]').attr('content');\n\n      var data = {\n        \"poll_answer\": {\n          \"answer\": pollResponse,\n          \"poll_question_id\": this.$pollQuestionID.val(),\n        }\n      };\n\n      $.ajax({\n        type: \"POST\",\n        url: \"/poll\",\n        data: data,\n        beforeSend: function(xhr) {\n          xhr.setRequestHeader(\"X-CSRF-Token\", AUTH_TOKEN);\n        },\n        success: function(data) {\n          // Update values\n          self.$yesPercentage.text(data.yes);\n          self.$noPercentage.text(data.no);\n          self.$totalCount.text(data.participants);\n        },\n        error: function() {\n          console.error('Unable to post poll data to “/poll”', data);\n          // Hide data\n          self.$resultsData.hide();\n        }\n      });\n\n      // Unhide appropriate resource\n      if ( pollResponse === 0 ) {\n        this.$noResource.addClass('is-active');\n      }\n      else {\n        this.$yesResource.addClass('is-active');\n      }\n\n      this.showResults();\n    }\n  }\n});\n\n// Initialize\n$('[data-poll]').each(function() {\n  var poll = new Poll({ el: this });\n});\n","//------------------------------------------------------------------------\n// Section drawer functionality for Publication Collection pages\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\nimport events from './events';\n\nvar PublicationDrawer = Backbone.View.extend({\n  events: {\n    \"click .PublicationSection-toggle\": \"toggle\",\n  },\n\n  initialize: function() {\n    var self = this;\n  },\n\n  toggle: function() {\n    if (this.$el.find('.PublicationSection-toggle-text')[0].innerText == 'Read More') {\n      this.$el.find('.PublicationSection-toggle-text').html('Collapse');\n    } else {\n      this.$el.find('.PublicationSection-toggle-text').html('Read More');\n    };\n\n    this.$el.find('.PublicationSection-toggle-arrow').toggleClass('is-active');\n    this.$el.find('.PublicationSection-drawer-content').slideToggle(1000);\n    this.$el.find('.PublicationSection-drawer-content-background-shape').toggleClass('is-active');\n  },\n\n\n});\n\n// Initialize\n$('.PublicationSection-drawer').each(function() {\n  var publicationDrawer = new PublicationDrawer({ el: this });\n});\n\n// Return constructor so it can be used by other modules\nexport default PublicationDrawer;\n","//------------------------------------------------------------------------\n// Quiz functionality\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\n\nvar Quiz = Backbone.View.extend({\n  events: {\n    'click .Question-reveal': 'showAnswer',\n    'click .Question-next': 'nextQuestion'\n  },\n\n  initialize: function() {\n    this.currentQuestion = 0;\n\n    this.$panels = this.$el.find('.Question-panel');\n    this.$panels.first().attr('aria-hidden', 'false');\n    this.$panels.slice(1).attr('aria-hidden', 'true');\n  },\n\n  showAnswer: function(evt) {\n    var $target = $(evt.target).addClass('is-hidden');\n    var $answer = $target.next('.Question-answer').addClass('is-active');\n  },\n\n  nextQuestion: function() {\n    // Get currently active question\n    var $current = this.$panels.eq(this.currentQuestion);\n\n    // Check if on last question\n    if ( this.currentQuestion === (this.$panels.length - 1) ) {\n      this.currentQuestion = 0;\n    }\n    else {\n      this.currentQuestion += 1;\n    }\n\n    // Get next question\n    var $next = this.$panels.eq(this.currentQuestion);\n\n    // Hide current and show next question\n    $current.attr('aria-hidden', 'true');\n    $next.attr('aria-hidden', 'false');\n  }\n\n});\n\n// Initialize\n$('.Question').each(function() {\n  var quiz = new Quiz({ el: this });\n});\n","//------------------------------------------------------------------------\n// Quiz functionality\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\n\nvar Quiz = Backbone.View.extend({\n  events: {\n    'click .Quiz-action-button': 'buttonHandler',\n    'click .Quiz-action-button--reset': 'reset',\n    'submit .Quiz-action-form': 'submitHandler'\n  },\n\n  initialize: function() {\n    this.$eligible = $('#eligible');\n    this.$form = this.$el.find('.Quiz-action-form');\n    this.$fee = this.$el.find('.Quiz-fee-amount');\n    this.defaultFee = this.$fee.text();\n    this.$submitButton = this.$el.find('[data-validate=\"submit\"]');\n  },\n\n  showPanel: function($panel) {\n    // Check if panel exists\n    if ( $panel.length ) {\n      // Hide old item\n      this.$el.find('[aria-hidden=\"false\"]').attr('aria-hidden', 'true').removeClass('is-active');\n\n      // Show target item\n      $panel.attr('aria-hidden', 'false').addClass('is-active');\n    }\n  },\n\n  // Add commas to dollar amounts\n  // Source: http://stackoverflow.com/a/2901298\n  formatDollars: function(val) {\n    return val.toString().replace(/\\B(?=(\\d{3})+(?!\\d))/g, \",\");\n  },\n\n  buttonHandler: function(evt) {\n    var $target = $(evt.target);\n    var href = $target.attr('href');\n\n    // Make sure this is a jump link\n    if ( href.indexOf('#') === 0 ) {\n      evt.preventDefault();\n\n      var targetId = $target.attr('href').substring(1);\n      var $targetItem = $('#' + targetId);\n\n      // Update panels\n      this.showPanel( $targetItem );\n    }\n  },\n\n  reset: function() {\n    this.$fee.text(this.defaultFee);\n  },\n\n  submitHandler: function(evt) {\n    // Prevent form from submitting since we don’t want to force a page refresh\n    evt.preventDefault();\n\n    // Check if form is valid\n    if ( !this.$form.hasClass('is-invalid') ) {\n\n      // Re-enable submit button (disabled by form validation script to prevent multiple sunbmissions)\n      // in case users go back to this panel again.\n      this.$submitButton.prop('disabled', false);\n\n      // Get select box value\n      var fee = parseInt($(evt.target).find('select').val(), 10);\n\n      // Check to make sure value is a number\n      if ( !isNaN(fee) ) {\n        // Update fee text\n        this.$fee.text( this.formatDollars(fee) );\n\n        // Go to eligibility panel\n        this.showPanel( this.$eligible );\n      }\n    }\n  }\n\n});\n\n// Initialize\n$('[data-quiz]').each(function() {\n  var quiz = new Quiz({ el: this });\n});\n","//------------------------------------------------------------------------\n// Video promo\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\nimport events from './events';\n\nvar VideoPromo = Backbone.View.extend({\n  events: {\n    'click .VideoPromo-play': 'play'\n  },\n\n  initialize: function() {\n    this.$video = this.$el.find('[data-youtube]');\n    this.videoId = this.$video.data('youtube');\n    this.$content = this.$el.find('.VideoPromo-wrap');\n    this.$play = this.$el.find('.VideoPromo-play');\n\n    // Once JS runs, link will operate like a button so we need to update its role\n    this.$play.attr('role', 'button');\n  },\n\n  play: function(evt) {\n    // Dont’t follow link\n    evt.preventDefault();\n\n    // Load the YouTube video on demand\n    events.trigger('load-video', this.videoId, true);\n\n    // Hide content\n    this.$content.addClass('is-hidden');\n\n    // Show video\n    this.$video.addClass('is-active');\n  }\n});\n\n// Initialize\n$('.VideoPromo').each(function() {\n  var videoPromo = new VideoPromo({ el: this });\n});\n","// Vimeo video players\n// https://github.com/vimeo/player.js\n//\n// This module will dynamically load the JS API, build the players, and attach event listeners for GTM.\n//\n// <div data-vimeo=\"65171201\"><a href=\"https://vimeo.com/141050050\">Watch video on Vimeo</a></div>\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\nimport once from 'lodash/once';\n\n// Video constructor\nvar VimeoPlayer = Backbone.View.extend({\n  initialize: function() {\n    var self = this;\n    this.id = this.$el.data('vimeo');\n\n    // Create video player\n    // Docs https://github.com/vimeo/player.js#embed-options\n    this.player = new window.Vimeo.Player(this.el, {\n      byline: false,\n      color: '009cde',\n      id: this.id,\n      portrait: false,\n      title: false\n    });\n\n    // Get the video title\n    this.player.getVideoTitle().then( function(title) {\n      self.videoTitle = title;\n    }).catch( function(error) {\n      console.warn(error);\n      self.videoTitle = 'Title not found';\n    });\n\n    // Play event listener\n    this.player.on('play', function() {\n      self.gtmVideoAction('play');\n    });\n\n    // Finished event listener\n    this.player.on('ended', function() {\n      self.gtmVideoAction('finished');\n    });\n\n    // These functions should only run once\n    // http://underscorejs.org/#once\n    this.track10sec = once(this.track10sec);\n    this.track50percent = once(this.track50percent);\n\n    // Track progress (fires every ~250ms)\n    this.player.on('timeupdate', function(data) {\n      // console.log(data.seconds + 's - ' + (data.percent * 100) + '% played');\n\n      // 10s elapsed\n      if ( data.seconds >= 10 ) {\n        self.track10sec();\n      }\n\n      // 50% watched\n      if ( data.percent >= 0.5 ) {\n        self.track50percent();\n      }\n    });\n  },\n\n  track10sec: function() {\n    this.gtmVideoAction('watched 10s');\n  },\n\n  track50percent: function() {\n    this.gtmVideoAction('watched 50%');\n  },\n\n  // Helper to push data to GTM dataLayer\n  gtmVideoAction: function(action) {\n    // console.log({\n    //   'event': 'customVideoEvent',\n    //   'videoTitle': this.videoTitle,\n    //   'videoAction': action\n    // });\n\n    // Use try/catch just in case GTM hasn’t loaded yet\n    try {\n      window.dataLayer.push({\n        'event': 'customVideoEvent',\n        'videoAction': action,\n        'videoTitle': this.videoTitle\n      });\n    } catch(e) {\n      console.warn('GTM: Unable to push Vimeo data to dataLayer');\n    }\n  }\n});\n\n// Find videos\nvar $videos = $('[data-vimeo], iframe[src*=\"vimeo.com\"]');\n\n// Load JS API and create video players if present\nif ( $videos.length ) {\n\n  // Build video players\n  var buildPlayers = function() {\n    $videos.each( function() {\n      var video = new VimeoPlayer({el: this});\n    });\n  };\n\n  // Load JS API if not already loaded\n  // https://github.com/vimeo/player.js\n  if (typeof window.Vimeo == 'undefined') {\n    // Get the script then build the players\n    $.getScript('https://player.vimeo.com/api/player.js')\n      .done(function( script, textStatus ) {\n        buildPlayers();\n      })\n      .fail(function( jqxhr, settings, exception ) {\n        console.warn('Vimeo player JS API could not be loaded');\n      });\n  }\n  else {\n    buildPlayers();\n  }\n}\n","// YouTube video players\n// https://developers.google.com/youtube/iframe_api_reference\n//\n// Requires YouTube Data API key to get video title\n// https://developers.google.com/youtube/v3/getting-started\n//\n// This module will dynamically load the JS API, build the players, and attach event listeners for GTM.\n//\n// <div data-youtube=\"FuYW3GdPhsc\"><a href=\"https://www.youtube.com/watch?v=FuYW3GdPhsc\">Watch video on YouTube</a></div>\n//------------------------------------------------------------------------\n'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\nimport once from 'lodash/once';\nimport events from './events';\nconst publicKey = '<%= ENV.fetch(\"YOUTUBE_PUBLIC_KEY\") %>';\n\n// Video constructor\nvar YouTubePlayer = Backbone.View.extend({\n  initialize: function() {\n    var self = this;\n    this.url = window.location.href;\n\n    // Create unique ID for each video\n    this.uniqueID = 'YT' + this.cid;\n\n    // Get playerVars from optional data attributes if present\n    this.collectVars();\n\n    // Check if iframe embed\n    if ( this.el.nodeName.toLowerCase() === 'iframe' ) {\n      // Add unique id\n      this.$el.attr('id', this.uniqueID);\n\n      // Get vars from iframe src attribute\n      this.iframeVars();\n    }\n    // Embed using data attributes\n    else {\n      // Get YouTube video ID\n      this.videoID = this.$el.attr('data-youtube');\n\n      // Create placeholder element that iframe will replace\n      $('<div>', {\n        id: this.uniqueID\n      }).appendTo(this.$el);\n\n      if ( !this.videoID ) {\n        console.warn('Missing YouTube ID');\n      }\n\n      // Store the video name for access later\n      this.videoTitle = this.$el.attr('data-youtube-title') || '';\n\n      // Lookup video title if not provided\n      if ( !this.videoTitle.length ) {\n        this.getVideoData( function( data ) {\n          if ( 'items' in data && data.items.length) {\n            var video = data.items[0];\n            self.videoTitle = $.trim( video.snippet.title );\n            // self.description = video.snippet.description || '';\n          }\n          else {\n            console.warn('Can’t get YouTube data for video ID ' + self.videoID);\n          }\n        });\n      }\n    }\n\n    // Lazy load functionality\n    this.shouldLazyload = this.$el.hasClass('js-lazyload');\n    this.hasLoaded = false;\n\n    if ( this.shouldLazyload && !this.hasLoaded ) {\n      events.on('load-video', function(id, autoplay) {\n        if ( self.videoID === id ) {\n          // console.log('heard load-video', id, autoplay);\n          self.buildPlayer(autoplay);\n        }\n      });\n    }\n    // Build if lazy load not enabled\n    else if ( !this.shouldLazyload ) {\n      this.buildPlayer();\n    }\n  },\n\n  // Get video metadata using YouTube gdata API\n  // https://www.googleapis.com/youtube/v3/videos?id=jZ4cur1kgog\n  getVideoData: function( callback ) {\n    var self = this;\n    var jqxhr = $.ajax({\n      type: 'GET',\n      url: 'https://www.googleapis.com/youtube/v3/videos?id=' + self.videoID + '&key=' + publicKey + '&part=snippet,contentDetails',\n      dataType: 'jsonp',\n      crossDomain: true,\n      success: function( data ) {\n        // console.log('YT get data', data);\n        callback( data );\n      },\n      error: function() {\n        this.videoTitle = 'Title not found';\n        return false;\n      }\n    });\n  },\n\n  // Collect player vars from data attributes (if present)\n  // https://developers.google.com/youtube/player_parameters?playerVersion=HTML5#Parameters\n  collectVars: function() {\n    this.playerVars = {};\n    this.playerVars.autohide = this.$el.attr('data-youtube-autohide') || 1;\n    this.playerVars.autoplay = this.$el.attr('data-youtube-autoplay') || 0;\n    // Note: controls=2 does not work when enablejsapi=1\n    this.playerVars.controls = this.$el.attr('data-youtube-controls') || 2;\n    this.playerVars.iv_load_policy = this.$el.attr('data-youtube-iv_load_policy') || 3;\n    this.playerVars.modestbranding = this.$el.attr('data-youtube-modestbranding') || 1;\n    this.playerVars.showinfo = this.$el.attr('data-youtube-showinfo') || 0;\n    this.playerVars.rel = this.$el.attr('data-youtube-rel') || 0;\n    this.playerVars.wmode = 'opaque';\n    // console.log('this.playerVars', this.playerVars);\n  },\n\n  iframeVars: function() {\n    var self = this;\n\n    // Get video ID from iframe URL and check for \"rel\" param\n    var iframeSrc = this.$el.attr('src');\n    var pattern = /(?:youtube.*\\/embed\\/)([-0-9A-z]*)(\\S*(?:rel\\=)([0-9]))?/g;\n    var matches = pattern.exec( iframeSrc );\n\n    if ( !!matches && matches.length > 1 ) {\n      this.videoID = matches[1];\n      // Set related videos param\n      this.playerVars.rel = matches[3] || 1;\n    }\n\n    // Get video title\n    this.getVideoData( function( data ) {\n      self.videoTitle = data.items[0].snippet.title;\n    });\n\n    // Add enablejsapi=1 to iframe src to allow API to work\n    if ( iframeSrc.indexOf('enablejsapi') === -1 || iframeSrc.indexOf('wmode') === -1 ) {\n      var separator = iframeSrc.indexOf('?') > 0 ? '&' : '?';\n      iframeSrc += separator + 'enablejsapi=1&' + $.param( this.playerVars );\n      this.$el.attr( 'src', iframeSrc );\n    }\n  },\n\n  buildPlayer: function(autoplay) {\n    var self = this;\n\n    if ( typeof autoplay !== 'undefined' ) {\n      this.playerVars.autoplay = true;\n    }\n\n    // Replace the placeholder element with the iframe\n    this.player = new YT.Player( this.uniqueID, {\n      videoId: self.videoID,\n      playerVars: self.playerVars,\n      events: {\n        'onReady': function() {\n          // console.log('YT ready', self.uniqueID);\n          self.videoReady();\n        },\n        'onStateChange': function() {\n          // console.log('YT change', self.uniqueID);\n          self.onPlayerStateChange();\n        }\n      }\n    });\n  },\n\n  videoReady: function() {\n    this.hasLoaded = true;\n\n    // Add init class to wrapper to hide the fallback link\n    this.$el.addClass('js-init');\n\n    // Save video duration\n    this.duration = this.player.getDuration();\n\n    // Ensure analytics functions only run once\n    // http://underscorejs.org/#once\n    this.analyticsPlay = once(this.analyticsPlay);\n    this.analytics10s = once(this.analytics10s);\n    this.analytics50 = once(this.analytics50);\n    this.analyticsEnd = once(this.analyticsEnd);\n\n    // Emit video event if inside a modal window\n    var $modal = this.$el.closest('[data-modal]');\n\n    if ( $modal.length ) {\n      events.trigger('modal-video-ready', $modal, this.player);\n    }\n  },\n\n  // make start/end analytics calls, monitor video while playing\n  onPlayerStateChange: function() {\n    var self = this;\n    this.state = this.player.getPlayerState();\n\n    // Playing\n    if ( this.state === YT.PlayerState.PLAYING ) {\n      this.analyticsPlay();\n\n      // Track elapsed time\n      this.timer = setInterval(function() {\n        this.monitorVideo();\n      }.bind(this), 1000);\n    }\n    // Finished\n    else if ( this.state === YT.PlayerState.ENDED ) {\n      this.analyticsEnd();\n      clearInterval( this.timer );\n    }\n    else {\n      clearInterval( this.timer );\n    }\n  },\n\n  // Track video progress\n  monitorVideo: function() {\n    var time = this.player.getCurrentTime();\n\n    // Viewed 10 seconds\n    if ( time > 10 ) {\n      this.analytics10s();\n    }\n\n    // Viewed 50%\n    if ( time / this.duration >= 0.5 ) {\n      this.analytics50();\n    }\n  },\n\n  // Analytics Functions (replace logs with correct GA calls - video name stored in 'this.videoTitle')\n  analyticsPlay: function() {\n    this.gtmVideoAction('play');\n  },\n\n  analytics10s: function() {\n    this.gtmVideoAction('watched 10s');\n  },\n\n  analytics50: function() {\n    this.gtmVideoAction('watched 50%');\n  },\n\n  analyticsEnd: function() {\n    this.gtmVideoAction('finished');\n  },\n\n  gtmVideoAction: function(action) {\n    // console.log({\n    //   'event': 'customVideoEvent',\n    //   'videoTitle': this.videoTitle,\n    //   'videoAction': action\n    // });\n\n    // Use try/catch to be safe\n    try {\n      window.dataLayer.push({\n        'event': 'customVideoEvent',\n        'videoTitle': this.videoTitle,\n        'videoAction': action\n      });\n    } catch(e) {\n      console.warn('GTM: Unable to push YouTube data to dataLayer');\n    }\n  }\n});\n\n// Find videos\nvar $videos = $(\"[data-youtube], iframe[src*='youtube.com'], iframe[src*='youtube-nocookie.com']\");\n\n// Load JS API and create video players if present\nif ( $videos.length ) {\n\n  // Build video players\n  var buildPlayers = function() {\n    $videos.each( function() {\n      var video = new YouTubePlayer({el: this});\n    });\n  };\n\n  // Check if YouTube script has already run\n  // https://developers.google.com/youtube/iframe_api_reference\n  if (typeof window.onYouTubeIframeAPIReady == 'undefined') {\n    // Set custom “onYouTubeIframeAPIReady” callback that will fire once the script has downloaded\n    window.onYouTubeIframeAPIReady = function() {\n      buildPlayers();\n    };\n\n    // Get YouTube JS API script\n    $.getScript('https://www.youtube.com/iframe_api')\n      .fail(function( jqxhr, settings, exception ) {\n        console.warn('YouTube Iframe Player API could not be loaded');\n      });\n  }\n  // If YouTube script has previously run, we can build players immediately\n  else {\n    buildPlayers();\n  }\n}","'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\n\n// jQuery Easing v1.3 - http://gsgd.co.uk/sandbox/jquery/easing/\n$.extend( $.easing, {\n  easeOutQuad: function (x, t, b, c, d) {\n    return -c *(t/=d)*(t-2) + b;\n  }\n});\n\nvar MobileHeaderView = Backbone.View.extend({\n\n  initialize: function() {\n    var self = this;\n    var isOpen = false;\n\n    this.$nav = this.$(\".MobileNavigation\");\n    this.$navToggle = this.$(\".MobileHeader-navToggle\");\n    this.$navOverlay = this.$(\".MobileHeader-overlay\");\n\n    this.navOverlayActiveClass = \"-active\";\n    this.navActiveClass = \"-active\";\n    this.toggleActiveClass = \"-active\";\n    this.itemActiveClass = \"-active\";\n\n    this.navToggleText = this.$navToggle.text();\n    this.navCloseText = \"Close\";\n  },\n\n  events: {\n    \"click .MobileHeader-navToggle\": \"toggleMainMenu\",\n    \"click .MobileNavigation-item.-withSubmenu .MobileNavigation-link\": \"toggleSubMenu\",\n  },\n\n  toggleMainMenu: function(event) {\n    event.preventDefault();\n    if (this.isOpen) {\n      this.collapseMainMenu();\n    } else {\n      this.expandMainMenu();\n    }\n  },\n\n  expandMainMenu: function() {\n    this.$navToggle.addClass(this.toggleActiveClass);\n    this.$navToggle.text(this.navCloseText);\n    this.$nav.addClass(this.navActiveClass);\n    this.$navOverlay.addClass(this.navOverlayActiveClass);\n    this.isOpen = true;\n  },\n\n  collapseMainMenu: function() {\n    this.$navToggle.removeClass(this.toggleActiveClass);\n    this.$navToggle.text(this.navToggleText);\n    this.$nav.removeClass(this.navActiveClass);\n    this.closeSubMenus();\n    this.$navOverlay.removeClass(\"-active\");\n    this.isOpen = false;\n  },\n\n  closeSubMenus: function(event) {\n    $(\".MobileNavigation-item\").removeClass(this.itemActiveClass);\n    $(\".MobileNavigation-subMenu\").slideUp({\n      duration: 200,\n      easing: \"easeOutQuad\"\n    });\n  },\n\n  toggleSubMenu: function(event) {\n    event.preventDefault();\n\n    var $targetItem = $(event.currentTarget).closest(\".MobileNavigation-item\");\n    var $targetMenu = $targetItem.find(\".MobileNavigation-subMenu\");\n\n    if ($targetItem.hasClass(this.itemActiveClass)) {\n      this.closeSubMenus();\n    } else {\n      this.closeSubMenus();\n\n      // open target item\n      $targetItem.addClass(this.itemActiveClass);\n      $targetMenu.slideDown({\n        duration: 200,\n        easing: \"easeOutQuad\"\n      });\n    }\n  }\n});\n\n$(\".MobileHeader\").each( function() {\n  var Header = new MobileHeaderView({ el: this });\n});\n","'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\nimport Events from './events';\n\n// jQuery Easing v1.3 - http://gsgd.co.uk/sandbox/jquery/easing/\n$.extend( $.easing, {\n  easeOutQuad: function (x, t, b, c, d) {\n    return -c *(t/=d)*(t-2) + b;\n  }\n});\n\nvar DesktopHeaderView = Backbone.View.extend({\n  initialize: function() {\n    var self = this;\n    var searchIsOpen = false;\n\n    this.itemActiveClass = \"-active\";\n    this.searchToggleActiveClass = \"-active\";\n\n    this.$searchToggle = this.$(\".DesktopSearch-toggle\").attr('role', 'button');\n    this.$searchForm = this.$(\".DesktopSearch-form\");\n    this.$searchQuery = this.$(\".DesktopSearch-query\");\n\n    Events.on(\"bodyClick\", function(event) {\n      var $target = $(event.target);\n\n      if ( !$target.closest(\".DesktopNavigation-item\").length ) {\n        self.closeSubMenus();\n      }\n\n      if ( !$target.closest(\".DesktopSearch\").length ) {\n        self.closeSearch();\n      }\n    });\n  },\n\n  events: {\n    \"click .DesktopNavigation-item.-withSubmenu .DesktopNavigation-link\": \"toggleSubMenu\",\n    \"click .DesktopSearch-toggle\": \"toggleSearch\",\n  },\n\n  toggleSearch: function(event) {\n    event.preventDefault();\n\n    var self = this;\n\n    if ( this.searchIsOpen ) {\n      self.closeSearch();\n    } else {\n      self.openSearch();\n    }\n  },\n\n  openSearch: function(event) {\n    this.closeSubMenus();\n    this.$searchToggle.addClass(this.searchToggleActiveClass);\n    this.$searchForm.fadeIn({\n      duration: 150,\n      easing: \"easeOutQuad\"\n    });\n    this.$searchQuery.focus();\n    this.searchIsOpen = true;\n  },\n\n  closeSearch: function(event) {\n    this.$searchToggle.removeClass(this.searchToggleActiveClass);\n    this.$searchForm.fadeOut({\n      duration: 150,\n      easing: \"easeOutQuad\"\n    });\n    this.searchIsOpen = false;\n  },\n\n  closeSubMenus: function(event) {\n    $(\".DesktopNavigation-item\").removeClass(this.itemActiveClass);\n    $(\".DesktopNavigation-subMenu\").fadeOut({\n      duration: 300,\n      easing: \"easeOutQuad\"\n    });\n  },\n\n  toggleSubMenu: function(event) {\n    event.preventDefault();\n\n    var $targetItem = $(event.currentTarget).closest(\".DesktopNavigation-item\");\n    var $targetMenu = $targetItem.find(\".DesktopNavigation-subMenu\");\n\n    if ($targetItem.hasClass(this.itemActiveClass)) {\n      this.closeSubMenus();\n    } else {\n      this.closeSubMenus();\n\n      // open target item\n      $targetItem.addClass(this.itemActiveClass);\n      $targetMenu.fadeIn({\n        duration: 300,\n        easing: \"easeOutQuad\"\n      });\n    }\n  }\n\n});\n\n$(\".DesktopHeader\").each( function() {\n  var Header = new DesktopHeaderView({ el: this });\n});\n","'use strict';\nimport $ from 'jquery';\nimport Backbone from 'backbone';\nimport slick from 'slick-carousel';\n\nvar ContentCarousel = Backbone.View.extend({\n  initialize: function() {\n    this.$slides = this.$('.ContentCarousel-slides');\n    console.log(this.$slides);\n\n    this.$slides.slick({\n      adaptiveHeight: true,\n      dots: true,\n      infinite: false,\n      slidesToShow: 1,\n      slidesToScroll: 1,\n      nextArrow: `\n        <button class=\"ContentCarousel-button ContentCarousel-button--next\">\n          <svg viewBox=\"0 0 1792 1792\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M1171 960q0 13-10 23l-466 466q-10 10-23 10t-23-10l-50-50q-10-10-10-23t10-23l393-393-393-393q-10-10-10-23t10-23l50-50q10-10 23-10t23 10l466 466q10 10 10 23z\"/></svg>\n        </button>\n      `,\n      prevArrow: `\n        <button class=\"ContentCarousel-button ContentCarousel-button--prev\">\n          <svg viewBox=\"0 0 1792 1792\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M1203 544q0 13-10 23L800 960l393 393q10 10 10 23t-10 23l-50 50q-10 10-23 10t-23-10L631 983q-10-10-10-23t10-23l466-466q10-10 23-10t23 10l50 50q10 10 10 23z\"/></svg>\n        </button>\n      `\n    });\n  }\n});\n\n$('.ContentCarousel').each(function() {\n  new ContentCarousel({ el: this });\n});\n","//------------------------------------------------------------------------\n// This file contains site-wide JS that will be packaged into a single file\n//\n// We’re using the sprockets-commoner gem to enable Babel transformations\n// https://github.com/Shopify/sprockets-commoner\n//------------------------------------------------------------------------\n/* globals require */ // JSHint global vars\n'use strict';\n\n// Expose jQuery globally (optional)\nwindow.$ = window.jQuery = require('jquery');\n\n// Picture element polyfill\n// Requires background-picture.js and \".js-background-image\" CSS in _base.scss\n// Can remove once support is broad enough http://caniuse.com/#feat=picture\nimport 'picturefill';\n\n// Include Chosen library\nimport './lib/jquery.chosen';\n\n// Modules\nimport './modules/background-picture';\nimport './modules/custom-select';\nimport './modules/form-autosubmit';\nimport './modules/form-validation';\nimport './modules/jump-links';\nimport './modules/mailto';\nimport './modules/megamenu';\nimport './modules/modals';\nimport './modules/modal-toggles';\nimport './modules/multi-select';\nimport './modules/orphans';\nimport './modules/poll';\nimport './modules/publication-drawer';\nimport './modules/question-carousel';\nimport './modules/quiz';\nimport './modules/video-promo';\nimport './modules/vimeo';\nimport './modules/youtube';\nimport AdminEditLink from './modules/admin-edit-link';\nimport readCookie from './modules/read-cookie';\n\n// Project Modules\nimport './modules/mobile-header';\nimport './modules/desktop-header';\nimport './modules/sessions';\nimport './modules/content-carousel';\n\n// Twitter widgets\nif ($('.twitter-tweet').length) {\n  $.getScript('https://platform.twitter.com/widgets.js')\n    .done(function(script, textStatus) {})\n    .fail(function(jqxhr, settings, exception) {\n      console.warn('Twitter widgets could not be loaded');\n    });\n}\n\n// Admin Edit Links\nif (readCookie('signed_in') === '1') {\n  var editableElements = document.querySelectorAll('[data-editable]');\n  [].forEach.call(editableElements, function(el) {\n    new AdminEditLink({\n      el: el\n    });\n  });\n}\n","export default function(name) {\n  var nameEQ = name + '=';\n  var ca = document.cookie.split(';');\n\n  for (var i = 0; i < ca.length; i++) {\n    var c = ca[i];\n    while (c.charAt(0) === ' ') c = c.substring(1, c.length);\n    if (c.indexOf(nameEQ) === 0) return c.substring(nameEQ.length, c.length);\n  }\n  return null;\n};\n"],"names":["module","exports","config","self","this","createAnchor","settings","class","href","text","target","e","console","warn","el","style","position","anchor","document","createElement","anchorText","createTextNode","append","setAttribute","render","editableAttribute","getAttribute","length","editableInfo","split","prepend","initialize","root","g","global","_","$","Backbone","previousBackbone","slice","Array","prototype","VERSION","noConflict","emulateHTTP","emulateJSON","addUnderscoreMethods","Class","methods","attribute","each","method","value","iteratee","context","cb","defaultVal","args","call","arguments","unshift","apply","addMethod","instance","isFunction","isObject","_isModel","modelMatcher","isString","model","get","attrs","matcher","matches","attributes","Events","eventSplitter","eventsApi","events","name","callback","opts","names","i","keys","test","on","internalOn","obj","listening","_events","onApi","ctx","_listeners","id","listenTo","_listenId","uniqueId","listeningTo","_listeningTo","thisId","objId","count","options","handlers","push","off","offApi","listeners","stopListening","ids","remaining","j","handler","_callback","once","onceMap","bind","listenToOnce","map","offer","trigger","Math","max","triggerApi","objEvents","allEvents","all","triggerEvents","concat","ev","l","a1","a2","a3","unbind","extend","Model","cid","cidPrefix","collection","parse","defaults","result","set","changed","validationError","idAttribute","toJSON","clone","sync","attr","escape","has","key","val","_validate","unset","silent","changes","changing","_changing","_previousAttributes","current","prev","isEqual","_pending","clear","hasChanged","isEmpty","changedAttributes","diff","old","size","previous","previousAttributes","fetch","success","resp","serverAttrs","wrapError","save","wait","validate","isNew","patch","xhr","destroy","defer","url","base","urlError","replace","encodeURIComponent","constructor","isValid","error","values","pairs","invert","pick","omit","chain","Collection","models","comparator","_reset","reset","setOptions","add","remove","merge","addOptions","splice","array","insert","at","min","tail","singular","isArray","removed","_removeModels","added","merged","toAdd","toMerge","toRemove","modelMap","sort","sortable","sortAttr","existing","_prepareModel","_addReference","orderChanged","some","m","index","_removeReference","previousModels","pop","shift","_byId","modelId","where","first","findWhere","Error","sortBy","pluck","create","callbackOpts","indexOf","_onModelEvent","event","prevId","forEach","collect","reduce","foldl","inject","reduceRight","foldr","find","detect","filter","select","reject","every","any","include","includes","contains","invoke","toArray","head","take","initial","rest","drop","last","without","difference","shuffle","lastIndexOf","sample","partition","groupBy","countBy","indexBy","findIndex","findLastIndex","View","viewOptions","_ensureElement","delegateEventSplitter","tagName","selector","$el","_removeElement","setElement","element","undelegateEvents","_setElement","delegateEvents","match","delegate","eventName","listener","undelegate","_createElement","className","_setAttributes","type","methodMap","params","dataType","data","contentType","JSON","stringify","_method","beforeSend","setRequestHeader","processData","textStatus","errorThrown","ajax","Router","routes","_bindRoutes","optionalParam","namedParam","splatParam","escapeRegExp","route","isRegExp","_routeToRegExp","router","history","fragment","_extractParameters","execute","navigate","optional","RegExp","exec","param","decodeURIComponent","History","checkUrl","window","location","routeStripper","rootStripper","pathStripper","started","interval","atRoot","pathname","getSearch","matchRoot","decodeFragment","decodeURI","getHash","getPath","path","charAt","getFragment","_usePushState","_wantsHashChange","start","hashChange","_hasHashChange","documentMode","_useHashChange","_wantsPushState","pushState","_hasPushState","rootPath","iframe","src","display","tabIndex","body","iWindow","insertBefore","firstChild","contentWindow","open","close","hash","addEventListener","attachEvent","_checkUrlInterval","setInterval","loadUrl","stop","removeEventListener","detachEvent","removeChild","clearInterval","title","assign","_updateHash","protoProps","staticProps","child","parent","__super__","factory","undefined","TypeError","Function","object","Object","scope","arraylike","String","searchElement","fromIndex","k","O","len","n","abs","Infinity","pluginName","words","wrapEl","Plugin","_defaults","_name","init","trim","html","startTags","startTagsCount","startPlaceholders","endTags","endTagsCount","endPlaceholders","wordArray","wordPositions","cleanWordArray","item","lastWordPos","lastWordIndex","firstPart","join","lastPart","replaceRegex","fn","jQuery","w","noGlobal","arr","getProto","getPrototypeOf","class2type","toString","hasOwn","hasOwnProperty","fnToString","ObjectFunctionString","support","DOMEval","code","doc","script","appendChild","parentNode","version","rtrim","rmsPrefix","rdashAlpha","fcamelCase","letter","toUpperCase","isArrayLike","isWindow","jquery","num","pushStack","elems","ret","prevObject","elem","eq","end","copy","copyIsArray","deep","isPlainObject","expando","random","isReady","msg","noop","isNumeric","isNaN","parseFloat","proto","Ctor","isEmptyObject","globalEval","camelCase","string","makeArray","results","inArray","second","grep","callbackExpect","arg","guid","proxy","tmp","now","Date","Symbol","iterator","toLowerCase","Sizzle","Expr","getText","isXML","tokenize","compile","outermostContext","sortInput","hasDuplicate","setDocument","docElem","documentIsHTML","rbuggyQSA","rbuggyMatches","preferredDoc","dirruns","done","classCache","createCache","tokenCache","compilerCache","sortOrder","a","b","push_native","list","booleans","whitespace","identifier","pseudos","rwhitespace","rcomma","rcombinators","rattributeQuotes","rpseudo","ridentifier","matchExpr","rinputs","rheader","rnative","rquickExpr","rsibling","runescape","funescape","escaped","escapedWhitespace","high","fromCharCode","rcssescape","fcssescape","ch","asCodePoint","charCodeAt","unloadHandler","disabledAncestor","addCombinator","disabled","dir","next","childNodes","nodeType","els","seed","nid","groups","newSelector","newContext","ownerDocument","getElementById","getElementsByTagName","getElementsByClassName","qsa","nodeName","toSelector","testContext","querySelectorAll","qsaError","removeAttribute","cache","cacheLength","markFunction","assert","addHandle","attrHandle","siblingCheck","cur","sourceIndex","nextSibling","createInputPseudo","createButtonPseudo","createDisabledPseudo","isDisabled","createPositionalPseudo","argument","matchIndexes","documentElement","node","hasCompare","subWindow","defaultView","top","createComment","getById","getElementsByName","attrId","getAttributeNode","tag","innerHTML","input","matchesSelector","webkitMatchesSelector","mozMatchesSelector","oMatchesSelector","msMatchesSelector","disconnectedMatch","compareDocumentPosition","adown","bup","compare","sortDetached","aup","ap","bp","expr","elements","specified","sel","uniqueSort","duplicates","detectDuplicates","sortStable","textContent","nodeValue","selectors","createPseudo","relative","preFilter","excess","unquoted","nodeNameSelector","pattern","operator","check","what","simple","forward","ofType","xml","uniqueCache","outerCache","nodeIndex","useCache","lastChild","uniqueID","pseudo","setFilters","idx","matched","unmatched","innerText","lang","elemLang","activeElement","hasFocus","checked","selected","selectedIndex","radio","checkbox","file","password","image","submit","tokens","combinator","skip","checkNonElements","doneName","oldCache","newCache","elementMatcher","matchers","condense","newUnmatched","mapped","setMatcher","postFilter","postFinder","postSelector","temp","preMap","postMap","preexisting","contexts","multipleContexts","matcherIn","matcherOut","matcherFromTokens","checkContext","leadingRelative","implicitRelative","matchContext","matchAnyContext","filters","parseOnly","soFar","preFilters","cached","setMatchers","elementMatchers","bySet","byElement","superMatcher","outermost","matchedCount","setMatched","contextBackup","dirrunsUnique","matcherFromGroupMatchers","token","compiled","defaultValue","unique","isXMLDoc","escapeSelector","until","truncate","is","siblings","rneedsContext","needsContext","rsingleTag","risSimple","winnow","qualifier","not","rootjQuery","parseHTML","ready","rparentsprev","guaranteedUnique","children","contents","sibling","targets","closest","prevAll","addBack","parents","parentsUntil","nextAll","nextUntil","prevUntil","contentDocument","content","reverse","rnothtmlwhite","Identity","v","Thrower","ex","adoptValue","resolve","noValue","promise","fail","then","Callbacks","flag","createOptions","firing","memory","fired","locked","queue","firingIndex","fire","stopOnFalse","empty","disable","lock","fireWith","Deferred","func","tuples","state","always","deferred","pipe","fns","newDefer","tuple","returned","progress","notify","onFulfilled","onRejected","onProgress","maxDepth","depth","special","that","mightThrow","notifyWith","resolveWith","process","exceptionHook","stackTrace","rejectWith","getStackHook","setTimeout","stateString","when","singleValue","resolveContexts","resolveValues","master","updateFunc","rerrorNames","stack","message","readyException","readyList","completed","catch","readyWait","readyState","doScroll","access","chainable","emptyGet","raw","bulk","acceptData","owner","Data","uid","defineProperty","configurable","prop","hasData","dataPriv","dataUser","rbrace","rmultiDash","dataAttr","getData","removeData","_data","_removeData","dequeue","startLength","hooks","_queueHooks","setter","clearQueue","pnum","source","rcssNum","cssExpand","isHiddenWithinTree","css","swap","adjustCSS","valueParts","tween","adjusted","scale","maxIterations","currentValue","unit","cssNumber","initialInUnit","defaultDisplayMap","getDefaultDisplay","showHide","show","hide","toggle","rcheckableType","rtagName","rscriptType","wrapMap","option","thead","col","tr","td","_default","getAll","setGlobalEval","refElements","optgroup","tbody","tfoot","colgroup","caption","th","div","rhtml","buildFragment","scripts","selection","ignored","wrap","createDocumentFragment","nodes","htmlPrefilter","checkClone","cloneNode","noCloneChecked","rkeyEvent","rmouseEvent","rtypenamespace","returnTrue","returnFalse","safeActiveElement","err","types","one","origFn","handleObjIn","eventHandle","t","handleObj","namespaces","origType","elemData","handle","triggered","dispatch","delegateType","bindType","namespace","delegateCount","setup","mappedTypes","origCount","teardown","removeEvent","nativeEvent","handlerQueue","fix","delegateTarget","preDispatch","isPropagationStopped","currentTarget","isImmediatePropagationStopped","rnamespace","preventDefault","stopPropagation","postDispatch","matchedHandlers","matchedSelectors","button","addProp","hook","Event","enumerable","originalEvent","writable","load","noBubble","focus","blur","click","beforeunload","returnValue","props","isDefaultPrevented","defaultPrevented","relatedTarget","timeStamp","isSimulated","stopImmediatePropagation","altKey","bubbles","cancelable","changedTouches","ctrlKey","detail","eventPhase","metaKey","pageX","pageY","shiftKey","view","charCode","keyCode","buttons","clientX","clientY","offsetX","offsetY","pointerId","pointerType","screenX","screenY","targetTouches","toElement","touches","which","mouseenter","mouseleave","pointerenter","pointerleave","orig","related","rxhtmlTag","rnoInnerhtml","rchecked","rscriptTypeMasked","rcleanScript","manipulationTarget","disableScript","restoreScript","cloneCopyEvent","dest","pdataOld","pdataCur","udataOld","udataCur","fixInput","domManip","hasScripts","iNoClone","_evalUrl","keepData","cleanData","dataAndEvents","deepDataAndEvents","srcElements","destElements","inPage","detach","before","after","replaceWith","replaceChild","appendTo","prependTo","insertAfter","replaceAll","original","rmargin","rnumnonpx","getStyles","opener","getComputedStyle","curCSS","computed","width","minWidth","maxWidth","getPropertyValue","pixelMarginRight","addGetHookIf","conditionFn","hookFn","computeStyleTests","cssText","container","divStyle","pixelPositionVal","reliableMarginLeftVal","marginLeft","boxSizingReliableVal","marginRight","pixelMarginRightVal","backgroundClip","clearCloneStyle","pixelPosition","boxSizingReliable","reliableMarginLeft","rdisplayswap","rcustomProp","cssShow","visibility","cssNormalTransform","letterSpacing","fontWeight","cssPrefixes","emptyStyle","finalPropName","cssProps","capName","vendorPropName","setPositiveNumber","subtract","augmentWidthOrHeight","extra","isBorderBox","styles","getWidthOrHeight","valueIsBorderBox","Tween","easing","cssHooks","opacity","origName","isCustomProp","setProperty","isFinite","getClientRects","getBoundingClientRect","left","margin","padding","border","prefix","suffix","expand","expanded","parts","propHooks","run","percent","eased","duration","pos","step","fx","scrollTop","scrollLeft","linear","p","swing","cos","PI","fxNow","inProgress","rfxtypes","rrun","schedule","hidden","requestAnimationFrame","tick","createFxNow","genFx","includeWidth","height","createTween","animation","Animation","tweeners","properties","stopped","prefilters","currentTime","startTime","tweens","specialEasing","originalProperties","originalOptions","gotoEnd","propFilter","complete","timer","anim","tweener","oldfire","propTween","restoreDisplay","isBox","dataShow","unqueued","overflow","overflowX","overflowY","prefilter","speed","opt","speeds","fadeTo","to","animate","optall","doAnimation","finish","stopQueue","timers","cssFn","slideDown","slideUp","slideToggle","fadeIn","fadeOut","fadeToggle","slow","fast","delay","time","timeout","clearTimeout","checkOn","optSelected","radioValue","boolHook","removeAttr","nType","attrHooks","bool","attrNames","getter","lowercaseName","rfocusable","rclickable","stripAndCollapse","getClass","removeProp","propFix","tabindex","parseInt","addClass","classes","curValue","clazz","finalValue","removeClass","toggleClass","stateVal","classNames","hasClass","rreturn","valHooks","optionSet","rfocusMorph","onlyHandlers","bubbleType","ontype","eventPath","isTrigger","parentWindow","simulate","triggerHandler","hover","fnOver","fnOut","focusin","attaches","nonce","rquery","parseXML","DOMParser","parseFromString","rbracket","rCRLF","rsubmitterTypes","rsubmittable","buildParams","traditional","s","valueOrFunction","serialize","serializeArray","r20","rhash","rantiCache","rheaders","rnoContent","rprotocol","transports","allTypes","originAnchor","addToPrefiltersOrTransports","structure","dataTypeExpression","dataTypes","inspectPrefiltersOrTransports","jqXHR","inspected","seekingTransport","inspect","prefilterOrFactory","dataTypeOrTransport","ajaxExtend","flatOptions","ajaxSettings","active","lastModified","etag","isLocal","protocol","async","accepts","json","responseFields","converters","ajaxSetup","ajaxPrefilter","ajaxTransport","transport","cacheURL","responseHeadersString","responseHeaders","timeoutTimer","urlAnchor","fireGlobals","uncached","callbackContext","globalEventContext","completeDeferred","statusCode","requestHeaders","requestHeadersNames","strAbort","getResponseHeader","getAllResponseHeaders","overrideMimeType","mimeType","status","abort","statusText","finalText","crossDomain","host","hasContent","ifModified","headers","send","nativeStatusText","responses","isSuccess","response","modified","ct","finalDataType","firstDataType","ajaxHandleResponses","conv2","conv","dataFilter","throws","ajaxConvert","getJSON","getScript","wrapAll","firstElementChild","wrapInner","unwrap","visible","offsetWidth","offsetHeight","XMLHttpRequest","xhrSuccessStatus","xhrSupported","cors","errorCallback","username","xhrFields","onload","onerror","onabort","onreadystatechange","responseType","responseText","binary","charset","scriptCharset","evt","oldCallbacks","rjsonp","jsonp","jsonpCallback","originalSettings","callbackName","overwritten","responseContainer","jsonProp","createHTMLDocument","implementation","keepScripts","parsed","animated","offset","setOffset","curPosition","curLeft","curCSSTop","curTop","curOffset","curCSSLeft","curElem","using","rect","win","pageYOffset","clientTop","pageXOffset","clientLeft","offsetParent","parentOffset","scrollTo","Height","Width","defaultExtra","funcName","holdReady","hold","parseJSON","_jQuery","_$","getRawTag","objectToString","symToStringTag","toStringTag","freeGlobal","objectProto","nativeObjectToString","isOwn","unmasked","freeSelf","toInteger","toNumber","nativeMax","nativeMin","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","invokeFunc","thisArg","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","remainingWait","debounced","isInvoking","leadingEdge","cancel","flush","baseGetTag","isObjectLike","FUNC_ERROR_TEXT","HASH_UNDEFINED","PLACEHOLDER","WRAP_PARTIAL_FLAG","WRAP_ARY_FLAG","INFINITY","MAX_SAFE_INTEGER","NAN","MAX_ARRAY_LENGTH","wrapFlags","argsTag","arrayTag","boolTag","dateTag","errorTag","funcTag","genTag","mapTag","numberTag","objectTag","promiseTag","regexpTag","setTag","stringTag","symbolTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reEmptyStringLeading","reEmptyStringMiddle","reEmptyStringTrailing","reEscapedHtml","reUnescapedHtml","reHasEscapedHtml","reHasUnescapedHtml","reEscape","reEvaluate","reInterpolate","reIsDeepProp","reIsPlainProp","reLeadingDot","rePropName","reRegExpChar","reHasRegExpChar","reTrim","reTrimStart","reTrimEnd","reWrapComment","reWrapDetails","reSplitDetails","reAsciiWord","reEscapeChar","reEsTemplate","reFlags","reIsBadHex","reIsBinary","reIsHostCtor","reIsOctal","reIsUint","reLatin","reNoMatch","reUnescapedString","rsAstralRange","rsComboRange","rsComboMarksRange","rsDingbatRange","rsLowerRange","rsUpperRange","rsVarRange","rsBreakRange","rsMathOpRange","rsAstral","rsBreak","rsCombo","rsDigits","rsDingbat","rsLower","rsMisc","rsFitz","rsNonAstral","rsRegional","rsSurrPair","rsUpper","rsZWJ","rsMiscLower","rsMiscUpper","rsOptContrLower","rsOptContrUpper","reOptMod","rsModifier","rsOptVar","rsSeq","rsEmoji","rsSymbol","reApos","reComboMark","reUnicode","reUnicodeWord","reHasUnicode","reHasUnicodeWord","contextProps","templateCounter","typedArrayTags","cloneableTags","stringEscapes","freeParseFloat","freeParseInt","freeExports","freeModule","moduleExports","freeProcess","nodeUtil","binding","nodeIsArrayBuffer","isArrayBuffer","nodeIsDate","isDate","nodeIsMap","isMap","nodeIsRegExp","nodeIsSet","isSet","nodeIsTypedArray","isTypedArray","addMapEntry","pair","addSetEntry","arrayAggregator","accumulator","arrayEach","arrayEachRight","arrayEvery","predicate","arrayFilter","resIndex","arrayIncludes","baseIndexOf","arrayIncludesWith","arrayMap","arrayPush","arrayReduce","initAccum","arrayReduceRight","arraySome","asciiSize","baseProperty","baseFindKey","eachFunc","baseFindIndex","fromRight","strictIndexOf","baseIsNaN","baseIndexOfWith","baseMean","baseSum","basePropertyOf","baseReduce","baseTimes","baseUnary","baseValues","cacheHas","charsStartIndex","strSymbols","chrSymbols","charsEndIndex","deburrLetter","escapeHtmlChar","escapeStringChar","chr","hasUnicode","mapToArray","overArg","transform","replaceHolders","placeholder","setToArray","setToPairs","stringSize","lastIndex","unicodeSize","stringToArray","unicodeToArray","asciiToArray","unescapeHtmlChar","runInContext","arrayProto","funcProto","coreJsData","funcToString","idCounter","maskSrcKey","IE_PROTO","objectCtorString","oldDash","reIsNative","Buffer","Uint8Array","allocUnsafe","getPrototype","objectCreate","propertyIsEnumerable","spreadableSymbol","isConcatSpreadable","symIterator","getNative","ctxClearTimeout","ctxNow","ctxSetTimeout","nativeCeil","ceil","nativeFloor","floor","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","isBuffer","nativeIsFinite","nativeJoin","nativeKeys","nativeNow","nativeParseInt","nativeRandom","nativeReverse","DataView","Map","Promise","Set","WeakMap","nativeCreate","metaMap","realNames","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","valueOf","symbolToString","lodash","LazyWrapper","LodashWrapper","wrapperClone","baseCreate","baseLodash","chainAll","__wrapped__","__actions__","__chain__","__index__","__values__","__dir__","__filtered__","__iteratees__","__takeCount__","__views__","Hash","entries","entry","ListCache","MapCache","SetCache","__data__","Stack","arrayLikeKeys","inherited","isArr","isArg","isArguments","isBuff","isType","skipIndexes","isIndex","arraySample","baseRandom","arraySampleSize","shuffleSelf","copyArray","baseClamp","arrayShuffle","assignMergeValue","baseAssignValue","assignValue","objValue","assocIndexOf","baseAggregator","baseEach","baseAssign","copyObject","baseAt","paths","number","lower","upper","baseClone","bitmask","customizer","isDeep","isFlat","isFull","initCloneArray","getTag","isFunc","cloneBuffer","initCloneObject","getSymbolsIn","copySymbolsIn","keysIn","baseAssignIn","getSymbols","copySymbols","cloneFunc","symbol","cloneArrayBuffer","dataView","buffer","byteOffset","byteLength","cloneDataView","cloneTypedArray","cloneMap","regexp","cloneRegExp","cloneSet","initCloneByTag","stacked","getAllKeysIn","getAllKeys","subValue","baseConformsTo","baseDelay","baseDifference","isCommon","valuesLength","outer","valuesIndex","templateSettings","getMapData","LARGE_ARRAY_SIZE","createBaseEach","baseForOwn","baseEachRight","baseForOwnRight","baseEvery","baseExtremum","isSymbol","baseFilter","baseFlatten","isStrict","isFlattenable","baseFor","createBaseFor","baseForRight","baseFunctions","baseGet","castPath","toKey","baseGetAllKeys","keysFunc","symbolsFunc","baseGt","other","baseHas","baseHasIn","baseIntersection","arrays","othLength","othIndex","caches","maxLength","seen","baseInvoke","baseIsArguments","baseIsEqual","equalFunc","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","equalArrays","convert","isPartial","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","objProps","objLength","skipCtor","othValue","compared","objCtor","othCtor","equalObjects","baseIsEqualDeep","baseIsMatch","matchData","noCustomizer","srcValue","COMPARE_PARTIAL_FLAG","baseIsNative","baseIteratee","identity","baseMatchesProperty","baseMatches","property","baseKeys","isPrototype","baseLt","baseMap","getMatchData","matchesStrictComparable","isKey","isStrictComparable","hasIn","baseMerge","srcIndex","mergeFunc","newValue","isTyped","isArrayLikeObject","toPlainObject","baseMergeDeep","baseNth","baseOrderBy","iteratees","orders","getIteratee","criteria","comparer","objCriteria","othCriteria","ordersLength","compareAscending","compareMultiple","baseSortBy","basePickBy","baseSet","basePullAll","basePullAt","indexes","baseUnset","baseRepeat","baseRest","setToString","overRest","baseSample","baseSampleSize","nested","baseSetData","baseSetToString","constant","baseShuffle","baseSlice","baseSome","baseSortedIndex","retHighest","low","mid","baseSortedIndexBy","valIsNaN","valIsNull","valIsSymbol","valIsUndefined","othIsDefined","othIsNull","othIsReflexive","othIsSymbol","setLow","baseSortedUniq","baseToNumber","baseToString","baseUniq","createSet","seenIndex","baseUpdate","updater","baseWhile","isDrop","baseWrapperValue","actions","action","baseXor","baseZipObject","assignFunc","valsLength","castArrayLikeObject","castFunction","stringToPath","castRest","castSlice","arrayBuffer","typedArray","valIsDefined","valIsReflexive","composeArgs","partials","holders","isCurried","argsIndex","argsLength","holdersLength","leftIndex","leftLength","rangeLength","isUncurried","composeArgsRight","holdersIndex","rightIndex","rightLength","createAggregator","initializer","createAssigner","assigner","sources","guard","isIterateeCall","iterable","createCaseFirst","methodName","createCompounder","deburr","createCtor","thisBinding","createFind","findIndexFunc","createFlow","flatRest","funcs","prereq","thru","wrapper","getFuncName","isLaziable","plant","createHybrid","partialsRight","holdersRight","argPos","ary","arity","isAry","isBind","isBindKey","isFlip","getHolder","holdersCount","countHolders","newHolders","createRecurry","arrLength","oldArray","reorder","createInverter","toIteratee","baseInverter","createMathOperation","createOver","arrayFunc","createPadding","chars","charsLength","createRange","toFinite","baseRange","createRelationalOperation","wrapFunc","isCurry","newData","setData","setWrapToString","createRound","precision","createToPairs","baseToPairs","createWrap","srcBitmask","newBitmask","isCombo","mergeData","createCurry","createPartial","createBind","customDefaultsAssignIn","customDefaultsMerge","customOmitClone","arrValue","flatten","otherFunc","getValue","stubArray","hasPath","hasFunc","isLength","ArrayBuffer","ctorString","isMaskable","stubFalse","otherArgs","shortOut","reference","details","insertWrapDetails","updateWrapDetails","getWrapDetails","lastCalled","stamp","rand","memoize","quote","differenceBy","differenceWith","intersection","intersectionBy","intersectionWith","pull","pullAll","pullAt","union","unionBy","unionWith","unzip","group","unzipWith","xor","xorBy","xorWith","zip","zipWith","interceptor","wrapperAt","findLast","forEachRight","invokeMap","keyBy","bindKey","WRAP_BIND_FLAG","debounce","resolver","memoized","Cache","negate","overArgs","transforms","funcsLength","partial","partialRight","rearg","gt","gte","isError","isInteger","isNumber","lt","lte","iteratorToArray","remainder","toLength","isBinary","assignIn","assignInWith","assignWith","defaultsDeep","mergeWith","invertBy","nativeKeysIn","isProto","baseKeysIn","CLONE_DEEP_FLAG","basePick","pickBy","toPairs","toPairsIn","word","capitalize","upperFirst","kebabCase","lowerCase","lowerFirst","snakeCase","startCase","upperCase","hasUnicodeWord","unicodeWords","asciiWords","attempt","bindAll","methodNames","flow","flowRight","methodOf","mixin","over","overEvery","overSome","basePropertyDeep","range","rangeRight","augend","addend","divide","dividend","divisor","multiply","multiplier","multiplicand","round","minuend","subtrahend","castArray","chunk","compact","cond","conforms","baseConforms","curry","curryRight","dropRight","dropRightWhile","dropWhile","fill","baseFill","flatMap","flatMapDeep","flatMapDepth","flattenDeep","flattenDepth","flip","fromPairs","functions","functionsIn","mapKeys","mapValues","matchesProperty","nthArg","omitBy","orderBy","propertyOf","pullAllBy","pullAllWith","sampleSize","setWith","sortedUniq","sortedUniqBy","separator","limit","spread","takeRight","takeRightWhile","takeWhile","tap","throttle","toPath","isArrLike","unary","uniq","uniqBy","uniqWith","update","updateWith","valuesIn","zipObject","zipObjectDeep","entriesIn","extendWith","clamp","cloneDeep","cloneDeepWith","cloneWith","conformsTo","defaultTo","endsWith","findKey","findLastKey","forIn","forInRight","forOwn","forOwnRight","inRange","baseInRange","isBoolean","isElement","isEqualWith","isMatch","isMatchWith","isNative","isNil","isNull","isSafeInteger","isUndefined","isWeakMap","isWeakSet","strictLastIndexOf","maxBy","mean","meanBy","minBy","stubObject","stubString","stubTrue","nth","pad","strLength","padEnd","padStart","radix","floating","repeat","sortedIndex","sortedIndexBy","sortedIndexOf","sortedLastIndex","sortedLastIndexBy","sortedLastIndexOf","startsWith","sum","sumBy","template","isEscaping","isEvaluating","imports","importsKeys","importsValues","interpolate","reDelimiters","evaluate","sourceURL","escapeValue","interpolateValue","esTemplateValue","evaluateValue","variable","times","toLower","toSafeInteger","toUpper","trimEnd","trimStart","omission","search","substring","newEnd","unescape","eachRight","isFilter","takeName","dropName","checkIteratee","isTaker","lodashFunc","retUnwrapped","isLazy","useLazy","isHybrid","isUnwrapped","onlyLazy","chainName","isRight","getView","iterLength","takeCount","iterIndex","commit","wrapped","dummySrc","fixRespimg","findPictureImgs","onResize","mq","ua","navigator","userAgent","HTMLPictureElement","$1","img","sizes","picture","_pfLastSize","imgs","matchMedia","addListener","srcset","eminpx","alwaysCheckWDescriptor","evalId","pf","isSupportTestReady","getImgAttr","setImgAttr","removeImgAttr","cfg","algorithm","srcAttr","srcsetAttr","supportAbort","curSrcProp","regWDesc","regSize","picturefillCFG","fsCss","isVwDirty","cssCache","sizeLengthCache","DPR","devicePixelRatio","units","px","alreadyRun","regexLeadingSpaces","regexLeadingCommasOrSpaces","regexLeadingNotSpaces","regexTrailingCommas","regexNonNegativeInteger","regexFloatingPoint","capture","isSpace","c","regLength","buildStr","image2","width1","isDomReady","timestamp","later","regReady","lastClientWidth","evalCSS","parsedLength","setResolution","candidate","sizesattr","cWidth","calcListLength","res","d","picturefill","plen","reevaluate","reselect","selShort","setupRun","fillImg","teardownRun","ascendingSort","getCandidateForSrc","candidates","parseSet","makeUrl","hasFeature","ns","getTime","substr","supSrcset","supSizes","supPicture","u","setSize","matchesMedia","media","mMQ","calcLength","sourceSizeValue","supportsType","parseSize","sourceSizeStr","cands","collectCharacters","regEx","descriptors","currentDescriptor","inputLength","parseDescriptors","h","desc","lastChar","intVal","floatVal","pError","has1x","parseSrcset","getEmValue","originalHTMLCSS","originalBodyCSS","sourceSizeListStr","uT","winningLength","strValue","unparsedSizesList","unparsedSizesListLength","unparsedSize","lastComponentValue","regexCssLengthWithUnits","regexCssCalc","str","chrctr","component","componentArray","listArray","parenDepth","inComment","pushComponent","pushComponentArray","parseComponentValues","parseSizes","setRes","applySetCandidate","bestCandidate","curSrc","curCan","candidateSrc","abortCurSrc","lowerValue","higherValue","dprValue","isCached","bonusFactor","bonus","meanDensity","imageData","dpr","sets","setSrcToCur","pow","sqrt","setSrc","origWidth","getSet","parseSets","srcsetAttribute","imageSet","isWDescripor","srcsetParsed","hasPicture","pic","getAllSourceElements","supported","extreme","evaled","srcSetCandidates","matchingSet","evaluated","applyBestCandidate","innerWidth","clientWidth","innerHeight","clientHeight","vw","vh","em","rem","fillImgs","typeUri","Image","detectTypeSupport","instanceUid","Slick","dataSettings","accessibility","adaptiveHeight","appendArrows","appendDots","arrows","asNavFor","prevArrow","nextArrow","autoplay","autoplaySpeed","centerMode","centerPadding","cssEase","customPaging","slider","dots","dotsClass","draggable","edgeFriction","fade","focusOnSelect","focusOnChange","infinite","initialSlide","lazyLoad","mobileFirst","pauseOnHover","pauseOnFocus","pauseOnDotsHover","respondTo","responsive","rows","rtl","slide","slidesPerRow","slidesToShow","slidesToScroll","swipe","swipeToSlide","touchMove","touchThreshold","useCSS","useTransform","variableWidth","vertical","verticalSwiping","waitForAnimate","zIndex","initials","animating","dragging","autoPlayTimer","currentDirection","currentLeft","currentSlide","direction","$dots","listWidth","listHeight","loadIndex","$nextArrow","$prevArrow","scrolling","slideCount","slideWidth","$slideTrack","$slides","sliding","slideOffset","swipeLeft","swiping","$list","touchObject","transformsEnabled","unslicked","activeBreakpoint","animType","animProp","breakpoints","breakpointSettings","cssTransitions","focussed","interrupted","paused","positionProp","rowCount","shouldClick","$slider","$slidesCache","transformType","transitionType","visibilityChange","windowWidth","windowTimer","mozHidden","webkitHidden","autoPlay","autoPlayClear","autoPlayIterator","changeSlide","clickHandler","selectHandler","setPosition","swipeHandler","dragHandler","keyHandler","htmlExpr","registerBreakpoints","activateADA","addSlide","slickAdd","markup","addBefore","unload","reinit","animateHeight","targetHeight","outerHeight","animateSlide","targetLeft","animProps","animStart","applyTransition","disableTransition","getNavTarget","slick","slideHandler","transition","slideTo","buildArrows","buildDots","dot","getDotCount","buildOut","setupInfinite","updateDots","setSlideClasses","buildRows","newSlides","numOfSlides","originalSlides","slidesPerSection","row","checkResponsive","forceUpdate","breakpoint","targetBreakpoint","respondToWidth","triggerBreakpoint","sliderWidth","unslick","refresh","dontAnimate","indexOffset","$target","checkNavigable","navigables","prevNavigable","getNavigableIndexes","cleanUpEvents","interrupt","cleanUpSlideEvents","orientationChange","resize","cleanUpRows","fadeSlide","slideIndex","fadeSlideOut","filterSlides","slickFilter","focusHandler","$sf","getCurrent","slickCurrentSlide","breakPoint","counter","pagerQty","getLeft","verticalHeight","targetSlide","coef","verticalOffset","offsetLeft","outerWidth","getOption","slickGetOption","getSlick","getSlideCount","swipedSlide","centerOffset","goTo","slickGoTo","creation","setProps","startLoad","loadSlider","initializeEvents","updateArrows","initADA","numDotGroups","tabControlIndexes","slideControlIndex","ariaButtonControl","mappedSlideIndex","initArrowEvents","initDotEvents","initSlideEvents","initUI","loadRange","rangeStart","rangeEnd","loadImages","imagesScope","imageSource","imageSrcSet","imageSizes","imageToLoad","prevSlide","nextSlide","progressiveLazyLoad","slickNext","pause","slickPause","play","slickPlay","postSlide","slickPrev","tryCount","$imgsToLoad","initializing","lastVisibleIndex","currentBreakpoint","responsiveSettings","windowDelay","removeSlide","slickRemove","removeBefore","removeAll","setCSS","x","y","positionProps","setDimensions","setFade","right","setHeight","setOption","slickSetOption","bodyStyle","WebkitTransition","MozTransition","msTransition","OTransform","perspectiveProperty","webkitPerspective","MozTransform","MozPerspective","webkitTransform","msTransform","allSlides","evenCoef","infiniteCount","targetElement","animSlide","oldSlide","slideLeft","navTarget","swipeDirection","xDist","yDist","r","swipeAngle","startX","curX","startY","curY","atan2","swipeEnd","swipeLength","edgeHit","minSwipe","fingerCount","swipeStart","swipeMove","positionOffset","verticalSwipeLength","unfilterSlides","slickUnfilter","fromBreakpoint","previousUnderscore","ArrayProto","ObjProto","FuncProto","nativeIsArray","nativeBind","_wrapped","optimizeCb","argCount","undefinedOnly","MAX_ARRAY_INDEX","getLength","createReduce","memo","currentKey","lastComputed","shuffled","behavior","pass","shallow","strict","startIndex","output","createPredicateIndexFinder","createIndexFinder","predicateFind","isSorted","executeBound","sourceFunc","boundFunc","callingContext","bound","boundArgs","hasher","address","immediate","callNow","compose","hasEnumBug","nonEnumerableProps","collectNonEnumProps","nonEnumIdx","allKeys","mapObject","extendOwn","oiteratee","aStack","bStack","areArrays","aCtor","bCtor","Int8Array","accum","escapeMap","unescapeMap","createEscaper","escaper","testRegexp","replaceRegexp","fallback","noMatch","escapes","escapeChar","oldSettings","_chain","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","loaded","__webpack_modules__","__esModule","definition","o","globalThis","nmd","AbstractChosen","Chosen","SelectParser","__hasProp","options_index","add_node","add_group","add_option","group_position","_i","_len","_ref","_results","array_index","label","escapeExpression","group_disabled","group_array_index","group_label","unsafe_chars","select_to_array","parser","form_field","browser_is_supported","is_multiple","multiple","set_default_text","set_default_values","set_up_html","register_observers","on_ready","_this","click_test_action","test_active_click","activate_action","activate_field","active_field","mouse_on_container","results_showing","result_highlighted","allow_single_deselect","disable_search_threshold","disable_search","enable_split_word_search","group_search","search_contains","single_backstroke_delete","max_selected_options","inherit_select_classes","display_selected_options","display_disabled_options","include_group_label_in_selected","max_shown_results","Number","POSITIVE_INFINITY","case_sensitive_search","default_text","placeholder_text_multiple","placeholder_text","default_multiple_text","placeholder_text_single","default_single_text","results_none_found","no_results_text","default_no_result_text","choice_label","mouse_enter","mouse_leave","input_focus","container_mousedown","input_blur","blur_test","results_option_build","data_content","shown_results","results_data","result_add_group","result_add_option","choice_build","single_set_selected_text","option_el","search_match","include_option_in_results","search_text","outerHTML","group_el","group_match","active_options","results_update_field","results_reset_cleanup","result_clear_highlight","results_build","winnow_results","reset_single_select_options","results_toggle","results_hide","results_show","results_search","escapedSearchText","regex","results_group","searchText","startpos","zregex","no_results_clear","get_search_text","get_search_regex","search_string_match","update_results_content","no_results","winnow_results_set_highlight","escaped_search_string","regex_anchor","regex_flag","search_string","part","choices_count","selected_option_count","choices_click","is_disabled","keyup_checker","stroke","search_field_scale","backstroke_length","keydown_backstroke","pending_backstroke","result_select","clipboard_event_checker","container_width","search_results_touchstart","touch_started","search_results_mouseover","search_results_touchmove","search_results_mouseout","search_results_touchend","search_results_mouseup","appName","chosen","input_field","$this","_super","ctor","__extends","form_field_jq","current_selectedIndex","is_rtl","container_classes","container_props","dropdown","search_field","search_results","search_no_results","search_choices","search_container","selected_item","set_tab_index","set_label_behavior","container_mouseup","search_results_mousewheel","keydown_checker","search_field_disabled","close_field","results_reset","delta","deltaY","wheelDelta","clear_backstroke","show_search_field_default","active_container","parsing","readOnly","result_do_highlight","high_bottom","high_top","maxHeight","visible_bottom","visible_top","result_highlight","ti","form_field_label","choice","close_link","choice_destroy_link_click","choice_destroy","link","result_deselect","single_deselect_control_build","result_data","deselected","do_high","selected_results","terms","no_results_html","keydown_arrow","next_sib","keyup_arrow","prev_sibs","next_available_destroy","_ref1","f_width","style_block","documentClasses","supportsObjectFit","noObjectFit","bgPicture","isModern","currentSrc","backgroundImage","$inputs","isAndroid","isIE","msie","rv","edge","isIOS","isSamsung","isSmooth","hasTargetEl","harTargetPos","targetPos","$window","topPos","androidVersion","isOldAndroid","targetId","easeOutExpo","ValidateForm","$errorMsg","$submit","shouldScroll","submitText","submittedText","$validateEls","$groups","$prevGroup","emailRegex","numericRegex","phoneRegex","zipRegex","persisted","isEmail","isPhone","isZip","isRequired","numberEvent","getErrorMsgParent","$error","getErrorMsg","showErrorMsg","hideErrorMsg","showGroupErroMsg","hideGroupErrorMsg","toggleErrorMsg","clearError","isFormValid","validateEl","$currentGroup","validateAll","validateGroupEl","condition","isExact","selectedEls","validateGroup","validateAllGroups","submitHandler","$errMsg","smoothScroll","scrollSpeed","newURL","shouldJump","shouldClearHash","linkHtml","$link","$body","scrollTimer","oldWidth","getWinWidth","oldHeight","getWinHeight","handleResize","winWidth","winHeight","widthChanged","heightChanged","Megamenu","section","changeTab","_docClasses","_scrollPos","_saveScrollPos","enable","Modal","isOpen","$prevFocused","$document","$video","videoIsReady","$close","$toggles","toggleText","ariaLabel","modalEvents","$focused","$tabbables","replaceState","$focusEl","ModalToggle","$modal","MultiSelect","chosenOptions","chosenSupported","$select","placeholderValue","Orphans","unorphanize","Poll","pollID","$submitButton","$results","$resultsData","$yesPercentage","$noPercentage","$totalCount","$yesResource","$noResource","$pollQuestionID","showResults","pollResponse","AUTH_TOKEN","yes","no","participants","PublicationDrawer","Quiz","currentQuestion","$panels","showAnswer","nextQuestion","$current","$next","$eligible","$form","$fee","defaultFee","showPanel","$panel","formatDollars","buttonHandler","$targetItem","fee","VideoPromo","videoId","$content","$play","VimeoPlayer","player","Vimeo","Player","byline","color","portrait","getVideoTitle","videoTitle","gtmVideoAction","track10sec","track50percent","seconds","dataLayer","$videos","buildPlayers","jqxhr","exception","YouTubePlayer","collectVars","iframeVars","videoID","getVideoData","items","video","snippet","shouldLazyload","hasLoaded","buildPlayer","playerVars","autohide","controls","iv_load_policy","modestbranding","showinfo","rel","wmode","iframeSrc","YT","videoReady","onPlayerStateChange","getDuration","analyticsPlay","analytics10s","analytics50","analyticsEnd","getPlayerState","PlayerState","PLAYING","monitorVideo","ENDED","getCurrentTime","onYouTubeIframeAPIReady","easeOutQuad","MobileHeaderView","$nav","$navToggle","$navOverlay","navOverlayActiveClass","navActiveClass","toggleActiveClass","itemActiveClass","navToggleText","navCloseText","toggleMainMenu","collapseMainMenu","expandMainMenu","closeSubMenus","toggleSubMenu","$targetMenu","DesktopHeaderView","searchToggleActiveClass","$searchToggle","$searchForm","$searchQuery","closeSearch","toggleSearch","searchIsOpen","openSearch","ContentCarousel","log","require","nameEQ","ca","cookie","readCookie","editableElements","AdminEditLink"],"sourceRoot":""}