{"version":3,"file":"/js/app.js","mappings":"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","sources":["webpack:///webpack/runtime/chunk loaded","webpack:///./node_modules/axios/index.js","webpack:///./node_modules/axios/lib/adapters/xhr.js","webpack:///./node_modules/axios/lib/axios.js","webpack:///./node_modules/axios/lib/cancel/Cancel.js","webpack:///./node_modules/axios/lib/cancel/CancelToken.js","webpack:///./node_modules/axios/lib/cancel/isCancel.js","webpack:///./node_modules/axios/lib/core/Axios.js","webpack:///./node_modules/axios/lib/core/InterceptorManager.js","webpack:///./node_modules/axios/lib/core/buildFullPath.js","webpack:///./node_modules/axios/lib/core/createError.js","webpack:///./node_modules/axios/lib/core/dispatchRequest.js","webpack:///./node_modules/axios/lib/core/enhanceError.js","webpack:///./node_modules/axios/lib/core/mergeConfig.js","webpack:///./node_modules/axios/lib/core/settle.js","webpack:///./node_modules/axios/lib/core/transformData.js","webpack:///./node_modules/axios/lib/defaults.js","webpack:///./node_modules/axios/lib/env/data.js","webpack:///./node_modules/axios/lib/helpers/bind.js","webpack:///./node_modules/axios/lib/helpers/buildURL.js","webpack:///./node_modules/axios/lib/helpers/combineURLs.js","webpack:///./node_modules/axios/lib/helpers/cookies.js","webpack:///./node_modules/axios/lib/helpers/isAbsoluteURL.js","webpack:///./node_modules/axios/lib/helpers/isAxiosError.js","webpack:///./node_modules/axios/lib/helpers/isURLSameOrigin.js","webpack:///./node_modules/axios/lib/helpers/normalizeHeaderName.js","webpack:///./node_modules/axios/lib/helpers/parseHeaders.js","webpack:///./node_modules/axios/lib/helpers/spread.js","webpack:///./node_modules/axios/lib/helpers/validator.js","webpack:///./node_modules/axios/lib/utils.js","webpack:///./resources/js/app.js","webpack:///./resources/js/bootstrap.js","webpack:///./node_modules/filepond-plugin-file-rename/dist/filepond-plugin-file-rename.js","webpack:///./node_modules/filepond/dist/filepond.js","webpack:///./node_modules/jquery/dist/jquery.js","webpack:///./node_modules/lodash/lodash.js","webpack:///./node_modules/process/browser.js","webpack:///webpack/bootstrap","webpack:///webpack/runtime/compat get default export","webpack:///webpack/runtime/define property getters","webpack:///webpack/runtime/global","webpack:///webpack/runtime/hasOwnProperty shorthand","webpack:///webpack/runtime/node module decorator","webpack:///webpack/runtime/jsonp chunk loading","webpack:///webpack/startup"],"sourcesContent":["var deferred = [];\n__webpack_require__.O = (result, chunkIds, fn, priority) => {\n\tif(chunkIds) {\n\t\tpriority = priority || 0;\n\t\tfor(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];\n\t\tdeferred[i] = [chunkIds, fn, priority];\n\t\treturn;\n\t}\n\tvar notFulfilled = Infinity;\n\tfor (var i = 0; i < deferred.length; i++) {\n\t\tvar [chunkIds, fn, priority] = deferred[i];\n\t\tvar fulfilled = true;\n\t\tfor (var j = 0; j < chunkIds.length; j++) {\n\t\t\tif ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {\n\t\t\t\tchunkIds.splice(j--, 1);\n\t\t\t} else {\n\t\t\t\tfulfilled = false;\n\t\t\t\tif(priority < notFulfilled) notFulfilled = priority;\n\t\t\t}\n\t\t}\n\t\tif(fulfilled) {\n\t\t\tdeferred.splice(i--, 1)\n\t\t\tvar r = fn();\n\t\t\tif (r !== undefined) result = r;\n\t\t}\n\t}\n\treturn result;\n};","module.exports = require('./lib/axios');","'use strict';\n\nvar utils = require('./../utils');\nvar settle = require('./../core/settle');\nvar cookies = require('./../helpers/cookies');\nvar buildURL = require('./../helpers/buildURL');\nvar buildFullPath = require('../core/buildFullPath');\nvar parseHeaders = require('./../helpers/parseHeaders');\nvar isURLSameOrigin = require('./../helpers/isURLSameOrigin');\nvar createError = require('../core/createError');\nvar defaults = require('../defaults');\nvar Cancel = require('../cancel/Cancel');\n\nmodule.exports = function xhrAdapter(config) {\n  return new Promise(function dispatchXhrRequest(resolve, reject) {\n    var requestData = config.data;\n    var requestHeaders = config.headers;\n    var responseType = config.responseType;\n    var onCanceled;\n    function done() {\n      if (config.cancelToken) {\n        config.cancelToken.unsubscribe(onCanceled);\n      }\n\n      if (config.signal) {\n        config.signal.removeEventListener('abort', onCanceled);\n      }\n    }\n\n    if (utils.isFormData(requestData)) {\n      delete requestHeaders['Content-Type']; // Let the browser set it\n    }\n\n    var request = new XMLHttpRequest();\n\n    // HTTP basic authentication\n    if (config.auth) {\n      var username = config.auth.username || '';\n      var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';\n      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n    }\n\n    var fullPath = buildFullPath(config.baseURL, config.url);\n    request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);\n\n    // Set the request timeout in MS\n    request.timeout = config.timeout;\n\n    function onloadend() {\n      if (!request) {\n        return;\n      }\n      // Prepare the response\n      var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n      var responseData = !responseType || responseType === 'text' ||  responseType === 'json' ?\n        request.responseText : request.response;\n      var response = {\n        data: responseData,\n        status: request.status,\n        statusText: request.statusText,\n        headers: responseHeaders,\n        config: config,\n        request: request\n      };\n\n      settle(function _resolve(value) {\n        resolve(value);\n        done();\n      }, function _reject(err) {\n        reject(err);\n        done();\n      }, response);\n\n      // Clean up request\n      request = null;\n    }\n\n    if ('onloadend' in request) {\n      // Use onloadend if available\n      request.onloadend = onloadend;\n    } else {\n      // Listen for ready state to emulate onloadend\n      request.onreadystatechange = function handleLoad() {\n        if (!request || request.readyState !== 4) {\n          return;\n        }\n\n        // The request errored out and we didn't get a response, this will be\n        // handled by onerror instead\n        // With one exception: request that using file: protocol, most browsers\n        // will return status as 0 even though it's a successful request\n        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n          return;\n        }\n        // readystate handler is calling before onerror or ontimeout handlers,\n        // so we should call onloadend on the next 'tick'\n        setTimeout(onloadend);\n      };\n    }\n\n    // Handle browser request cancellation (as opposed to a manual cancellation)\n    request.onabort = function handleAbort() {\n      if (!request) {\n        return;\n      }\n\n      reject(createError('Request aborted', config, 'ECONNABORTED', request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle low level network errors\n    request.onerror = function handleError() {\n      // Real errors are hidden from us by the browser\n      // onerror should only fire if it's a network error\n      reject(createError('Network Error', config, null, request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle timeout\n    request.ontimeout = function handleTimeout() {\n      var timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';\n      var transitional = config.transitional || defaults.transitional;\n      if (config.timeoutErrorMessage) {\n        timeoutErrorMessage = config.timeoutErrorMessage;\n      }\n      reject(createError(\n        timeoutErrorMessage,\n        config,\n        transitional.clarifyTimeoutError ? 'ETIMEDOUT' : 'ECONNABORTED',\n        request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Add xsrf header\n    // This is only done if running in a standard browser environment.\n    // Specifically not if we're in a web worker, or react-native.\n    if (utils.isStandardBrowserEnv()) {\n      // Add xsrf header\n      var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ?\n        cookies.read(config.xsrfCookieName) :\n        undefined;\n\n      if (xsrfValue) {\n        requestHeaders[config.xsrfHeaderName] = xsrfValue;\n      }\n    }\n\n    // Add headers to the request\n    if ('setRequestHeader' in request) {\n      utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n          // Remove Content-Type if data is undefined\n          delete requestHeaders[key];\n        } else {\n          // Otherwise add header to the request\n          request.setRequestHeader(key, val);\n        }\n      });\n    }\n\n    // Add withCredentials to request if needed\n    if (!utils.isUndefined(config.withCredentials)) {\n      request.withCredentials = !!config.withCredentials;\n    }\n\n    // Add responseType to request if needed\n    if (responseType && responseType !== 'json') {\n      request.responseType = config.responseType;\n    }\n\n    // Handle progress if needed\n    if (typeof config.onDownloadProgress === 'function') {\n      request.addEventListener('progress', config.onDownloadProgress);\n    }\n\n    // Not all browsers support upload events\n    if (typeof config.onUploadProgress === 'function' && request.upload) {\n      request.upload.addEventListener('progress', config.onUploadProgress);\n    }\n\n    if (config.cancelToken || config.signal) {\n      // Handle cancellation\n      // eslint-disable-next-line func-names\n      onCanceled = function(cancel) {\n        if (!request) {\n          return;\n        }\n        reject(!cancel || (cancel && cancel.type) ? new Cancel('canceled') : cancel);\n        request.abort();\n        request = null;\n      };\n\n      config.cancelToken && config.cancelToken.subscribe(onCanceled);\n      if (config.signal) {\n        config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);\n      }\n    }\n\n    if (!requestData) {\n      requestData = null;\n    }\n\n    // Send the request\n    request.send(requestData);\n  });\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar bind = require('./helpers/bind');\nvar Axios = require('./core/Axios');\nvar mergeConfig = require('./core/mergeConfig');\nvar defaults = require('./defaults');\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n  var context = new Axios(defaultConfig);\n  var instance = bind(Axios.prototype.request, context);\n\n  // Copy axios.prototype to instance\n  utils.extend(instance, Axios.prototype, context);\n\n  // Copy context to instance\n  utils.extend(instance, context);\n\n  // Factory for creating new instances\n  instance.create = function create(instanceConfig) {\n    return createInstance(mergeConfig(defaultConfig, instanceConfig));\n  };\n\n  return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Expose Cancel & CancelToken\naxios.Cancel = require('./cancel/Cancel');\naxios.CancelToken = require('./cancel/CancelToken');\naxios.isCancel = require('./cancel/isCancel');\naxios.VERSION = require('./env/data').version;\n\n// Expose all/spread\naxios.all = function all(promises) {\n  return Promise.all(promises);\n};\naxios.spread = require('./helpers/spread');\n\n// Expose isAxiosError\naxios.isAxiosError = require('./helpers/isAxiosError');\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n","'use strict';\n\n/**\n * A `Cancel` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n */\nfunction Cancel(message) {\n  this.message = message;\n}\n\nCancel.prototype.toString = function toString() {\n  return 'Cancel' + (this.message ? ': ' + this.message : '');\n};\n\nCancel.prototype.__CANCEL__ = true;\n\nmodule.exports = Cancel;\n","'use strict';\n\nvar Cancel = require('./Cancel');\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n  if (typeof executor !== 'function') {\n    throw new TypeError('executor must be a function.');\n  }\n\n  var resolvePromise;\n\n  this.promise = new Promise(function promiseExecutor(resolve) {\n    resolvePromise = resolve;\n  });\n\n  var token = this;\n\n  // eslint-disable-next-line func-names\n  this.promise.then(function(cancel) {\n    if (!token._listeners) return;\n\n    var i;\n    var l = token._listeners.length;\n\n    for (i = 0; i < l; i++) {\n      token._listeners[i](cancel);\n    }\n    token._listeners = null;\n  });\n\n  // eslint-disable-next-line func-names\n  this.promise.then = function(onfulfilled) {\n    var _resolve;\n    // eslint-disable-next-line func-names\n    var promise = new Promise(function(resolve) {\n      token.subscribe(resolve);\n      _resolve = resolve;\n    }).then(onfulfilled);\n\n    promise.cancel = function reject() {\n      token.unsubscribe(_resolve);\n    };\n\n    return promise;\n  };\n\n  executor(function cancel(message) {\n    if (token.reason) {\n      // Cancellation has already been requested\n      return;\n    }\n\n    token.reason = new Cancel(message);\n    resolvePromise(token.reason);\n  });\n}\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n  if (this.reason) {\n    throw this.reason;\n  }\n};\n\n/**\n * Subscribe to the cancel signal\n */\n\nCancelToken.prototype.subscribe = function subscribe(listener) {\n  if (this.reason) {\n    listener(this.reason);\n    return;\n  }\n\n  if (this._listeners) {\n    this._listeners.push(listener);\n  } else {\n    this._listeners = [listener];\n  }\n};\n\n/**\n * Unsubscribe from the cancel signal\n */\n\nCancelToken.prototype.unsubscribe = function unsubscribe(listener) {\n  if (!this._listeners) {\n    return;\n  }\n  var index = this._listeners.indexOf(listener);\n  if (index !== -1) {\n    this._listeners.splice(index, 1);\n  }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n  var cancel;\n  var token = new CancelToken(function executor(c) {\n    cancel = c;\n  });\n  return {\n    token: token,\n    cancel: cancel\n  };\n};\n\nmodule.exports = CancelToken;\n","'use strict';\n\nmodule.exports = function isCancel(value) {\n  return !!(value && value.__CANCEL__);\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar buildURL = require('../helpers/buildURL');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar mergeConfig = require('./mergeConfig');\nvar validator = require('../helpers/validator');\n\nvar validators = validator.validators;\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n  this.defaults = instanceConfig;\n  this.interceptors = {\n    request: new InterceptorManager(),\n    response: new InterceptorManager()\n  };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(configOrUrl, config) {\n  /*eslint no-param-reassign:0*/\n  // Allow for axios('example/url'[, config]) a la fetch API\n  if (typeof configOrUrl === 'string') {\n    config = config || {};\n    config.url = configOrUrl;\n  } else {\n    config = configOrUrl || {};\n  }\n\n  if (!config.url) {\n    throw new Error('Provided config url is not valid');\n  }\n\n  config = mergeConfig(this.defaults, config);\n\n  // Set config.method\n  if (config.method) {\n    config.method = config.method.toLowerCase();\n  } else if (this.defaults.method) {\n    config.method = this.defaults.method.toLowerCase();\n  } else {\n    config.method = 'get';\n  }\n\n  var transitional = config.transitional;\n\n  if (transitional !== undefined) {\n    validator.assertOptions(transitional, {\n      silentJSONParsing: validators.transitional(validators.boolean),\n      forcedJSONParsing: validators.transitional(validators.boolean),\n      clarifyTimeoutError: validators.transitional(validators.boolean)\n    }, false);\n  }\n\n  // filter out skipped interceptors\n  var requestInterceptorChain = [];\n  var synchronousRequestInterceptors = true;\n  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n    if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {\n      return;\n    }\n\n    synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;\n\n    requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  var responseInterceptorChain = [];\n  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n    responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  var promise;\n\n  if (!synchronousRequestInterceptors) {\n    var chain = [dispatchRequest, undefined];\n\n    Array.prototype.unshift.apply(chain, requestInterceptorChain);\n    chain = chain.concat(responseInterceptorChain);\n\n    promise = Promise.resolve(config);\n    while (chain.length) {\n      promise = promise.then(chain.shift(), chain.shift());\n    }\n\n    return promise;\n  }\n\n\n  var newConfig = config;\n  while (requestInterceptorChain.length) {\n    var onFulfilled = requestInterceptorChain.shift();\n    var onRejected = requestInterceptorChain.shift();\n    try {\n      newConfig = onFulfilled(newConfig);\n    } catch (error) {\n      onRejected(error);\n      break;\n    }\n  }\n\n  try {\n    promise = dispatchRequest(newConfig);\n  } catch (error) {\n    return Promise.reject(error);\n  }\n\n  while (responseInterceptorChain.length) {\n    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());\n  }\n\n  return promise;\n};\n\nAxios.prototype.getUri = function getUri(config) {\n  if (!config.url) {\n    throw new Error('Provided config url is not valid');\n  }\n  config = mergeConfig(this.defaults, config);\n  return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\\?/, '');\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, config) {\n    return this.request(mergeConfig(config || {}, {\n      method: method,\n      url: url,\n      data: (config || {}).data\n    }));\n  };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, data, config) {\n    return this.request(mergeConfig(config || {}, {\n      method: method,\n      url: url,\n      data: data\n    }));\n  };\n});\n\nmodule.exports = Axios;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction InterceptorManager() {\n  this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected, options) {\n  this.handlers.push({\n    fulfilled: fulfilled,\n    rejected: rejected,\n    synchronous: options ? options.synchronous : false,\n    runWhen: options ? options.runWhen : null\n  });\n  return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n  if (this.handlers[id]) {\n    this.handlers[id] = null;\n  }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n  utils.forEach(this.handlers, function forEachHandler(h) {\n    if (h !== null) {\n      fn(h);\n    }\n  });\n};\n\nmodule.exports = InterceptorManager;\n","'use strict';\n\nvar isAbsoluteURL = require('../helpers/isAbsoluteURL');\nvar combineURLs = require('../helpers/combineURLs');\n\n/**\n * Creates a new URL by combining the baseURL with the requestedURL,\n * only when the requestedURL is not already an absolute URL.\n * If the requestURL is absolute, this function returns the requestedURL untouched.\n *\n * @param {string} baseURL The base URL\n * @param {string} requestedURL Absolute or relative URL to combine\n * @returns {string} The combined full path\n */\nmodule.exports = function buildFullPath(baseURL, requestedURL) {\n  if (baseURL && !isAbsoluteURL(requestedURL)) {\n    return combineURLs(baseURL, requestedURL);\n  }\n  return requestedURL;\n};\n","'use strict';\n\nvar enhanceError = require('./enhanceError');\n\n/**\n * Create an Error with the specified message, config, error code, request and response.\n *\n * @param {string} message The error message.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nmodule.exports = function createError(message, config, code, request, response) {\n  var error = new Error(message);\n  return enhanceError(error, config, code, request, response);\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar transformData = require('./transformData');\nvar isCancel = require('../cancel/isCancel');\nvar defaults = require('../defaults');\nvar Cancel = require('../cancel/Cancel');\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n  if (config.cancelToken) {\n    config.cancelToken.throwIfRequested();\n  }\n\n  if (config.signal && config.signal.aborted) {\n    throw new Cancel('canceled');\n  }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n  throwIfCancellationRequested(config);\n\n  // Ensure headers exist\n  config.headers = config.headers || {};\n\n  // Transform request data\n  config.data = transformData.call(\n    config,\n    config.data,\n    config.headers,\n    config.transformRequest\n  );\n\n  // Flatten headers\n  config.headers = utils.merge(\n    config.headers.common || {},\n    config.headers[config.method] || {},\n    config.headers\n  );\n\n  utils.forEach(\n    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n    function cleanHeaderConfig(method) {\n      delete config.headers[method];\n    }\n  );\n\n  var adapter = config.adapter || defaults.adapter;\n\n  return adapter(config).then(function onAdapterResolution(response) {\n    throwIfCancellationRequested(config);\n\n    // Transform response data\n    response.data = transformData.call(\n      config,\n      response.data,\n      response.headers,\n      config.transformResponse\n    );\n\n    return response;\n  }, function onAdapterRejection(reason) {\n    if (!isCancel(reason)) {\n      throwIfCancellationRequested(config);\n\n      // Transform response data\n      if (reason && reason.response) {\n        reason.response.data = transformData.call(\n          config,\n          reason.response.data,\n          reason.response.headers,\n          config.transformResponse\n        );\n      }\n    }\n\n    return Promise.reject(reason);\n  });\n};\n","'use strict';\n\n/**\n * Update an Error with the specified config, error code, and response.\n *\n * @param {Error} error The error to update.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n * @returns {Error} The error.\n */\nmodule.exports = function enhanceError(error, config, code, request, response) {\n  error.config = config;\n  if (code) {\n    error.code = code;\n  }\n\n  error.request = request;\n  error.response = response;\n  error.isAxiosError = true;\n\n  error.toJSON = function toJSON() {\n    return {\n      // Standard\n      message: this.message,\n      name: this.name,\n      // Microsoft\n      description: this.description,\n      number: this.number,\n      // Mozilla\n      fileName: this.fileName,\n      lineNumber: this.lineNumber,\n      columnNumber: this.columnNumber,\n      stack: this.stack,\n      // Axios\n      config: this.config,\n      code: this.code,\n      status: this.response && this.response.status ? this.response.status : null\n    };\n  };\n  return error;\n};\n","'use strict';\n\nvar utils = require('../utils');\n\n/**\n * Config-specific merge-function which creates a new config-object\n * by merging two configuration objects together.\n *\n * @param {Object} config1\n * @param {Object} config2\n * @returns {Object} New object resulting from merging config2 to config1\n */\nmodule.exports = function mergeConfig(config1, config2) {\n  // eslint-disable-next-line no-param-reassign\n  config2 = config2 || {};\n  var config = {};\n\n  function getMergedValue(target, source) {\n    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {\n      return utils.merge(target, source);\n    } else if (utils.isPlainObject(source)) {\n      return utils.merge({}, source);\n    } else if (utils.isArray(source)) {\n      return source.slice();\n    }\n    return source;\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDeepProperties(prop) {\n    if (!utils.isUndefined(config2[prop])) {\n      return getMergedValue(config1[prop], config2[prop]);\n    } else if (!utils.isUndefined(config1[prop])) {\n      return getMergedValue(undefined, config1[prop]);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function valueFromConfig2(prop) {\n    if (!utils.isUndefined(config2[prop])) {\n      return getMergedValue(undefined, config2[prop]);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function defaultToConfig2(prop) {\n    if (!utils.isUndefined(config2[prop])) {\n      return getMergedValue(undefined, config2[prop]);\n    } else if (!utils.isUndefined(config1[prop])) {\n      return getMergedValue(undefined, config1[prop]);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDirectKeys(prop) {\n    if (prop in config2) {\n      return getMergedValue(config1[prop], config2[prop]);\n    } else if (prop in config1) {\n      return getMergedValue(undefined, config1[prop]);\n    }\n  }\n\n  var mergeMap = {\n    'url': valueFromConfig2,\n    'method': valueFromConfig2,\n    'data': valueFromConfig2,\n    'baseURL': defaultToConfig2,\n    'transformRequest': defaultToConfig2,\n    'transformResponse': defaultToConfig2,\n    'paramsSerializer': defaultToConfig2,\n    'timeout': defaultToConfig2,\n    'timeoutMessage': defaultToConfig2,\n    'withCredentials': defaultToConfig2,\n    'adapter': defaultToConfig2,\n    'responseType': defaultToConfig2,\n    'xsrfCookieName': defaultToConfig2,\n    'xsrfHeaderName': defaultToConfig2,\n    'onUploadProgress': defaultToConfig2,\n    'onDownloadProgress': defaultToConfig2,\n    'decompress': defaultToConfig2,\n    'maxContentLength': defaultToConfig2,\n    'maxBodyLength': defaultToConfig2,\n    'transport': defaultToConfig2,\n    'httpAgent': defaultToConfig2,\n    'httpsAgent': defaultToConfig2,\n    'cancelToken': defaultToConfig2,\n    'socketPath': defaultToConfig2,\n    'responseEncoding': defaultToConfig2,\n    'validateStatus': mergeDirectKeys\n  };\n\n  utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {\n    var merge = mergeMap[prop] || mergeDeepProperties;\n    var configValue = merge(prop);\n    (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);\n  });\n\n  return config;\n};\n","'use strict';\n\nvar createError = require('./createError');\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n  var validateStatus = response.config.validateStatus;\n  if (!response.status || !validateStatus || validateStatus(response.status)) {\n    resolve(response);\n  } else {\n    reject(createError(\n      'Request failed with status code ' + response.status,\n      response.config,\n      null,\n      response.request,\n      response\n    ));\n  }\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar defaults = require('./../defaults');\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, fns) {\n  var context = this || defaults;\n  /*eslint no-param-reassign:0*/\n  utils.forEach(fns, function transform(fn) {\n    data = fn.call(context, data, headers);\n  });\n\n  return data;\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar normalizeHeaderName = require('./helpers/normalizeHeaderName');\nvar enhanceError = require('./core/enhanceError');\n\nvar DEFAULT_CONTENT_TYPE = {\n  'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n    headers['Content-Type'] = value;\n  }\n}\n\nfunction getDefaultAdapter() {\n  var adapter;\n  if (typeof XMLHttpRequest !== 'undefined') {\n    // For browsers use XHR adapter\n    adapter = require('./adapters/xhr');\n  } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {\n    // For node use HTTP adapter\n    adapter = require('./adapters/http');\n  }\n  return adapter;\n}\n\nfunction stringifySafely(rawValue, parser, encoder) {\n  if (utils.isString(rawValue)) {\n    try {\n      (parser || JSON.parse)(rawValue);\n      return utils.trim(rawValue);\n    } catch (e) {\n      if (e.name !== 'SyntaxError') {\n        throw e;\n      }\n    }\n  }\n\n  return (encoder || JSON.stringify)(rawValue);\n}\n\nvar defaults = {\n\n  transitional: {\n    silentJSONParsing: true,\n    forcedJSONParsing: true,\n    clarifyTimeoutError: false\n  },\n\n  adapter: getDefaultAdapter(),\n\n  transformRequest: [function transformRequest(data, headers) {\n    normalizeHeaderName(headers, 'Accept');\n    normalizeHeaderName(headers, 'Content-Type');\n\n    if (utils.isFormData(data) ||\n      utils.isArrayBuffer(data) ||\n      utils.isBuffer(data) ||\n      utils.isStream(data) ||\n      utils.isFile(data) ||\n      utils.isBlob(data)\n    ) {\n      return data;\n    }\n    if (utils.isArrayBufferView(data)) {\n      return data.buffer;\n    }\n    if (utils.isURLSearchParams(data)) {\n      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n      return data.toString();\n    }\n    if (utils.isObject(data) || (headers && headers['Content-Type'] === 'application/json')) {\n      setContentTypeIfUnset(headers, 'application/json');\n      return stringifySafely(data);\n    }\n    return data;\n  }],\n\n  transformResponse: [function transformResponse(data) {\n    var transitional = this.transitional || defaults.transitional;\n    var silentJSONParsing = transitional && transitional.silentJSONParsing;\n    var forcedJSONParsing = transitional && transitional.forcedJSONParsing;\n    var strictJSONParsing = !silentJSONParsing && this.responseType === 'json';\n\n    if (strictJSONParsing || (forcedJSONParsing && utils.isString(data) && data.length)) {\n      try {\n        return JSON.parse(data);\n      } catch (e) {\n        if (strictJSONParsing) {\n          if (e.name === 'SyntaxError') {\n            throw enhanceError(e, this, 'E_JSON_PARSE');\n          }\n          throw e;\n        }\n      }\n    }\n\n    return data;\n  }],\n\n  /**\n   * A timeout in milliseconds to abort a request. If set to 0 (default) a\n   * timeout is not created.\n   */\n  timeout: 0,\n\n  xsrfCookieName: 'XSRF-TOKEN',\n  xsrfHeaderName: 'X-XSRF-TOKEN',\n\n  maxContentLength: -1,\n  maxBodyLength: -1,\n\n  validateStatus: function validateStatus(status) {\n    return status >= 200 && status < 300;\n  },\n\n  headers: {\n    common: {\n      'Accept': 'application/json, text/plain, */*'\n    }\n  }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n  defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n","module.exports = {\n  \"version\": \"0.25.0\"\n};","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n  return function wrap() {\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n    return fn.apply(thisArg, args);\n  };\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction encode(val) {\n  return encodeURIComponent(val).\n    replace(/%3A/gi, ':').\n    replace(/%24/g, '$').\n    replace(/%2C/gi, ',').\n    replace(/%20/g, '+').\n    replace(/%5B/gi, '[').\n    replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, paramsSerializer) {\n  /*eslint no-param-reassign:0*/\n  if (!params) {\n    return url;\n  }\n\n  var serializedParams;\n  if (paramsSerializer) {\n    serializedParams = paramsSerializer(params);\n  } else if (utils.isURLSearchParams(params)) {\n    serializedParams = params.toString();\n  } else {\n    var parts = [];\n\n    utils.forEach(params, function serialize(val, key) {\n      if (val === null || typeof val === 'undefined') {\n        return;\n      }\n\n      if (utils.isArray(val)) {\n        key = key + '[]';\n      } else {\n        val = [val];\n      }\n\n      utils.forEach(val, function parseValue(v) {\n        if (utils.isDate(v)) {\n          v = v.toISOString();\n        } else if (utils.isObject(v)) {\n          v = JSON.stringify(v);\n        }\n        parts.push(encode(key) + '=' + encode(v));\n      });\n    });\n\n    serializedParams = parts.join('&');\n  }\n\n  if (serializedParams) {\n    var hashmarkIndex = url.indexOf('#');\n    if (hashmarkIndex !== -1) {\n      url = url.slice(0, hashmarkIndex);\n    }\n\n    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n  }\n\n  return url;\n};\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n  return relativeURL\n    ? baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '')\n    : baseURL;\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n  utils.isStandardBrowserEnv() ?\n\n  // Standard browser envs support document.cookie\n    (function standardBrowserEnv() {\n      return {\n        write: function write(name, value, expires, path, domain, secure) {\n          var cookie = [];\n          cookie.push(name + '=' + encodeURIComponent(value));\n\n          if (utils.isNumber(expires)) {\n            cookie.push('expires=' + new Date(expires).toGMTString());\n          }\n\n          if (utils.isString(path)) {\n            cookie.push('path=' + path);\n          }\n\n          if (utils.isString(domain)) {\n            cookie.push('domain=' + domain);\n          }\n\n          if (secure === true) {\n            cookie.push('secure');\n          }\n\n          document.cookie = cookie.join('; ');\n        },\n\n        read: function read(name) {\n          var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n          return (match ? decodeURIComponent(match[3]) : null);\n        },\n\n        remove: function remove(name) {\n          this.write(name, '', Date.now() - 86400000);\n        }\n      };\n    })() :\n\n  // Non standard browser env (web workers, react-native) lack needed support.\n    (function nonStandardBrowserEnv() {\n      return {\n        write: function write() {},\n        read: function read() { return null; },\n        remove: function remove() {}\n      };\n    })()\n);\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nmodule.exports = function isAbsoluteURL(url) {\n  // A URL is considered absolute if it begins with \"<scheme>://\" or \"//\" (protocol-relative URL).\n  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n  // by any combination of letters, digits, plus, period, or hyphen.\n  return /^([a-z][a-z\\d+\\-.]*:)?\\/\\//i.test(url);\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Determines whether the payload is an error thrown by Axios\n *\n * @param {*} payload The value to test\n * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false\n */\nmodule.exports = function isAxiosError(payload) {\n  return utils.isObject(payload) && (payload.isAxiosError === true);\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n  utils.isStandardBrowserEnv() ?\n\n  // Standard browser envs have full support of the APIs needed to test\n  // whether the request URL is of the same origin as current location.\n    (function standardBrowserEnv() {\n      var msie = /(msie|trident)/i.test(navigator.userAgent);\n      var urlParsingNode = document.createElement('a');\n      var originURL;\n\n      /**\n    * Parse a URL to discover it's components\n    *\n    * @param {String} url The URL to be parsed\n    * @returns {Object}\n    */\n      function resolveURL(url) {\n        var href = url;\n\n        if (msie) {\n        // IE needs attribute set twice to normalize properties\n          urlParsingNode.setAttribute('href', href);\n          href = urlParsingNode.href;\n        }\n\n        urlParsingNode.setAttribute('href', href);\n\n        // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n        return {\n          href: urlParsingNode.href,\n          protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n          host: urlParsingNode.host,\n          search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n          hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n          hostname: urlParsingNode.hostname,\n          port: urlParsingNode.port,\n          pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n            urlParsingNode.pathname :\n            '/' + urlParsingNode.pathname\n        };\n      }\n\n      originURL = resolveURL(window.location.href);\n\n      /**\n    * Determine if a URL shares the same origin as the current location\n    *\n    * @param {String} requestURL The URL to test\n    * @returns {boolean} True if URL shares the same origin, otherwise false\n    */\n      return function isURLSameOrigin(requestURL) {\n        var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n        return (parsed.protocol === originURL.protocol &&\n            parsed.host === originURL.host);\n      };\n    })() :\n\n  // Non standard browser envs (web workers, react-native) lack needed support.\n    (function nonStandardBrowserEnv() {\n      return function isURLSameOrigin() {\n        return true;\n      };\n    })()\n);\n","'use strict';\n\nvar utils = require('../utils');\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n  utils.forEach(headers, function processHeader(value, name) {\n    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n      headers[normalizedName] = value;\n      delete headers[name];\n    }\n  });\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n// Headers whose duplicates are ignored by node\n// c.f. https://nodejs.org/api/http.html#http_message_headers\nvar ignoreDuplicateOf = [\n  'age', 'authorization', 'content-length', 'content-type', 'etag',\n  'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',\n  'last-modified', 'location', 'max-forwards', 'proxy-authorization',\n  'referer', 'retry-after', 'user-agent'\n];\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n  var parsed = {};\n  var key;\n  var val;\n  var i;\n\n  if (!headers) { return parsed; }\n\n  utils.forEach(headers.split('\\n'), function parser(line) {\n    i = line.indexOf(':');\n    key = utils.trim(line.substr(0, i)).toLowerCase();\n    val = utils.trim(line.substr(i + 1));\n\n    if (key) {\n      if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {\n        return;\n      }\n      if (key === 'set-cookie') {\n        parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);\n      } else {\n        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n      }\n    }\n  });\n\n  return parsed;\n};\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n *  ```js\n *  function f(x, y, z) {}\n *  var args = [1, 2, 3];\n *  f.apply(null, args);\n *  ```\n *\n * With `spread` this example can be re-written.\n *\n *  ```js\n *  spread(function(x, y, z) {})([1, 2, 3]);\n *  ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n  return function wrap(arr) {\n    return callback.apply(null, arr);\n  };\n};\n","'use strict';\n\nvar VERSION = require('../env/data').version;\n\nvar validators = {};\n\n// eslint-disable-next-line func-names\n['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach(function(type, i) {\n  validators[type] = function validator(thing) {\n    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;\n  };\n});\n\nvar deprecatedWarnings = {};\n\n/**\n * Transitional option validator\n * @param {function|boolean?} validator - set to false if the transitional option has been removed\n * @param {string?} version - deprecated version / removed since version\n * @param {string?} message - some message with additional info\n * @returns {function}\n */\nvalidators.transitional = function transitional(validator, version, message) {\n  function formatMessage(opt, desc) {\n    return '[Axios v' + VERSION + '] Transitional option \\'' + opt + '\\'' + desc + (message ? '. ' + message : '');\n  }\n\n  // eslint-disable-next-line func-names\n  return function(value, opt, opts) {\n    if (validator === false) {\n      throw new Error(formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')));\n    }\n\n    if (version && !deprecatedWarnings[opt]) {\n      deprecatedWarnings[opt] = true;\n      // eslint-disable-next-line no-console\n      console.warn(\n        formatMessage(\n          opt,\n          ' has been deprecated since v' + version + ' and will be removed in the near future'\n        )\n      );\n    }\n\n    return validator ? validator(value, opt, opts) : true;\n  };\n};\n\n/**\n * Assert object's properties type\n * @param {object} options\n * @param {object} schema\n * @param {boolean?} allowUnknown\n */\n\nfunction assertOptions(options, schema, allowUnknown) {\n  if (typeof options !== 'object') {\n    throw new TypeError('options must be an object');\n  }\n  var keys = Object.keys(options);\n  var i = keys.length;\n  while (i-- > 0) {\n    var opt = keys[i];\n    var validator = schema[opt];\n    if (validator) {\n      var value = options[opt];\n      var result = value === undefined || validator(value, opt, options);\n      if (result !== true) {\n        throw new TypeError('option ' + opt + ' must be ' + result);\n      }\n      continue;\n    }\n    if (allowUnknown !== true) {\n      throw Error('Unknown option ' + opt);\n    }\n  }\n}\n\nmodule.exports = {\n  assertOptions: assertOptions,\n  validators: validators\n};\n","'use strict';\n\nvar bind = require('./helpers/bind');\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n  return Array.isArray(val);\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n  return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is a Buffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Buffer, otherwise false\n */\nfunction isBuffer(val) {\n  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)\n    && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nfunction isArrayBuffer(val) {\n  return toString.call(val) === '[object ArrayBuffer]';\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(val) {\n  return toString.call(val) === '[object FormData]';\n}\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n  var result;\n  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n    result = ArrayBuffer.isView(val);\n  } else {\n    result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));\n  }\n  return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n  return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n  return typeof val === 'number';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n  return val !== null && typeof val === 'object';\n}\n\n/**\n * Determine if a value is a plain Object\n *\n * @param {Object} val The value to test\n * @return {boolean} True if value is a plain Object, otherwise false\n */\nfunction isPlainObject(val) {\n  if (toString.call(val) !== '[object Object]') {\n    return false;\n  }\n\n  var prototype = Object.getPrototypeOf(val);\n  return prototype === null || prototype === Object.prototype;\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nfunction isDate(val) {\n  return toString.call(val) === '[object Date]';\n}\n\n/**\n * Determine if a value is a File\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nfunction isFile(val) {\n  return toString.call(val) === '[object File]';\n}\n\n/**\n * Determine if a value is a Blob\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nfunction isBlob(val) {\n  return toString.call(val) === '[object Blob]';\n}\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n  return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n  return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nfunction isURLSearchParams(val) {\n  return toString.call(val) === '[object URLSearchParams]';\n}\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n  return str.trim ? str.trim() : str.replace(/^\\s+|\\s+$/g, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n *  typeof window -> undefined\n *  typeof document -> undefined\n *\n * react-native:\n *  navigator.product -> 'ReactNative'\n * nativescript\n *  navigator.product -> 'NativeScript' or 'NS'\n */\nfunction isStandardBrowserEnv() {\n  if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||\n                                           navigator.product === 'NativeScript' ||\n                                           navigator.product === 'NS')) {\n    return false;\n  }\n  return (\n    typeof window !== 'undefined' &&\n    typeof document !== 'undefined'\n  );\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n  // Don't bother if no value provided\n  if (obj === null || typeof obj === 'undefined') {\n    return;\n  }\n\n  // Force an array if not already something iterable\n  if (typeof obj !== 'object') {\n    /*eslint no-param-reassign:0*/\n    obj = [obj];\n  }\n\n  if (isArray(obj)) {\n    // Iterate over array values\n    for (var i = 0, l = obj.length; i < l; i++) {\n      fn.call(null, obj[i], i, obj);\n    }\n  } else {\n    // Iterate over object keys\n    for (var key in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, key)) {\n        fn.call(null, obj[key], key, obj);\n      }\n    }\n  }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n  var result = {};\n  function assignValue(val, key) {\n    if (isPlainObject(result[key]) && isPlainObject(val)) {\n      result[key] = merge(result[key], val);\n    } else if (isPlainObject(val)) {\n      result[key] = merge({}, val);\n    } else if (isArray(val)) {\n      result[key] = val.slice();\n    } else {\n      result[key] = val;\n    }\n  }\n\n  for (var i = 0, l = arguments.length; i < l; i++) {\n    forEach(arguments[i], assignValue);\n  }\n  return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n  forEach(b, function assignValue(val, key) {\n    if (thisArg && typeof val === 'function') {\n      a[key] = bind(val, thisArg);\n    } else {\n      a[key] = val;\n    }\n  });\n  return a;\n}\n\n/**\n * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)\n *\n * @param {string} content with BOM\n * @return {string} content value without BOM\n */\nfunction stripBOM(content) {\n  if (content.charCodeAt(0) === 0xFEFF) {\n    content = content.slice(1);\n  }\n  return content;\n}\n\nmodule.exports = {\n  isArray: isArray,\n  isArrayBuffer: isArrayBuffer,\n  isBuffer: isBuffer,\n  isFormData: isFormData,\n  isArrayBufferView: isArrayBufferView,\n  isString: isString,\n  isNumber: isNumber,\n  isObject: isObject,\n  isPlainObject: isPlainObject,\n  isUndefined: isUndefined,\n  isDate: isDate,\n  isFile: isFile,\n  isBlob: isBlob,\n  isFunction: isFunction,\n  isStream: isStream,\n  isURLSearchParams: isURLSearchParams,\n  isStandardBrowserEnv: isStandardBrowserEnv,\n  forEach: forEach,\n  merge: merge,\n  extend: extend,\n  trim: trim,\n  stripBOM: stripBOM\n};\n","require('./bootstrap');\r\nimport * as FilePond from 'filepond';\r\n\r\nimport FilePondPluginFileRename from 'filepond-plugin-file-rename';\r\nFilePond.registerPlugin(FilePondPluginFileRename);\r\n\r\nwindow.FilePond = FilePond;\r\ntry {\r\n    window.$ = window.jQuery = require('jquery');\r\n} catch (error) {\r\n    console.log(error);\r\n}\r\nlet admin_sidenav = {\r\n    init: function () {\r\n        this.cacheDom();\r\n        this.bindEvents();\r\n    },\r\n    cacheDom: function () {\r\n        this.$nav_container = $(\"#admin_sidebar_main\");\r\n        this.$nav_button_expandable = $(\".nav-expandable\");\r\n        this.$admin_sidebar_nav_open = $(\"#admin_sidebar_nav_open\");\r\n        this.$admin_sidebar_nav_close = $(\"#admin_sidebar_nav_close\");\r\n        this.$admin_nav_toggle = $('.admin-nav-toggle');\r\n    },\r\n    bindEvents: function () {\r\n        this.$admin_nav_toggle.on(\"click\", this.toggleNav.bind(this));\r\n        this.$nav_button_expandable.on(\"click\", this.toggleMenuItem);\r\n    },\r\n    toggleNav: function () {\r\n        console.log('toggleNav');\r\n        this.$nav_container.toggleClass(\"-translate-x-full\");\r\n        this.$nav_container.toggleClass(\"translate-x-0\");\r\n        this.$admin_sidebar_nav_open.toggleClass(\"hidden\");\r\n        this.$admin_sidebar_nav_close.toggleClass(\"hidden\");\r\n    },\r\n    toggleMenuItem: function () {\r\n        let $this = $(this);\r\n        console.log('toggleMenuItem');\r\n        $this.find('i.fa-chevron-down').toggleClass(\"rotate-180\");\r\n        $this.next('.nav-sub').toggleClass(\"hidden\");\r\n    },\r\n};\r\nlet modal_ui_triggers = {\r\n    init: function () {\r\n        this.bindEvents();\r\n    },\r\n    cacheDom: function () {\r\n    },\r\n    bindEvents: function () {\r\n        $(document).on('click', '.open-modal', this.openModal);\r\n        $(document).on('click', '.close-modal', this.closeModal);\r\n    },\r\n    openModal: function () {\r\n        console.log('OPEN MODAL - ' + $(this).attr('data-target-modal'));\r\n        $('#' + $(this).attr('data-target-modal')).removeClass('hidden');\r\n    },\r\n    closeModal: function () {\r\n        $('#' + $(this).attr('data-target-modal')).addClass('hidden');\r\n    },\r\n};\r\nlet toggle_ui_triggers = {\r\n    init: function () {\r\n        this.cacheDom();\r\n        this.bindEvents();\r\n    },\r\n    cacheDom: function () {\r\n        this.$triggers = $(\".toggle-trigger\");\r\n        this.$targets = $(\".toggle-target\");\r\n\r\n    },\r\n    bindEvents: function () {\r\n        this.$triggers.on(\"click\", this.toggleTarget);\r\n        $(document).on('click', '.toggle-close', this.closeAll.bind(this));\r\n    },\r\n    toggleTarget: function () {\r\n        let $target = $('.' + $(this).attr('data-target'));\r\n        $target.toggleClass('invisible');\r\n        $target.toggleClass('visible');\r\n        setTimeout(function () {\r\n            if ($target.hasClass('visible')) {\r\n                $('body').addClass('toggle-close');\r\n            } else {\r\n                $('body').removeClass('toggle-close');\r\n            }\r\n        }, 50);\r\n    },\r\n    closeAll: function () {\r\n        $('body').removeClass('toggle-close');\r\n        setTimeout(function () {\r\n            toggle_ui_triggers.$targets.addClass('invisible');\r\n            toggle_ui_triggers.$targets.removeClass('visible');\r\n        }, 100);\r\n    }\r\n};\r\n$(document).ready(function () {\r\n    //admin_sidenav.init();\r\n    modal_ui_triggers.init();\r\n    toggle_ui_triggers.init();\r\n});\r\n\r\n\r\nlet top_nav_handler = {\r\n    dropdownHandler: function (element) {\r\n        let single = element.getElementsByTagName(\"ul\")[0];\r\n        single.classList.toggle(\"hidden\");\r\n    },\r\n    MenuHandler: function (el, val) {\r\n        let MainList = el.parentElement.parentElement.getElementsByTagName(\"ul\")[0];\r\n        let closeIcon = el.parentElement.parentElement.getElementsByClassName(\"close-m-menu\")[0];\r\n        let showIcon = el.parentElement.parentElement.getElementsByClassName(\"show-m-menu\")[0];\r\n        if (val) {\r\n            MainList.classList.remove(\"hidden\");\r\n            el.classList.add(\"hidden\");\r\n            closeIcon.classList.remove(\"hidden\");\r\n        } else {\r\n            showIcon.classList.remove(\"hidden\");\r\n            MainList.classList.add(\"hidden\");\r\n            el.classList.add(\"hidden\");\r\n        }\r\n    },\r\n};\r\nwindow.top_nav_handler = top_nav_handler;\r\n\r\n\r\n\r\nwindow.activeFolderID = null;\r\n/*document.addEventListener('livewire:load', function () {\r\n    activeFolderID = @this.activeFolderID;\r\n})*/\r\n\r\n\r\n$(document).ready(function () {\r\n    //Load active folder from query string if present\r\n    if (window.location.pathname === '/') {\r\n        const queryString = window.location.search;\r\n        const urlParams = new URLSearchParams(queryString);\r\n\r\n        if (urlParams.has('view')) {\r\n            window.activeFolderID = parseInt(urlParams.get('view'));\r\n        }else{\r\n            window.activeFolderID = null;\r\n        }\r\n    }\r\n    Livewire.on('changeFolder', folderId => {\r\n        if(typeof folderId === 'undefined') {\r\n            folderId = null;\r\n        }\r\n        window.activeFolderID = folderId;\r\n    });\r\n\r\n    document.addEventListener('FilePond:addfilestart', (e) => {\r\n        let fileTitles = jQuery('.filepond--file-info-main').not('.cleared-folder-id');\r\n        fileTitles.each(function () {\r\n            let $this = $(this);\r\n\r\n            $this.html($this.html().split('_')[1]);\r\n        });\r\n    });\r\n});\r\n","window._ = require('lodash');\r\n\r\n/**\r\n * We'll load the axios HTTP library which allows us to easily issue requests\r\n * to our Laravel back-end. This library automatically handles sending the\r\n * CSRF token as a header based on the value of the \"XSRF\" token cookie.\r\n */\r\n\r\nwindow.axios = require('axios');\r\n\r\nwindow.axios.defaults.headers.common['X-Requested-With'] = 'XMLHttpRequest';\r\n\r\n/**\r\n * Echo exposes an expressive API for subscribing to channels and listening\r\n * for events that are broadcast by Laravel. Echo and event broadcasting\r\n * allows your team to easily build robust real-time web applications.\r\n */\r\n\r\n// import Echo from 'laravel-echo';\r\n\r\n// window.Pusher = require('pusher-js');\r\n\r\n// window.Echo = new Echo({\r\n//     broadcaster: 'pusher',\r\n//     key: process.env.MIX_PUSHER_APP_KEY,\r\n//     cluster: process.env.MIX_PUSHER_APP_CLUSTER,\r\n//     forceTLS: true\r\n// });\r\n","/*!\n * FilePondPluginFileRename 1.1.8\n * Licensed under MIT, https://opensource.org/licenses/MIT/\n * Please visit https://pqina.nl/filepond/ for details.\n */\n\n/* eslint-disable */\n\n(function(global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined'\n    ? (module.exports = factory())\n    : typeof define === 'function' && define.amd\n    ? define(factory)\n    : ((global = global || self),\n      (global.FilePondPluginFileRename = factory()));\n})(this, function() {\n  'use strict';\n\n  var plugin = function plugin(_ref) {\n    var addFilter = _ref.addFilter,\n      utils = _ref.utils;\n\n    // get quick reference to Type utils\n    var Type = utils.Type,\n      renameFile = utils.renameFile,\n      isFile = utils.isFile,\n      getExtensionFromFilename = utils.getExtensionFromFilename,\n      getFilenameWithoutExtension = utils.getFilenameWithoutExtension;\n\n    // called for each file that is loaded\n    // right before it is set to the item state\n    // should return a promise\n    addFilter('LOAD_FILE', function(file, _ref2) {\n      var query = _ref2.query;\n      return new Promise(function(resolve, reject) {\n        // reject\n        var allowFileRename = query('GET_ALLOW_FILE_RENAME');\n        var renameFunction = query('GET_FILE_RENAME_FUNCTION');\n        if (!isFile(file) || !allowFileRename || !renameFunction) {\n          resolve(file);\n          return;\n        }\n\n        // can either return a name or a promise\n        var newFilename = renameFunction({\n          name: file.name,\n          basename: getFilenameWithoutExtension(file.name),\n          extension: '.'.concat(getExtensionFromFilename(file.name))\n        });\n\n        // renames the file and resolves\n        var rename = function rename(name) {\n          resolve(renameFile(file, name));\n        };\n\n        // has returned new filename immidiately\n        if (typeof newFilename === 'string') {\n          rename(newFilename);\n          return;\n        }\n\n        // is promise\n        newFilename.then(rename);\n      });\n    });\n\n    return {\n      options: {\n        // Enable or disable file renaming\n        allowFileRename: [true, Type.BOOLEAN],\n\n        // Rename function to run for this\n        fileRenameFunction: [null, Type.FUNCTION]\n      }\n    };\n  };\n\n  // fire pluginloaded event if running in browser, this allows registering the plugin when using async script tags\n  var isBrowser =\n    typeof window !== 'undefined' && typeof window.document !== 'undefined';\n  if (isBrowser) {\n    document.dispatchEvent(\n      new CustomEvent('FilePond:pluginloaded', { detail: plugin })\n    );\n  }\n\n  return plugin;\n});\n","/*!\n * FilePond 4.30.4\n * Licensed under MIT, https://opensource.org/licenses/MIT/\n * Please visit https://pqina.nl/filepond/ for details.\n */\n\n/* eslint-disable */\n\n(function(global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined'\n        ? factory(exports)\n        : typeof define === 'function' && define.amd\n        ? define(['exports'], factory)\n        : ((global = global || self), factory((global.FilePond = {})));\n})(this, function(exports) {\n    'use strict';\n\n    var isNode = function isNode(value) {\n        return value instanceof HTMLElement;\n    };\n\n    var createStore = function createStore(initialState) {\n        var queries = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n        var actions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];\n        // internal state\n        var state = Object.assign({}, initialState);\n\n        // contains all actions for next frame, is clear when actions are requested\n        var actionQueue = [];\n        var dispatchQueue = [];\n\n        // returns a duplicate of the current state\n        var getState = function getState() {\n            return Object.assign({}, state);\n        };\n\n        // returns a duplicate of the actions array and clears the actions array\n        var processActionQueue = function processActionQueue() {\n            // create copy of actions queue\n            var queue = [].concat(actionQueue);\n\n            // clear actions queue (we don't want no double actions)\n            actionQueue.length = 0;\n\n            return queue;\n        };\n\n        // processes actions that might block the main UI thread\n        var processDispatchQueue = function processDispatchQueue() {\n            // create copy of actions queue\n            var queue = [].concat(dispatchQueue);\n\n            // clear actions queue (we don't want no double actions)\n            dispatchQueue.length = 0;\n\n            // now dispatch these actions\n            queue.forEach(function(_ref) {\n                var type = _ref.type,\n                    data = _ref.data;\n                dispatch(type, data);\n            });\n        };\n\n        // adds a new action, calls its handler and\n        var dispatch = function dispatch(type, data, isBlocking) {\n            // is blocking action (should never block if document is hidden)\n            if (isBlocking && !document.hidden) {\n                dispatchQueue.push({ type: type, data: data });\n                return;\n            }\n\n            // if this action has a handler, handle the action\n            if (actionHandlers[type]) {\n                actionHandlers[type](data);\n            }\n\n            // now add action\n            actionQueue.push({\n                type: type,\n                data: data,\n            });\n        };\n\n        var query = function query(str) {\n            var _queryHandles;\n            for (\n                var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1;\n                _key < _len;\n                _key++\n            ) {\n                args[_key - 1] = arguments[_key];\n            }\n            return queryHandles[str]\n                ? (_queryHandles = queryHandles)[str].apply(_queryHandles, args)\n                : null;\n        };\n\n        var api = {\n            getState: getState,\n            processActionQueue: processActionQueue,\n            processDispatchQueue: processDispatchQueue,\n            dispatch: dispatch,\n            query: query,\n        };\n\n        var queryHandles = {};\n        queries.forEach(function(query) {\n            queryHandles = Object.assign({}, query(state), {}, queryHandles);\n        });\n\n        var actionHandlers = {};\n        actions.forEach(function(action) {\n            actionHandlers = Object.assign({}, action(dispatch, query, state), {}, actionHandlers);\n        });\n\n        return api;\n    };\n\n    var defineProperty = function defineProperty(obj, property, definition) {\n        if (typeof definition === 'function') {\n            obj[property] = definition;\n            return;\n        }\n        Object.defineProperty(obj, property, Object.assign({}, definition));\n    };\n\n    var forin = function forin(obj, cb) {\n        for (var key in obj) {\n            if (!obj.hasOwnProperty(key)) {\n                continue;\n            }\n\n            cb(key, obj[key]);\n        }\n    };\n\n    var createObject = function createObject(definition) {\n        var obj = {};\n        forin(definition, function(property) {\n            defineProperty(obj, property, definition[property]);\n        });\n        return obj;\n    };\n\n    var attr = function attr(node, name) {\n        var value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n        if (value === null) {\n            return node.getAttribute(name) || node.hasAttribute(name);\n        }\n        node.setAttribute(name, value);\n    };\n\n    var ns = 'http://www.w3.org/2000/svg';\n    var svgElements = ['svg', 'path']; // only svg elements used\n\n    var isSVGElement = function isSVGElement(tag) {\n        return svgElements.includes(tag);\n    };\n\n    var createElement = function createElement(tag, className) {\n        var attributes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n        if (typeof className === 'object') {\n            attributes = className;\n            className = null;\n        }\n        var element = isSVGElement(tag)\n            ? document.createElementNS(ns, tag)\n            : document.createElement(tag);\n        if (className) {\n            if (isSVGElement(tag)) {\n                attr(element, 'class', className);\n            } else {\n                element.className = className;\n            }\n        }\n        forin(attributes, function(name, value) {\n            attr(element, name, value);\n        });\n        return element;\n    };\n\n    var appendChild = function appendChild(parent) {\n        return function(child, index) {\n            if (typeof index !== 'undefined' && parent.children[index]) {\n                parent.insertBefore(child, parent.children[index]);\n            } else {\n                parent.appendChild(child);\n            }\n        };\n    };\n\n    var appendChildView = function appendChildView(parent, childViews) {\n        return function(view, index) {\n            if (typeof index !== 'undefined') {\n                childViews.splice(index, 0, view);\n            } else {\n                childViews.push(view);\n            }\n\n            return view;\n        };\n    };\n\n    var removeChildView = function removeChildView(parent, childViews) {\n        return function(view) {\n            // remove from child views\n            childViews.splice(childViews.indexOf(view), 1);\n\n            // remove the element\n            if (view.element.parentNode) {\n                parent.removeChild(view.element);\n            }\n\n            return view;\n        };\n    };\n\n    var IS_BROWSER = (function() {\n        return typeof window !== 'undefined' && typeof window.document !== 'undefined';\n    })();\n    var isBrowser = function isBrowser() {\n        return IS_BROWSER;\n    };\n\n    var testElement = isBrowser() ? createElement('svg') : {};\n    var getChildCount =\n        'children' in testElement\n            ? function(el) {\n                  return el.children.length;\n              }\n            : function(el) {\n                  return el.childNodes.length;\n              };\n\n    var getViewRect = function getViewRect(elementRect, childViews, offset, scale) {\n        var left = offset[0] || elementRect.left;\n        var top = offset[1] || elementRect.top;\n        var right = left + elementRect.width;\n        var bottom = top + elementRect.height * (scale[1] || 1);\n\n        var rect = {\n            // the rectangle of the element itself\n            element: Object.assign({}, elementRect),\n\n            // the rectangle of the element expanded to contain its children, does not include any margins\n            inner: {\n                left: elementRect.left,\n                top: elementRect.top,\n                right: elementRect.right,\n                bottom: elementRect.bottom,\n            },\n\n            // the rectangle of the element expanded to contain its children including own margin and child margins\n            // margins will be added after we've recalculated the size\n            outer: {\n                left: left,\n                top: top,\n                right: right,\n                bottom: bottom,\n            },\n        };\n\n        // expand rect to fit all child rectangles\n        childViews\n            .filter(function(childView) {\n                return !childView.isRectIgnored();\n            })\n            .map(function(childView) {\n                return childView.rect;\n            })\n            .forEach(function(childViewRect) {\n                expandRect(rect.inner, Object.assign({}, childViewRect.inner));\n                expandRect(rect.outer, Object.assign({}, childViewRect.outer));\n            });\n\n        // calculate inner width and height\n        calculateRectSize(rect.inner);\n\n        // append additional margin (top and left margins are included in top and left automatically)\n        rect.outer.bottom += rect.element.marginBottom;\n        rect.outer.right += rect.element.marginRight;\n\n        // calculate outer width and height\n        calculateRectSize(rect.outer);\n\n        return rect;\n    };\n\n    var expandRect = function expandRect(parent, child) {\n        // adjust for parent offset\n        child.top += parent.top;\n        child.right += parent.left;\n        child.bottom += parent.top;\n        child.left += parent.left;\n\n        if (child.bottom > parent.bottom) {\n            parent.bottom = child.bottom;\n        }\n\n        if (child.right > parent.right) {\n            parent.right = child.right;\n        }\n    };\n\n    var calculateRectSize = function calculateRectSize(rect) {\n        rect.width = rect.right - rect.left;\n        rect.height = rect.bottom - rect.top;\n    };\n\n    var isNumber = function isNumber(value) {\n        return typeof value === 'number';\n    };\n\n    /**\n     * Determines if position is at destination\n     * @param position\n     * @param destination\n     * @param velocity\n     * @param errorMargin\n     * @returns {boolean}\n     */\n    var thereYet = function thereYet(position, destination, velocity) {\n        var errorMargin = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0.001;\n        return Math.abs(position - destination) < errorMargin && Math.abs(velocity) < errorMargin;\n    };\n\n    /**\n     * Spring animation\n     */\n    var spring =\n        // default options\n        function spring() // method definition\n        {\n            var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n                _ref$stiffness = _ref.stiffness,\n                stiffness = _ref$stiffness === void 0 ? 0.5 : _ref$stiffness,\n                _ref$damping = _ref.damping,\n                damping = _ref$damping === void 0 ? 0.75 : _ref$damping,\n                _ref$mass = _ref.mass,\n                mass = _ref$mass === void 0 ? 10 : _ref$mass;\n            var target = null;\n            var position = null;\n            var velocity = 0;\n            var resting = false;\n\n            // updates spring state\n            var interpolate = function interpolate(ts, skipToEndState) {\n                // in rest, don't animate\n                if (resting) return;\n\n                // need at least a target or position to do springy things\n                if (!(isNumber(target) && isNumber(position))) {\n                    resting = true;\n                    velocity = 0;\n                    return;\n                }\n\n                // calculate spring force\n                var f = -(position - target) * stiffness;\n\n                // update velocity by adding force based on mass\n                velocity += f / mass;\n\n                // update position by adding velocity\n                position += velocity;\n\n                // slow down based on amount of damping\n                velocity *= damping;\n\n                // we've arrived if we're near target and our velocity is near zero\n                if (thereYet(position, target, velocity) || skipToEndState) {\n                    position = target;\n                    velocity = 0;\n                    resting = true;\n\n                    // we done\n                    api.onupdate(position);\n                    api.oncomplete(position);\n                } else {\n                    // progress update\n                    api.onupdate(position);\n                }\n            };\n\n            /**\n             * Set new target value\n             * @param value\n             */\n            var setTarget = function setTarget(value) {\n                // if currently has no position, set target and position to this value\n                if (isNumber(value) && !isNumber(position)) {\n                    position = value;\n                }\n\n                // next target value will not be animated to\n                if (target === null) {\n                    target = value;\n                    position = value;\n                }\n\n                // let start moving to target\n                target = value;\n\n                // already at target\n                if (position === target || typeof target === 'undefined') {\n                    // now resting as target is current position, stop moving\n                    resting = true;\n                    velocity = 0;\n\n                    // done!\n                    api.onupdate(position);\n                    api.oncomplete(position);\n\n                    return;\n                }\n\n                resting = false;\n            };\n\n            // need 'api' to call onupdate callback\n            var api = createObject({\n                interpolate: interpolate,\n                target: {\n                    set: setTarget,\n                    get: function get() {\n                        return target;\n                    },\n                },\n\n                resting: {\n                    get: function get() {\n                        return resting;\n                    },\n                },\n\n                onupdate: function onupdate(value) {},\n                oncomplete: function oncomplete(value) {},\n            });\n\n            return api;\n        };\n\n    var easeLinear = function easeLinear(t) {\n        return t;\n    };\n    var easeInOutQuad = function easeInOutQuad(t) {\n        return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;\n    };\n\n    var tween =\n        // default values\n        function tween() // method definition\n        {\n            var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n                _ref$duration = _ref.duration,\n                duration = _ref$duration === void 0 ? 500 : _ref$duration,\n                _ref$easing = _ref.easing,\n                easing = _ref$easing === void 0 ? easeInOutQuad : _ref$easing,\n                _ref$delay = _ref.delay,\n                delay = _ref$delay === void 0 ? 0 : _ref$delay;\n            var start = null;\n            var t;\n            var p;\n            var resting = true;\n            var reverse = false;\n            var target = null;\n\n            var interpolate = function interpolate(ts, skipToEndState) {\n                if (resting || target === null) return;\n\n                if (start === null) {\n                    start = ts;\n                }\n\n                if (ts - start < delay) return;\n\n                t = ts - start - delay;\n\n                if (t >= duration || skipToEndState) {\n                    t = 1;\n                    p = reverse ? 0 : 1;\n                    api.onupdate(p * target);\n                    api.oncomplete(p * target);\n                    resting = true;\n                } else {\n                    p = t / duration;\n                    api.onupdate((t >= 0 ? easing(reverse ? 1 - p : p) : 0) * target);\n                }\n            };\n\n            // need 'api' to call onupdate callback\n            var api = createObject({\n                interpolate: interpolate,\n                target: {\n                    get: function get() {\n                        return reverse ? 0 : target;\n                    },\n                    set: function set(value) {\n                        // is initial value\n                        if (target === null) {\n                            target = value;\n                            api.onupdate(value);\n                            api.oncomplete(value);\n                            return;\n                        }\n\n                        // want to tween to a smaller value and have a current value\n                        if (value < target) {\n                            target = 1;\n                            reverse = true;\n                        } else {\n                            // not tweening to a smaller value\n                            reverse = false;\n                            target = value;\n                        }\n\n                        // let's go!\n                        resting = false;\n                        start = null;\n                    },\n                },\n\n                resting: {\n                    get: function get() {\n                        return resting;\n                    },\n                },\n\n                onupdate: function onupdate(value) {},\n                oncomplete: function oncomplete(value) {},\n            });\n\n            return api;\n        };\n\n    var animator = {\n        spring: spring,\n        tween: tween,\n    };\n\n    /*\n                       { type: 'spring', stiffness: .5, damping: .75, mass: 10 };\n                       { translation: { type: 'spring', ... }, ... }\n                       { translation: { x: { type: 'spring', ... } } }\n                      */\n    var createAnimator = function createAnimator(definition, category, property) {\n        // default is single definition\n        // we check if transform is set, if so, we check if property is set\n        var def =\n            definition[category] && typeof definition[category][property] === 'object'\n                ? definition[category][property]\n                : definition[category] || definition;\n\n        var type = typeof def === 'string' ? def : def.type;\n        var props = typeof def === 'object' ? Object.assign({}, def) : {};\n\n        return animator[type] ? animator[type](props) : null;\n    };\n\n    var addGetSet = function addGetSet(keys, obj, props) {\n        var overwrite = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n        obj = Array.isArray(obj) ? obj : [obj];\n        obj.forEach(function(o) {\n            keys.forEach(function(key) {\n                var name = key;\n                var getter = function getter() {\n                    return props[key];\n                };\n                var setter = function setter(value) {\n                    return (props[key] = value);\n                };\n\n                if (typeof key === 'object') {\n                    name = key.key;\n                    getter = key.getter || getter;\n                    setter = key.setter || setter;\n                }\n\n                if (o[name] && !overwrite) {\n                    return;\n                }\n\n                o[name] = {\n                    get: getter,\n                    set: setter,\n                };\n            });\n        });\n    };\n\n    // add to state,\n    // add getters and setters to internal and external api (if not set)\n    // setup animators\n\n    var animations = function animations(_ref) {\n        var mixinConfig = _ref.mixinConfig,\n            viewProps = _ref.viewProps,\n            viewInternalAPI = _ref.viewInternalAPI,\n            viewExternalAPI = _ref.viewExternalAPI;\n        // initial properties\n        var initialProps = Object.assign({}, viewProps);\n\n        // list of all active animations\n        var animations = [];\n\n        // setup animators\n        forin(mixinConfig, function(property, animation) {\n            var animator = createAnimator(animation);\n            if (!animator) {\n                return;\n            }\n\n            // when the animator updates, update the view state value\n            animator.onupdate = function(value) {\n                viewProps[property] = value;\n            };\n\n            // set animator target\n            animator.target = initialProps[property];\n\n            // when value is set, set the animator target value\n            var prop = {\n                key: property,\n                setter: function setter(value) {\n                    // if already at target, we done!\n                    if (animator.target === value) {\n                        return;\n                    }\n\n                    animator.target = value;\n                },\n                getter: function getter() {\n                    return viewProps[property];\n                },\n            };\n\n            // add getters and setters\n            addGetSet([prop], [viewInternalAPI, viewExternalAPI], viewProps, true);\n\n            // add it to the list for easy updating from the _write method\n            animations.push(animator);\n        });\n\n        // expose internal write api\n        return {\n            write: function write(ts) {\n                var skipToEndState = document.hidden;\n                var resting = true;\n                animations.forEach(function(animation) {\n                    if (!animation.resting) resting = false;\n                    animation.interpolate(ts, skipToEndState);\n                });\n                return resting;\n            },\n            destroy: function destroy() {},\n        };\n    };\n\n    var addEvent = function addEvent(element) {\n        return function(type, fn) {\n            element.addEventListener(type, fn);\n        };\n    };\n\n    var removeEvent = function removeEvent(element) {\n        return function(type, fn) {\n            element.removeEventListener(type, fn);\n        };\n    };\n\n    // mixin\n    var listeners = function listeners(_ref) {\n        var mixinConfig = _ref.mixinConfig,\n            viewProps = _ref.viewProps,\n            viewInternalAPI = _ref.viewInternalAPI,\n            viewExternalAPI = _ref.viewExternalAPI,\n            viewState = _ref.viewState,\n            view = _ref.view;\n        var events = [];\n\n        var add = addEvent(view.element);\n        var remove = removeEvent(view.element);\n\n        viewExternalAPI.on = function(type, fn) {\n            events.push({\n                type: type,\n                fn: fn,\n            });\n\n            add(type, fn);\n        };\n\n        viewExternalAPI.off = function(type, fn) {\n            events.splice(\n                events.findIndex(function(event) {\n                    return event.type === type && event.fn === fn;\n                }),\n                1\n            );\n\n            remove(type, fn);\n        };\n\n        return {\n            write: function write() {\n                // not busy\n                return true;\n            },\n            destroy: function destroy() {\n                events.forEach(function(event) {\n                    remove(event.type, event.fn);\n                });\n            },\n        };\n    };\n\n    // add to external api and link to props\n\n    var apis = function apis(_ref) {\n        var mixinConfig = _ref.mixinConfig,\n            viewProps = _ref.viewProps,\n            viewExternalAPI = _ref.viewExternalAPI;\n        addGetSet(mixinConfig, viewExternalAPI, viewProps);\n    };\n\n    var isDefined = function isDefined(value) {\n        return value != null;\n    };\n\n    // add to state,\n    // add getters and setters to internal and external api (if not set)\n    // set initial state based on props in viewProps\n    // apply as transforms each frame\n\n    var defaults = {\n        opacity: 1,\n        scaleX: 1,\n        scaleY: 1,\n        translateX: 0,\n        translateY: 0,\n        rotateX: 0,\n        rotateY: 0,\n        rotateZ: 0,\n        originX: 0,\n        originY: 0,\n    };\n\n    var styles = function styles(_ref) {\n        var mixinConfig = _ref.mixinConfig,\n            viewProps = _ref.viewProps,\n            viewInternalAPI = _ref.viewInternalAPI,\n            viewExternalAPI = _ref.viewExternalAPI,\n            view = _ref.view;\n        // initial props\n        var initialProps = Object.assign({}, viewProps);\n\n        // current props\n        var currentProps = {};\n\n        // we will add those properties to the external API and link them to the viewState\n        addGetSet(mixinConfig, [viewInternalAPI, viewExternalAPI], viewProps);\n\n        // override rect on internal and external rect getter so it takes in account transforms\n        var getOffset = function getOffset() {\n            return [viewProps['translateX'] || 0, viewProps['translateY'] || 0];\n        };\n\n        var getScale = function getScale() {\n            return [viewProps['scaleX'] || 0, viewProps['scaleY'] || 0];\n        };\n        var getRect = function getRect() {\n            return view.rect\n                ? getViewRect(view.rect, view.childViews, getOffset(), getScale())\n                : null;\n        };\n        viewInternalAPI.rect = { get: getRect };\n        viewExternalAPI.rect = { get: getRect };\n\n        // apply view props\n        mixinConfig.forEach(function(key) {\n            viewProps[key] =\n                typeof initialProps[key] === 'undefined' ? defaults[key] : initialProps[key];\n        });\n\n        // expose api\n        return {\n            write: function write() {\n                // see if props have changed\n                if (!propsHaveChanged(currentProps, viewProps)) {\n                    return;\n                }\n\n                // moves element to correct position on screen\n                applyStyles(view.element, viewProps);\n\n                // store new transforms\n                Object.assign(currentProps, Object.assign({}, viewProps));\n\n                // no longer busy\n                return true;\n            },\n            destroy: function destroy() {},\n        };\n    };\n\n    var propsHaveChanged = function propsHaveChanged(currentProps, newProps) {\n        // different amount of keys\n        if (Object.keys(currentProps).length !== Object.keys(newProps).length) {\n            return true;\n        }\n\n        // lets analyze the individual props\n        for (var prop in newProps) {\n            if (newProps[prop] !== currentProps[prop]) {\n                return true;\n            }\n        }\n\n        return false;\n    };\n\n    var applyStyles = function applyStyles(element, _ref2) {\n        var opacity = _ref2.opacity,\n            perspective = _ref2.perspective,\n            translateX = _ref2.translateX,\n            translateY = _ref2.translateY,\n            scaleX = _ref2.scaleX,\n            scaleY = _ref2.scaleY,\n            rotateX = _ref2.rotateX,\n            rotateY = _ref2.rotateY,\n            rotateZ = _ref2.rotateZ,\n            originX = _ref2.originX,\n            originY = _ref2.originY,\n            width = _ref2.width,\n            height = _ref2.height;\n\n        var transforms = '';\n        var styles = '';\n\n        // handle transform origin\n        if (isDefined(originX) || isDefined(originY)) {\n            styles += 'transform-origin: ' + (originX || 0) + 'px ' + (originY || 0) + 'px;';\n        }\n\n        // transform order is relevant\n        // 0. perspective\n        if (isDefined(perspective)) {\n            transforms += 'perspective(' + perspective + 'px) ';\n        }\n\n        // 1. translate\n        if (isDefined(translateX) || isDefined(translateY)) {\n            transforms +=\n                'translate3d(' + (translateX || 0) + 'px, ' + (translateY || 0) + 'px, 0) ';\n        }\n\n        // 2. scale\n        if (isDefined(scaleX) || isDefined(scaleY)) {\n            transforms +=\n                'scale3d(' +\n                (isDefined(scaleX) ? scaleX : 1) +\n                ', ' +\n                (isDefined(scaleY) ? scaleY : 1) +\n                ', 1) ';\n        }\n\n        // 3. rotate\n        if (isDefined(rotateZ)) {\n            transforms += 'rotateZ(' + rotateZ + 'rad) ';\n        }\n\n        if (isDefined(rotateX)) {\n            transforms += 'rotateX(' + rotateX + 'rad) ';\n        }\n\n        if (isDefined(rotateY)) {\n            transforms += 'rotateY(' + rotateY + 'rad) ';\n        }\n\n        // add transforms\n        if (transforms.length) {\n            styles += 'transform:' + transforms + ';';\n        }\n\n        // add opacity\n        if (isDefined(opacity)) {\n            styles += 'opacity:' + opacity + ';';\n\n            // if we reach zero, we make the element inaccessible\n            if (opacity === 0) {\n                styles += 'visibility:hidden;';\n            }\n\n            // if we're below 100% opacity this element can't be clicked\n            if (opacity < 1) {\n                styles += 'pointer-events:none;';\n            }\n        }\n\n        // add height\n        if (isDefined(height)) {\n            styles += 'height:' + height + 'px;';\n        }\n\n        // add width\n        if (isDefined(width)) {\n            styles += 'width:' + width + 'px;';\n        }\n\n        // apply styles\n        var elementCurrentStyle = element.elementCurrentStyle || '';\n\n        // if new styles does not match current styles, lets update!\n        if (styles.length !== elementCurrentStyle.length || styles !== elementCurrentStyle) {\n            element.style.cssText = styles;\n            // store current styles so we can compare them to new styles later on\n            // _not_ getting the style value is faster\n            element.elementCurrentStyle = styles;\n        }\n    };\n\n    var Mixins = {\n        styles: styles,\n        listeners: listeners,\n        animations: animations,\n        apis: apis,\n    };\n\n    var updateRect = function updateRect() {\n        var rect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n        var element = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n        var style = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n        if (!element.layoutCalculated) {\n            rect.paddingTop = parseInt(style.paddingTop, 10) || 0;\n            rect.marginTop = parseInt(style.marginTop, 10) || 0;\n            rect.marginRight = parseInt(style.marginRight, 10) || 0;\n            rect.marginBottom = parseInt(style.marginBottom, 10) || 0;\n            rect.marginLeft = parseInt(style.marginLeft, 10) || 0;\n            element.layoutCalculated = true;\n        }\n\n        rect.left = element.offsetLeft || 0;\n        rect.top = element.offsetTop || 0;\n        rect.width = element.offsetWidth || 0;\n        rect.height = element.offsetHeight || 0;\n\n        rect.right = rect.left + rect.width;\n        rect.bottom = rect.top + rect.height;\n\n        rect.scrollTop = element.scrollTop;\n\n        rect.hidden = element.offsetParent === null;\n\n        return rect;\n    };\n\n    var createView =\n        // default view definition\n        function createView() {\n            var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n                _ref$tag = _ref.tag,\n                tag = _ref$tag === void 0 ? 'div' : _ref$tag,\n                _ref$name = _ref.name,\n                name = _ref$name === void 0 ? null : _ref$name,\n                _ref$attributes = _ref.attributes,\n                attributes = _ref$attributes === void 0 ? {} : _ref$attributes,\n                _ref$read = _ref.read,\n                read = _ref$read === void 0 ? function() {} : _ref$read,\n                _ref$write = _ref.write,\n                write = _ref$write === void 0 ? function() {} : _ref$write,\n                _ref$create = _ref.create,\n                create = _ref$create === void 0 ? function() {} : _ref$create,\n                _ref$destroy = _ref.destroy,\n                destroy = _ref$destroy === void 0 ? function() {} : _ref$destroy,\n                _ref$filterFrameActio = _ref.filterFrameActionsForChild,\n                filterFrameActionsForChild =\n                    _ref$filterFrameActio === void 0\n                        ? function(child, actions) {\n                              return actions;\n                          }\n                        : _ref$filterFrameActio,\n                _ref$didCreateView = _ref.didCreateView,\n                didCreateView = _ref$didCreateView === void 0 ? function() {} : _ref$didCreateView,\n                _ref$didWriteView = _ref.didWriteView,\n                didWriteView = _ref$didWriteView === void 0 ? function() {} : _ref$didWriteView,\n                _ref$ignoreRect = _ref.ignoreRect,\n                ignoreRect = _ref$ignoreRect === void 0 ? false : _ref$ignoreRect,\n                _ref$ignoreRectUpdate = _ref.ignoreRectUpdate,\n                ignoreRectUpdate = _ref$ignoreRectUpdate === void 0 ? false : _ref$ignoreRectUpdate,\n                _ref$mixins = _ref.mixins,\n                mixins = _ref$mixins === void 0 ? [] : _ref$mixins;\n            return function(\n                // each view requires reference to store\n                store\n            ) {\n                var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n                // root element should not be changed\n                var element = createElement(tag, 'filepond--' + name, attributes);\n\n                // style reference should also not be changed\n                var style = window.getComputedStyle(element, null);\n\n                // element rectangle\n                var rect = updateRect();\n                var frameRect = null;\n\n                // rest state\n                var isResting = false;\n\n                // pretty self explanatory\n                var childViews = [];\n\n                // loaded mixins\n                var activeMixins = [];\n\n                // references to created children\n                var ref = {};\n\n                // state used for each instance\n                var state = {};\n\n                // list of writers that will be called to update this view\n                var writers = [\n                    write, // default writer\n                ];\n\n                var readers = [\n                    read, // default reader\n                ];\n\n                var destroyers = [\n                    destroy, // default destroy\n                ];\n\n                // core view methods\n                var getElement = function getElement() {\n                    return element;\n                };\n                var getChildViews = function getChildViews() {\n                    return childViews.concat();\n                };\n                var getReference = function getReference() {\n                    return ref;\n                };\n                var createChildView = function createChildView(store) {\n                    return function(view, props) {\n                        return view(store, props);\n                    };\n                };\n                var getRect = function getRect() {\n                    if (frameRect) {\n                        return frameRect;\n                    }\n                    frameRect = getViewRect(rect, childViews, [0, 0], [1, 1]);\n                    return frameRect;\n                };\n                var getStyle = function getStyle() {\n                    return style;\n                };\n\n                /**\n                 * Read data from DOM\n                 * @private\n                 */\n                var _read = function _read() {\n                    frameRect = null;\n\n                    // read child views\n                    childViews.forEach(function(child) {\n                        return child._read();\n                    });\n\n                    var shouldUpdate = !(ignoreRectUpdate && rect.width && rect.height);\n                    if (shouldUpdate) {\n                        updateRect(rect, element, style);\n                    }\n\n                    // readers\n                    var api = { root: internalAPI, props: props, rect: rect };\n                    readers.forEach(function(reader) {\n                        return reader(api);\n                    });\n                };\n\n                /**\n                 * Write data to DOM\n                 * @private\n                 */\n                var _write = function _write(ts, frameActions, shouldOptimize) {\n                    // if no actions, we assume that the view is resting\n                    var resting = frameActions.length === 0;\n\n                    // writers\n                    writers.forEach(function(writer) {\n                        var writerResting = writer({\n                            props: props,\n                            root: internalAPI,\n                            actions: frameActions,\n                            timestamp: ts,\n                            shouldOptimize: shouldOptimize,\n                        });\n\n                        if (writerResting === false) {\n                            resting = false;\n                        }\n                    });\n\n                    // run mixins\n                    activeMixins.forEach(function(mixin) {\n                        // if one of the mixins is still busy after write operation, we are not resting\n                        var mixinResting = mixin.write(ts);\n                        if (mixinResting === false) {\n                            resting = false;\n                        }\n                    });\n\n                    // updates child views that are currently attached to the DOM\n                    childViews\n                        .filter(function(child) {\n                            return !!child.element.parentNode;\n                        })\n                        .forEach(function(child) {\n                            // if a child view is not resting, we are not resting\n                            var childResting = child._write(\n                                ts,\n                                filterFrameActionsForChild(child, frameActions),\n                                shouldOptimize\n                            );\n\n                            if (!childResting) {\n                                resting = false;\n                            }\n                        });\n\n                    // append new elements to DOM and update those\n                    childViews\n                        //.filter(child => !child.element.parentNode)\n                        .forEach(function(child, index) {\n                            // skip\n                            if (child.element.parentNode) {\n                                return;\n                            }\n\n                            // append to DOM\n                            internalAPI.appendChild(child.element, index);\n\n                            // call read (need to know the size of these elements)\n                            child._read();\n\n                            // re-call write\n                            child._write(\n                                ts,\n                                filterFrameActionsForChild(child, frameActions),\n                                shouldOptimize\n                            );\n\n                            // we just added somthing to the dom, no rest\n                            resting = false;\n                        });\n\n                    // update resting state\n                    isResting = resting;\n\n                    didWriteView({\n                        props: props,\n                        root: internalAPI,\n                        actions: frameActions,\n                        timestamp: ts,\n                    });\n\n                    // let parent know if we are resting\n                    return resting;\n                };\n\n                var _destroy = function _destroy() {\n                    activeMixins.forEach(function(mixin) {\n                        return mixin.destroy();\n                    });\n                    destroyers.forEach(function(destroyer) {\n                        destroyer({ root: internalAPI, props: props });\n                    });\n                    childViews.forEach(function(child) {\n                        return child._destroy();\n                    });\n                };\n\n                // sharedAPI\n                var sharedAPIDefinition = {\n                    element: {\n                        get: getElement,\n                    },\n\n                    style: {\n                        get: getStyle,\n                    },\n\n                    childViews: {\n                        get: getChildViews,\n                    },\n                };\n\n                // private API definition\n                var internalAPIDefinition = Object.assign({}, sharedAPIDefinition, {\n                    rect: {\n                        get: getRect,\n                    },\n\n                    // access to custom children references\n                    ref: {\n                        get: getReference,\n                    },\n\n                    // dom modifiers\n                    is: function is(needle) {\n                        return name === needle;\n                    },\n                    appendChild: appendChild(element),\n                    createChildView: createChildView(store),\n                    linkView: function linkView(view) {\n                        childViews.push(view);\n                        return view;\n                    },\n                    unlinkView: function unlinkView(view) {\n                        childViews.splice(childViews.indexOf(view), 1);\n                    },\n                    appendChildView: appendChildView(element, childViews),\n                    removeChildView: removeChildView(element, childViews),\n                    registerWriter: function registerWriter(writer) {\n                        return writers.push(writer);\n                    },\n                    registerReader: function registerReader(reader) {\n                        return readers.push(reader);\n                    },\n                    registerDestroyer: function registerDestroyer(destroyer) {\n                        return destroyers.push(destroyer);\n                    },\n                    invalidateLayout: function invalidateLayout() {\n                        return (element.layoutCalculated = false);\n                    },\n\n                    // access to data store\n                    dispatch: store.dispatch,\n                    query: store.query,\n                });\n\n                // public view API methods\n                var externalAPIDefinition = {\n                    element: {\n                        get: getElement,\n                    },\n\n                    childViews: {\n                        get: getChildViews,\n                    },\n\n                    rect: {\n                        get: getRect,\n                    },\n\n                    resting: {\n                        get: function get() {\n                            return isResting;\n                        },\n                    },\n\n                    isRectIgnored: function isRectIgnored() {\n                        return ignoreRect;\n                    },\n                    _read: _read,\n                    _write: _write,\n                    _destroy: _destroy,\n                };\n\n                // mixin API methods\n                var mixinAPIDefinition = Object.assign({}, sharedAPIDefinition, {\n                    rect: {\n                        get: function get() {\n                            return rect;\n                        },\n                    },\n                });\n\n                // add mixin functionality\n                Object.keys(mixins)\n                    .sort(function(a, b) {\n                        // move styles to the back of the mixin list (so adjustments of other mixins are applied to the props correctly)\n                        if (a === 'styles') {\n                            return 1;\n                        } else if (b === 'styles') {\n                            return -1;\n                        }\n                        return 0;\n                    })\n                    .forEach(function(key) {\n                        var mixinAPI = Mixins[key]({\n                            mixinConfig: mixins[key],\n                            viewProps: props,\n                            viewState: state,\n                            viewInternalAPI: internalAPIDefinition,\n                            viewExternalAPI: externalAPIDefinition,\n                            view: createObject(mixinAPIDefinition),\n                        });\n\n                        if (mixinAPI) {\n                            activeMixins.push(mixinAPI);\n                        }\n                    });\n\n                // construct private api\n                var internalAPI = createObject(internalAPIDefinition);\n\n                // create the view\n                create({\n                    root: internalAPI,\n                    props: props,\n                });\n\n                // append created child views to root node\n                var childCount = getChildCount(element); // need to know the current child count so appending happens in correct order\n                childViews.forEach(function(child, index) {\n                    internalAPI.appendChild(child.element, childCount + index);\n                });\n\n                // call did create\n                didCreateView(internalAPI);\n\n                // expose public api\n                return createObject(externalAPIDefinition);\n            };\n        };\n\n    var createPainter = function createPainter(read, write) {\n        var fps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 60;\n\n        var name = '__framePainter';\n\n        // set global painter\n        if (window[name]) {\n            window[name].readers.push(read);\n            window[name].writers.push(write);\n            return;\n        }\n\n        window[name] = {\n            readers: [read],\n            writers: [write],\n        };\n\n        var painter = window[name];\n\n        var interval = 1000 / fps;\n        var last = null;\n        var id = null;\n        var requestTick = null;\n        var cancelTick = null;\n\n        var setTimerType = function setTimerType() {\n            if (document.hidden) {\n                requestTick = function requestTick() {\n                    return window.setTimeout(function() {\n                        return tick(performance.now());\n                    }, interval);\n                };\n                cancelTick = function cancelTick() {\n                    return window.clearTimeout(id);\n                };\n            } else {\n                requestTick = function requestTick() {\n                    return window.requestAnimationFrame(tick);\n                };\n                cancelTick = function cancelTick() {\n                    return window.cancelAnimationFrame(id);\n                };\n            }\n        };\n\n        document.addEventListener('visibilitychange', function() {\n            if (cancelTick) cancelTick();\n            setTimerType();\n            tick(performance.now());\n        });\n\n        var tick = function tick(ts) {\n            // queue next tick\n            id = requestTick(tick);\n\n            // limit fps\n            if (!last) {\n                last = ts;\n            }\n\n            var delta = ts - last;\n\n            if (delta <= interval) {\n                // skip frame\n                return;\n            }\n\n            // align next frame\n            last = ts - (delta % interval);\n\n            // update view\n            painter.readers.forEach(function(read) {\n                return read();\n            });\n            painter.writers.forEach(function(write) {\n                return write(ts);\n            });\n        };\n\n        setTimerType();\n        tick(performance.now());\n\n        return {\n            pause: function pause() {\n                cancelTick(id);\n            },\n        };\n    };\n\n    var createRoute = function createRoute(routes, fn) {\n        return function(_ref) {\n            var root = _ref.root,\n                props = _ref.props,\n                _ref$actions = _ref.actions,\n                actions = _ref$actions === void 0 ? [] : _ref$actions,\n                timestamp = _ref.timestamp,\n                shouldOptimize = _ref.shouldOptimize;\n            actions\n                .filter(function(action) {\n                    return routes[action.type];\n                })\n                .forEach(function(action) {\n                    return routes[action.type]({\n                        root: root,\n                        props: props,\n                        action: action.data,\n                        timestamp: timestamp,\n                        shouldOptimize: shouldOptimize,\n                    });\n                });\n\n            if (fn) {\n                fn({\n                    root: root,\n                    props: props,\n                    actions: actions,\n                    timestamp: timestamp,\n                    shouldOptimize: shouldOptimize,\n                });\n            }\n        };\n    };\n\n    var insertBefore = function insertBefore(newNode, referenceNode) {\n        return referenceNode.parentNode.insertBefore(newNode, referenceNode);\n    };\n\n    var insertAfter = function insertAfter(newNode, referenceNode) {\n        return referenceNode.parentNode.insertBefore(newNode, referenceNode.nextSibling);\n    };\n\n    var isArray = function isArray(value) {\n        return Array.isArray(value);\n    };\n\n    var isEmpty = function isEmpty(value) {\n        return value == null;\n    };\n\n    var trim = function trim(str) {\n        return str.trim();\n    };\n\n    var toString = function toString(value) {\n        return '' + value;\n    };\n\n    var toArray = function toArray(value) {\n        var splitter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ',';\n        if (isEmpty(value)) {\n            return [];\n        }\n        if (isArray(value)) {\n            return value;\n        }\n        return toString(value)\n            .split(splitter)\n            .map(trim)\n            .filter(function(str) {\n                return str.length;\n            });\n    };\n\n    var isBoolean = function isBoolean(value) {\n        return typeof value === 'boolean';\n    };\n\n    var toBoolean = function toBoolean(value) {\n        return isBoolean(value) ? value : value === 'true';\n    };\n\n    var isString = function isString(value) {\n        return typeof value === 'string';\n    };\n\n    var toNumber = function toNumber(value) {\n        return isNumber(value)\n            ? value\n            : isString(value)\n            ? toString(value).replace(/[a-z]+/gi, '')\n            : 0;\n    };\n\n    var toInt = function toInt(value) {\n        return parseInt(toNumber(value), 10);\n    };\n\n    var toFloat = function toFloat(value) {\n        return parseFloat(toNumber(value));\n    };\n\n    var isInt = function isInt(value) {\n        return isNumber(value) && isFinite(value) && Math.floor(value) === value;\n    };\n\n    var toBytes = function toBytes(value) {\n        var base = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n        // is in bytes\n        if (isInt(value)) {\n            return value;\n        }\n\n        // is natural file size\n        var naturalFileSize = toString(value).trim();\n\n        // if is value in megabytes\n        if (/MB$/i.test(naturalFileSize)) {\n            naturalFileSize = naturalFileSize.replace(/MB$i/, '').trim();\n            return toInt(naturalFileSize) * base * base;\n        }\n\n        // if is value in kilobytes\n        if (/KB/i.test(naturalFileSize)) {\n            naturalFileSize = naturalFileSize.replace(/KB$i/, '').trim();\n            return toInt(naturalFileSize) * base;\n        }\n\n        return toInt(naturalFileSize);\n    };\n\n    var isFunction = function isFunction(value) {\n        return typeof value === 'function';\n    };\n\n    var toFunctionReference = function toFunctionReference(string) {\n        var ref = self;\n        var levels = string.split('.');\n        var level = null;\n        while ((level = levels.shift())) {\n            ref = ref[level];\n            if (!ref) {\n                return null;\n            }\n        }\n        return ref;\n    };\n\n    var methods = {\n        process: 'POST',\n        patch: 'PATCH',\n        revert: 'DELETE',\n        fetch: 'GET',\n        restore: 'GET',\n        load: 'GET',\n    };\n\n    var createServerAPI = function createServerAPI(outline) {\n        var api = {};\n\n        api.url = isString(outline) ? outline : outline.url || '';\n        api.timeout = outline.timeout ? parseInt(outline.timeout, 10) : 0;\n        api.headers = outline.headers ? outline.headers : {};\n\n        forin(methods, function(key) {\n            api[key] = createAction(key, outline[key], methods[key], api.timeout, api.headers);\n        });\n\n        // remove process if no url or process on outline\n        api.process = outline.process || isString(outline) || outline.url ? api.process : null;\n\n        // special treatment for remove\n        api.remove = outline.remove || null;\n\n        // remove generic headers from api object\n        delete api.headers;\n\n        return api;\n    };\n\n    var createAction = function createAction(name, outline, method, timeout, headers) {\n        // is explicitely set to null so disable\n        if (outline === null) {\n            return null;\n        }\n\n        // if is custom function, done! Dev handles everything.\n        if (typeof outline === 'function') {\n            return outline;\n        }\n\n        // build action object\n        var action = {\n            url: method === 'GET' || method === 'PATCH' ? '?' + name + '=' : '',\n            method: method,\n            headers: headers,\n            withCredentials: false,\n            timeout: timeout,\n            onload: null,\n            ondata: null,\n            onerror: null,\n        };\n\n        // is a single url\n        if (isString(outline)) {\n            action.url = outline;\n            return action;\n        }\n\n        // overwrite\n        Object.assign(action, outline);\n\n        // see if should reformat headers;\n        if (isString(action.headers)) {\n            var parts = action.headers.split(/:(.+)/);\n            action.headers = {\n                header: parts[0],\n                value: parts[1],\n            };\n        }\n\n        // if is bool withCredentials\n        action.withCredentials = toBoolean(action.withCredentials);\n\n        return action;\n    };\n\n    var toServerAPI = function toServerAPI(value) {\n        return createServerAPI(value);\n    };\n\n    var isNull = function isNull(value) {\n        return value === null;\n    };\n\n    var isObject = function isObject(value) {\n        return typeof value === 'object' && value !== null;\n    };\n\n    var isAPI = function isAPI(value) {\n        return (\n            isObject(value) &&\n            isString(value.url) &&\n            isObject(value.process) &&\n            isObject(value.revert) &&\n            isObject(value.restore) &&\n            isObject(value.fetch)\n        );\n    };\n\n    var getType = function getType(value) {\n        if (isArray(value)) {\n            return 'array';\n        }\n\n        if (isNull(value)) {\n            return 'null';\n        }\n\n        if (isInt(value)) {\n            return 'int';\n        }\n\n        if (/^[0-9]+ ?(?:GB|MB|KB)$/gi.test(value)) {\n            return 'bytes';\n        }\n\n        if (isAPI(value)) {\n            return 'api';\n        }\n\n        return typeof value;\n    };\n\n    var replaceSingleQuotes = function replaceSingleQuotes(str) {\n        return str\n            .replace(/{\\s*'/g, '{\"')\n            .replace(/'\\s*}/g, '\"}')\n            .replace(/'\\s*:/g, '\":')\n            .replace(/:\\s*'/g, ':\"')\n            .replace(/,\\s*'/g, ',\"')\n            .replace(/'\\s*,/g, '\",');\n    };\n\n    var conversionTable = {\n        array: toArray,\n        boolean: toBoolean,\n        int: function int(value) {\n            return getType(value) === 'bytes' ? toBytes(value) : toInt(value);\n        },\n        number: toFloat,\n        float: toFloat,\n        bytes: toBytes,\n        string: function string(value) {\n            return isFunction(value) ? value : toString(value);\n        },\n        function: function _function(value) {\n            return toFunctionReference(value);\n        },\n        serverapi: toServerAPI,\n        object: function object(value) {\n            try {\n                return JSON.parse(replaceSingleQuotes(value));\n            } catch (e) {\n                return null;\n            }\n        },\n    };\n\n    var convertTo = function convertTo(value, type) {\n        return conversionTable[type](value);\n    };\n\n    var getValueByType = function getValueByType(newValue, defaultValue, valueType) {\n        // can always assign default value\n        if (newValue === defaultValue) {\n            return newValue;\n        }\n\n        // get the type of the new value\n        var newValueType = getType(newValue);\n\n        // is valid type?\n        if (newValueType !== valueType) {\n            // is string input, let's attempt to convert\n            var convertedValue = convertTo(newValue, valueType);\n\n            // what is the type now\n            newValueType = getType(convertedValue);\n\n            // no valid conversions found\n            if (convertedValue === null) {\n                throw 'Trying to assign value with incorrect type to \"' +\n                    option +\n                    '\", allowed type: \"' +\n                    valueType +\n                    '\"';\n            } else {\n                newValue = convertedValue;\n            }\n        }\n\n        // assign new value\n        return newValue;\n    };\n\n    var createOption = function createOption(defaultValue, valueType) {\n        var currentValue = defaultValue;\n        return {\n            enumerable: true,\n            get: function get() {\n                return currentValue;\n            },\n            set: function set(newValue) {\n                currentValue = getValueByType(newValue, defaultValue, valueType);\n            },\n        };\n    };\n\n    var createOptions = function createOptions(options) {\n        var obj = {};\n        forin(options, function(prop) {\n            var optionDefinition = options[prop];\n            obj[prop] = createOption(optionDefinition[0], optionDefinition[1]);\n        });\n        return createObject(obj);\n    };\n\n    var createInitialState = function createInitialState(options) {\n        return {\n            // model\n            items: [],\n\n            // timeout used for calling update items\n            listUpdateTimeout: null,\n\n            // timeout used for stacking metadata updates\n            itemUpdateTimeout: null,\n\n            // queue of items waiting to be processed\n            processingQueue: [],\n\n            // options\n            options: createOptions(options),\n        };\n    };\n\n    var fromCamels = function fromCamels(string) {\n        var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '-';\n        return string\n            .split(/(?=[A-Z])/)\n            .map(function(part) {\n                return part.toLowerCase();\n            })\n            .join(separator);\n    };\n\n    var createOptionAPI = function createOptionAPI(store, options) {\n        var obj = {};\n        forin(options, function(key) {\n            obj[key] = {\n                get: function get() {\n                    return store.getState().options[key];\n                },\n                set: function set(value) {\n                    store.dispatch('SET_' + fromCamels(key, '_').toUpperCase(), {\n                        value: value,\n                    });\n                },\n            };\n        });\n        return obj;\n    };\n\n    var createOptionActions = function createOptionActions(options) {\n        return function(dispatch, query, state) {\n            var obj = {};\n            forin(options, function(key) {\n                var name = fromCamels(key, '_').toUpperCase();\n\n                obj['SET_' + name] = function(action) {\n                    try {\n                        state.options[key] = action.value;\n                    } catch (e) {} // nope, failed\n\n                    // we successfully set the value of this option\n                    dispatch('DID_SET_' + name, { value: state.options[key] });\n                };\n            });\n            return obj;\n        };\n    };\n\n    var createOptionQueries = function createOptionQueries(options) {\n        return function(state) {\n            var obj = {};\n            forin(options, function(key) {\n                obj['GET_' + fromCamels(key, '_').toUpperCase()] = function(action) {\n                    return state.options[key];\n                };\n            });\n            return obj;\n        };\n    };\n\n    var InteractionMethod = {\n        API: 1,\n        DROP: 2,\n        BROWSE: 3,\n        PASTE: 4,\n        NONE: 5,\n    };\n\n    var getUniqueId = function getUniqueId() {\n        return Math.random()\n            .toString(36)\n            .substring(2, 11);\n    };\n\n    function _typeof(obj) {\n        if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') {\n            _typeof = function(obj) {\n                return typeof obj;\n            };\n        } else {\n            _typeof = function(obj) {\n                return obj &&\n                    typeof Symbol === 'function' &&\n                    obj.constructor === Symbol &&\n                    obj !== Symbol.prototype\n                    ? 'symbol'\n                    : typeof obj;\n            };\n        }\n\n        return _typeof(obj);\n    }\n\n    var REACT_ELEMENT_TYPE;\n\n    function _jsx(type, props, key, children) {\n        if (!REACT_ELEMENT_TYPE) {\n            REACT_ELEMENT_TYPE =\n                (typeof Symbol === 'function' && Symbol['for'] && Symbol['for']('react.element')) ||\n                0xeac7;\n        }\n\n        var defaultProps = type && type.defaultProps;\n        var childrenLength = arguments.length - 3;\n\n        if (!props && childrenLength !== 0) {\n            props = {\n                children: void 0,\n            };\n        }\n\n        if (props && defaultProps) {\n            for (var propName in defaultProps) {\n                if (props[propName] === void 0) {\n                    props[propName] = defaultProps[propName];\n                }\n            }\n        } else if (!props) {\n            props = defaultProps || {};\n        }\n\n        if (childrenLength === 1) {\n            props.children = children;\n        } else if (childrenLength > 1) {\n            var childArray = new Array(childrenLength);\n\n            for (var i = 0; i < childrenLength; i++) {\n                childArray[i] = arguments[i + 3];\n            }\n\n            props.children = childArray;\n        }\n\n        return {\n            $$typeof: REACT_ELEMENT_TYPE,\n            type: type,\n            key: key === undefined ? null : '' + key,\n            ref: null,\n            props: props,\n            _owner: null,\n        };\n    }\n\n    function _asyncIterator(iterable) {\n        var method;\n\n        if (typeof Symbol !== 'undefined') {\n            if (Symbol.asyncIterator) {\n                method = iterable[Symbol.asyncIterator];\n                if (method != null) return method.call(iterable);\n            }\n\n            if (Symbol.iterator) {\n                method = iterable[Symbol.iterator];\n                if (method != null) return method.call(iterable);\n            }\n        }\n\n        throw new TypeError('Object is not async iterable');\n    }\n\n    function _AwaitValue(value) {\n        this.wrapped = value;\n    }\n\n    function _AsyncGenerator(gen) {\n        var front, back;\n\n        function send(key, arg) {\n            return new Promise(function(resolve, reject) {\n                var request = {\n                    key: key,\n                    arg: arg,\n                    resolve: resolve,\n                    reject: reject,\n                    next: null,\n                };\n\n                if (back) {\n                    back = back.next = request;\n                } else {\n                    front = back = request;\n                    resume(key, arg);\n                }\n            });\n        }\n\n        function resume(key, arg) {\n            try {\n                var result = gen[key](arg);\n                var value = result.value;\n                var wrappedAwait = value instanceof _AwaitValue;\n                Promise.resolve(wrappedAwait ? value.wrapped : value).then(\n                    function(arg) {\n                        if (wrappedAwait) {\n                            resume('next', arg);\n                            return;\n                        }\n\n                        settle(result.done ? 'return' : 'normal', arg);\n                    },\n                    function(err) {\n                        resume('throw', err);\n                    }\n                );\n            } catch (err) {\n                settle('throw', err);\n            }\n        }\n\n        function settle(type, value) {\n            switch (type) {\n                case 'return':\n                    front.resolve({\n                        value: value,\n                        done: true,\n                    });\n                    break;\n\n                case 'throw':\n                    front.reject(value);\n                    break;\n\n                default:\n                    front.resolve({\n                        value: value,\n                        done: false,\n                    });\n                    break;\n            }\n\n            front = front.next;\n\n            if (front) {\n                resume(front.key, front.arg);\n            } else {\n                back = null;\n            }\n        }\n\n        this._invoke = send;\n\n        if (typeof gen.return !== 'function') {\n            this.return = undefined;\n        }\n    }\n\n    if (typeof Symbol === 'function' && Symbol.asyncIterator) {\n        _AsyncGenerator.prototype[Symbol.asyncIterator] = function() {\n            return this;\n        };\n    }\n\n    _AsyncGenerator.prototype.next = function(arg) {\n        return this._invoke('next', arg);\n    };\n\n    _AsyncGenerator.prototype.throw = function(arg) {\n        return this._invoke('throw', arg);\n    };\n\n    _AsyncGenerator.prototype.return = function(arg) {\n        return this._invoke('return', arg);\n    };\n\n    function _wrapAsyncGenerator(fn) {\n        return function() {\n            return new _AsyncGenerator(fn.apply(this, arguments));\n        };\n    }\n\n    function _awaitAsyncGenerator(value) {\n        return new _AwaitValue(value);\n    }\n\n    function _asyncGeneratorDelegate(inner, awaitWrap) {\n        var iter = {},\n            waiting = false;\n\n        function pump(key, value) {\n            waiting = true;\n            value = new Promise(function(resolve) {\n                resolve(inner[key](value));\n            });\n            return {\n                done: false,\n                value: awaitWrap(value),\n            };\n        }\n\n        if (typeof Symbol === 'function' && Symbol.iterator) {\n            iter[Symbol.iterator] = function() {\n                return this;\n            };\n        }\n\n        iter.next = function(value) {\n            if (waiting) {\n                waiting = false;\n                return value;\n            }\n\n            return pump('next', value);\n        };\n\n        if (typeof inner.throw === 'function') {\n            iter.throw = function(value) {\n                if (waiting) {\n                    waiting = false;\n                    throw value;\n                }\n\n                return pump('throw', value);\n            };\n        }\n\n        if (typeof inner.return === 'function') {\n            iter.return = function(value) {\n                return pump('return', value);\n            };\n        }\n\n        return iter;\n    }\n\n    function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n        try {\n            var info = gen[key](arg);\n            var value = info.value;\n        } catch (error) {\n            reject(error);\n            return;\n        }\n\n        if (info.done) {\n            resolve(value);\n        } else {\n            Promise.resolve(value).then(_next, _throw);\n        }\n    }\n\n    function _asyncToGenerator(fn) {\n        return function() {\n            var self = this,\n                args = arguments;\n            return new Promise(function(resolve, reject) {\n                var gen = fn.apply(self, args);\n\n                function _next(value) {\n                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, 'next', value);\n                }\n\n                function _throw(err) {\n                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, 'throw', err);\n                }\n\n                _next(undefined);\n            });\n        };\n    }\n\n    function _classCallCheck(instance, Constructor) {\n        if (!(instance instanceof Constructor)) {\n            throw new TypeError('Cannot call a class as a function');\n        }\n    }\n\n    function _defineProperties(target, props) {\n        for (var i = 0; i < props.length; i++) {\n            var descriptor = props[i];\n            descriptor.enumerable = descriptor.enumerable || false;\n            descriptor.configurable = true;\n            if ('value' in descriptor) descriptor.writable = true;\n            Object.defineProperty(target, descriptor.key, descriptor);\n        }\n    }\n\n    function _createClass(Constructor, protoProps, staticProps) {\n        if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n        if (staticProps) _defineProperties(Constructor, staticProps);\n        return Constructor;\n    }\n\n    function _defineEnumerableProperties(obj, descs) {\n        for (var key in descs) {\n            var desc = descs[key];\n            desc.configurable = desc.enumerable = true;\n            if ('value' in desc) desc.writable = true;\n            Object.defineProperty(obj, key, desc);\n        }\n\n        if (Object.getOwnPropertySymbols) {\n            var objectSymbols = Object.getOwnPropertySymbols(descs);\n\n            for (var i = 0; i < objectSymbols.length; i++) {\n                var sym = objectSymbols[i];\n                var desc = descs[sym];\n                desc.configurable = desc.enumerable = true;\n                if ('value' in desc) desc.writable = true;\n                Object.defineProperty(obj, sym, desc);\n            }\n        }\n\n        return obj;\n    }\n\n    function _defaults(obj, defaults) {\n        var keys = Object.getOwnPropertyNames(defaults);\n\n        for (var i = 0; i < keys.length; i++) {\n            var key = keys[i];\n            var value = Object.getOwnPropertyDescriptor(defaults, key);\n\n            if (value && value.configurable && obj[key] === undefined) {\n                Object.defineProperty(obj, key, value);\n            }\n        }\n\n        return obj;\n    }\n\n    function _defineProperty(obj, key, value) {\n        if (key in obj) {\n            Object.defineProperty(obj, key, {\n                value: value,\n                enumerable: true,\n                configurable: true,\n                writable: true,\n            });\n        } else {\n            obj[key] = value;\n        }\n\n        return obj;\n    }\n\n    function _extends() {\n        _extends =\n            Object.assign ||\n            function(target) {\n                for (var i = 1; i < arguments.length; i++) {\n                    var source = arguments[i];\n\n                    for (var key in source) {\n                        if (Object.prototype.hasOwnProperty.call(source, key)) {\n                            target[key] = source[key];\n                        }\n                    }\n                }\n\n                return target;\n            };\n\n        return _extends.apply(this, arguments);\n    }\n\n    function _objectSpread(target) {\n        for (var i = 1; i < arguments.length; i++) {\n            var source = arguments[i] != null ? arguments[i] : {};\n            var ownKeys = Object.keys(source);\n\n            if (typeof Object.getOwnPropertySymbols === 'function') {\n                ownKeys = ownKeys.concat(\n                    Object.getOwnPropertySymbols(source).filter(function(sym) {\n                        return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n                    })\n                );\n            }\n\n            ownKeys.forEach(function(key) {\n                _defineProperty(target, key, source[key]);\n            });\n        }\n\n        return target;\n    }\n\n    function ownKeys(object, enumerableOnly) {\n        var keys = Object.keys(object);\n\n        if (Object.getOwnPropertySymbols) {\n            var symbols = Object.getOwnPropertySymbols(object);\n            if (enumerableOnly)\n                symbols = symbols.filter(function(sym) {\n                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n                });\n            keys.push.apply(keys, symbols);\n        }\n\n        return keys;\n    }\n\n    function _objectSpread2(target) {\n        for (var i = 1; i < arguments.length; i++) {\n            var source = arguments[i] != null ? arguments[i] : {};\n\n            if (i % 2) {\n                ownKeys(source, true).forEach(function(key) {\n                    _defineProperty(target, key, source[key]);\n                });\n            } else if (Object.getOwnPropertyDescriptors) {\n                Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n            } else {\n                ownKeys(source).forEach(function(key) {\n                    Object.defineProperty(\n                        target,\n                        key,\n                        Object.getOwnPropertyDescriptor(source, key)\n                    );\n                });\n            }\n        }\n\n        return target;\n    }\n\n    function _inherits(subClass, superClass) {\n        if (typeof superClass !== 'function' && superClass !== null) {\n            throw new TypeError('Super expression must either be null or a function');\n        }\n\n        subClass.prototype = Object.create(superClass && superClass.prototype, {\n            constructor: {\n                value: subClass,\n                writable: true,\n                configurable: true,\n            },\n        });\n        if (superClass) _setPrototypeOf(subClass, superClass);\n    }\n\n    function _inheritsLoose(subClass, superClass) {\n        subClass.prototype = Object.create(superClass.prototype);\n        subClass.prototype.constructor = subClass;\n        subClass.__proto__ = superClass;\n    }\n\n    function _getPrototypeOf(o) {\n        _getPrototypeOf = Object.setPrototypeOf\n            ? Object.getPrototypeOf\n            : function _getPrototypeOf(o) {\n                  return o.__proto__ || Object.getPrototypeOf(o);\n              };\n        return _getPrototypeOf(o);\n    }\n\n    function _setPrototypeOf(o, p) {\n        _setPrototypeOf =\n            Object.setPrototypeOf ||\n            function _setPrototypeOf(o, p) {\n                o.__proto__ = p;\n                return o;\n            };\n\n        return _setPrototypeOf(o, p);\n    }\n\n    function isNativeReflectConstruct() {\n        if (typeof Reflect === 'undefined' || !Reflect.construct) return false;\n        if (Reflect.construct.sham) return false;\n        if (typeof Proxy === 'function') return true;\n\n        try {\n            Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));\n            return true;\n        } catch (e) {\n            return false;\n        }\n    }\n\n    function _construct(Parent, args, Class) {\n        if (isNativeReflectConstruct()) {\n            _construct = Reflect.construct;\n        } else {\n            _construct = function _construct(Parent, args, Class) {\n                var a = [null];\n                a.push.apply(a, args);\n                var Constructor = Function.bind.apply(Parent, a);\n                var instance = new Constructor();\n                if (Class) _setPrototypeOf(instance, Class.prototype);\n                return instance;\n            };\n        }\n\n        return _construct.apply(null, arguments);\n    }\n\n    function _isNativeFunction(fn) {\n        return Function.toString.call(fn).indexOf('[native code]') !== -1;\n    }\n\n    function _wrapNativeSuper(Class) {\n        var _cache = typeof Map === 'function' ? new Map() : undefined;\n\n        _wrapNativeSuper = function _wrapNativeSuper(Class) {\n            if (Class === null || !_isNativeFunction(Class)) return Class;\n\n            if (typeof Class !== 'function') {\n                throw new TypeError('Super expression must either be null or a function');\n            }\n\n            if (typeof _cache !== 'undefined') {\n                if (_cache.has(Class)) return _cache.get(Class);\n\n                _cache.set(Class, Wrapper);\n            }\n\n            function Wrapper() {\n                return _construct(Class, arguments, _getPrototypeOf(this).constructor);\n            }\n\n            Wrapper.prototype = Object.create(Class.prototype, {\n                constructor: {\n                    value: Wrapper,\n                    enumerable: false,\n                    writable: true,\n                    configurable: true,\n                },\n            });\n            return _setPrototypeOf(Wrapper, Class);\n        };\n\n        return _wrapNativeSuper(Class);\n    }\n\n    function _instanceof(left, right) {\n        if (right != null && typeof Symbol !== 'undefined' && right[Symbol.hasInstance]) {\n            return !!right[Symbol.hasInstance](left);\n        } else {\n            return left instanceof right;\n        }\n    }\n\n    function _interopRequireDefault(obj) {\n        return obj && obj.__esModule\n            ? obj\n            : {\n                  default: obj,\n              };\n    }\n\n    function _interopRequireWildcard(obj) {\n        if (obj && obj.__esModule) {\n            return obj;\n        } else {\n            var newObj = {};\n\n            if (obj != null) {\n                for (var key in obj) {\n                    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n                        var desc =\n                            Object.defineProperty && Object.getOwnPropertyDescriptor\n                                ? Object.getOwnPropertyDescriptor(obj, key)\n                                : {};\n\n                        if (desc.get || desc.set) {\n                            Object.defineProperty(newObj, key, desc);\n                        } else {\n                            newObj[key] = obj[key];\n                        }\n                    }\n                }\n            }\n\n            newObj.default = obj;\n            return newObj;\n        }\n    }\n\n    function _newArrowCheck(innerThis, boundThis) {\n        if (innerThis !== boundThis) {\n            throw new TypeError('Cannot instantiate an arrow function');\n        }\n    }\n\n    function _objectDestructuringEmpty(obj) {\n        if (obj == null) throw new TypeError('Cannot destructure undefined');\n    }\n\n    function _objectWithoutPropertiesLoose(source, excluded) {\n        if (source == null) return {};\n        var target = {};\n        var sourceKeys = Object.keys(source);\n        var key, i;\n\n        for (i = 0; i < sourceKeys.length; i++) {\n            key = sourceKeys[i];\n            if (excluded.indexOf(key) >= 0) continue;\n            target[key] = source[key];\n        }\n\n        return target;\n    }\n\n    function _objectWithoutProperties(source, excluded) {\n        if (source == null) return {};\n\n        var target = _objectWithoutPropertiesLoose(source, excluded);\n\n        var key, i;\n\n        if (Object.getOwnPropertySymbols) {\n            var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n            for (i = 0; i < sourceSymbolKeys.length; i++) {\n                key = sourceSymbolKeys[i];\n                if (excluded.indexOf(key) >= 0) continue;\n                if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n                target[key] = source[key];\n            }\n        }\n\n        return target;\n    }\n\n    function _assertThisInitialized(self) {\n        if (self === void 0) {\n            throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n        }\n\n        return self;\n    }\n\n    function _possibleConstructorReturn(self, call) {\n        if (call && (typeof call === 'object' || typeof call === 'function')) {\n            return call;\n        }\n\n        return _assertThisInitialized(self);\n    }\n\n    function _superPropBase(object, property) {\n        while (!Object.prototype.hasOwnProperty.call(object, property)) {\n            object = _getPrototypeOf(object);\n            if (object === null) break;\n        }\n\n        return object;\n    }\n\n    function _get(target, property, receiver) {\n        if (typeof Reflect !== 'undefined' && Reflect.get) {\n            _get = Reflect.get;\n        } else {\n            _get = function _get(target, property, receiver) {\n                var base = _superPropBase(target, property);\n\n                if (!base) return;\n                var desc = Object.getOwnPropertyDescriptor(base, property);\n\n                if (desc.get) {\n                    return desc.get.call(receiver);\n                }\n\n                return desc.value;\n            };\n        }\n\n        return _get(target, property, receiver || target);\n    }\n\n    function set(target, property, value, receiver) {\n        if (typeof Reflect !== 'undefined' && Reflect.set) {\n            set = Reflect.set;\n        } else {\n            set = function set(target, property, value, receiver) {\n                var base = _superPropBase(target, property);\n\n                var desc;\n\n                if (base) {\n                    desc = Object.getOwnPropertyDescriptor(base, property);\n\n                    if (desc.set) {\n                        desc.set.call(receiver, value);\n                        return true;\n                    } else if (!desc.writable) {\n                        return false;\n                    }\n                }\n\n                desc = Object.getOwnPropertyDescriptor(receiver, property);\n\n                if (desc) {\n                    if (!desc.writable) {\n                        return false;\n                    }\n\n                    desc.value = value;\n                    Object.defineProperty(receiver, property, desc);\n                } else {\n                    _defineProperty(receiver, property, value);\n                }\n\n                return true;\n            };\n        }\n\n        return set(target, property, value, receiver);\n    }\n\n    function _set(target, property, value, receiver, isStrict) {\n        var s = set(target, property, value, receiver || target);\n\n        if (!s && isStrict) {\n            throw new Error('failed to set property');\n        }\n\n        return value;\n    }\n\n    function _taggedTemplateLiteral(strings, raw) {\n        if (!raw) {\n            raw = strings.slice(0);\n        }\n\n        return Object.freeze(\n            Object.defineProperties(strings, {\n                raw: {\n                    value: Object.freeze(raw),\n                },\n            })\n        );\n    }\n\n    function _taggedTemplateLiteralLoose(strings, raw) {\n        if (!raw) {\n            raw = strings.slice(0);\n        }\n\n        strings.raw = raw;\n        return strings;\n    }\n\n    function _temporalRef(val, name) {\n        if (val === _temporalUndefined) {\n            throw new ReferenceError(name + ' is not defined - temporal dead zone');\n        } else {\n            return val;\n        }\n    }\n\n    function _readOnlyError(name) {\n        throw new Error('\"' + name + '\" is read-only');\n    }\n\n    function _classNameTDZError(name) {\n        throw new Error('Class \"' + name + '\" cannot be referenced in computed property keys.');\n    }\n\n    var _temporalUndefined = {};\n\n    function _slicedToArray(arr, i) {\n        return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();\n    }\n\n    function _slicedToArrayLoose(arr, i) {\n        return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _nonIterableRest();\n    }\n\n    function _toArray(arr) {\n        return _arrayWithHoles(arr) || _iterableToArray(arr) || _nonIterableRest();\n    }\n\n    function _toConsumableArray(arr) {\n        return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n    }\n\n    function _arrayWithoutHoles(arr) {\n        if (Array.isArray(arr)) {\n            for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n            return arr2;\n        }\n    }\n\n    function _arrayWithHoles(arr) {\n        if (Array.isArray(arr)) return arr;\n    }\n\n    function _iterableToArray(iter) {\n        if (\n            Symbol.iterator in Object(iter) ||\n            Object.prototype.toString.call(iter) === '[object Arguments]'\n        )\n            return Array.from(iter);\n    }\n\n    function _iterableToArrayLimit(arr, i) {\n        var _arr = [];\n        var _n = true;\n        var _d = false;\n        var _e = undefined;\n\n        try {\n            for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n                _arr.push(_s.value);\n\n                if (i && _arr.length === i) break;\n            }\n        } catch (err) {\n            _d = true;\n            _e = err;\n        } finally {\n            try {\n                if (!_n && _i['return'] != null) _i['return']();\n            } finally {\n                if (_d) throw _e;\n            }\n        }\n\n        return _arr;\n    }\n\n    function _iterableToArrayLimitLoose(arr, i) {\n        var _arr = [];\n\n        for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done; ) {\n            _arr.push(_step.value);\n\n            if (i && _arr.length === i) break;\n        }\n\n        return _arr;\n    }\n\n    function _nonIterableSpread() {\n        throw new TypeError('Invalid attempt to spread non-iterable instance');\n    }\n\n    function _nonIterableRest() {\n        throw new TypeError('Invalid attempt to destructure non-iterable instance');\n    }\n\n    function _skipFirstGeneratorNext(fn) {\n        return function() {\n            var it = fn.apply(this, arguments);\n            it.next();\n            return it;\n        };\n    }\n\n    function _toPrimitive(input, hint) {\n        if (typeof input !== 'object' || input === null) return input;\n        var prim = input[Symbol.toPrimitive];\n\n        if (prim !== undefined) {\n            var res = prim.call(input, hint || 'default');\n            if (typeof res !== 'object') return res;\n            throw new TypeError('@@toPrimitive must return a primitive value.');\n        }\n\n        return (hint === 'string' ? String : Number)(input);\n    }\n\n    function _toPropertyKey(arg) {\n        var key = _toPrimitive(arg, 'string');\n\n        return typeof key === 'symbol' ? key : String(key);\n    }\n\n    function _initializerWarningHelper(descriptor, context) {\n        throw new Error(\n            'Decorating class property failed. Please ensure that ' +\n                'proposal-class-properties is enabled and set to use loose mode. ' +\n                'To use proposal-class-properties in spec mode with decorators, wait for ' +\n                'the next major version of decorators in stage 2.'\n        );\n    }\n\n    function _initializerDefineProperty(target, property, descriptor, context) {\n        if (!descriptor) return;\n        Object.defineProperty(target, property, {\n            enumerable: descriptor.enumerable,\n            configurable: descriptor.configurable,\n            writable: descriptor.writable,\n            value: descriptor.initializer ? descriptor.initializer.call(context) : void 0,\n        });\n    }\n\n    function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {\n        var desc = {};\n        Object.keys(descriptor).forEach(function(key) {\n            desc[key] = descriptor[key];\n        });\n        desc.enumerable = !!desc.enumerable;\n        desc.configurable = !!desc.configurable;\n\n        if ('value' in desc || desc.initializer) {\n            desc.writable = true;\n        }\n\n        desc = decorators\n            .slice()\n            .reverse()\n            .reduce(function(desc, decorator) {\n                return decorator(target, property, desc) || desc;\n            }, desc);\n\n        if (context && desc.initializer !== void 0) {\n            desc.value = desc.initializer ? desc.initializer.call(context) : void 0;\n            desc.initializer = undefined;\n        }\n\n        if (desc.initializer === void 0) {\n            Object.defineProperty(target, property, desc);\n            desc = null;\n        }\n\n        return desc;\n    }\n\n    var id = 0;\n\n    function _classPrivateFieldLooseKey(name) {\n        return '__private_' + id++ + '_' + name;\n    }\n\n    function _classPrivateFieldLooseBase(receiver, privateKey) {\n        if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {\n            throw new TypeError('attempted to use private field on non-instance');\n        }\n\n        return receiver;\n    }\n\n    function _classPrivateFieldGet(receiver, privateMap) {\n        var descriptor = privateMap.get(receiver);\n\n        if (!descriptor) {\n            throw new TypeError('attempted to get private field on non-instance');\n        }\n\n        if (descriptor.get) {\n            return descriptor.get.call(receiver);\n        }\n\n        return descriptor.value;\n    }\n\n    function _classPrivateFieldSet(receiver, privateMap, value) {\n        var descriptor = privateMap.get(receiver);\n\n        if (!descriptor) {\n            throw new TypeError('attempted to set private field on non-instance');\n        }\n\n        if (descriptor.set) {\n            descriptor.set.call(receiver, value);\n        } else {\n            if (!descriptor.writable) {\n                throw new TypeError('attempted to set read only private field');\n            }\n\n            descriptor.value = value;\n        }\n\n        return value;\n    }\n\n    function _classPrivateFieldDestructureSet(receiver, privateMap) {\n        if (!privateMap.has(receiver)) {\n            throw new TypeError('attempted to set private field on non-instance');\n        }\n\n        var descriptor = privateMap.get(receiver);\n\n        if (descriptor.set) {\n            if (!('__destrObj' in descriptor)) {\n                descriptor.__destrObj = {\n                    set value(v) {\n                        descriptor.set.call(receiver, v);\n                    },\n                };\n            }\n\n            return descriptor.__destrObj;\n        } else {\n            if (!descriptor.writable) {\n                throw new TypeError('attempted to set read only private field');\n            }\n\n            return descriptor;\n        }\n    }\n\n    function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) {\n        if (receiver !== classConstructor) {\n            throw new TypeError('Private static access of wrong provenance');\n        }\n\n        return descriptor.value;\n    }\n\n    function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) {\n        if (receiver !== classConstructor) {\n            throw new TypeError('Private static access of wrong provenance');\n        }\n\n        if (!descriptor.writable) {\n            throw new TypeError('attempted to set read only private field');\n        }\n\n        descriptor.value = value;\n        return value;\n    }\n\n    function _classStaticPrivateMethodGet(receiver, classConstructor, method) {\n        if (receiver !== classConstructor) {\n            throw new TypeError('Private static access of wrong provenance');\n        }\n\n        return method;\n    }\n\n    function _classStaticPrivateMethodSet() {\n        throw new TypeError('attempted to set read only static private field');\n    }\n\n    function _decorate(decorators, factory, superClass, mixins) {\n        var api = _getDecoratorsApi();\n\n        if (mixins) {\n            for (var i = 0; i < mixins.length; i++) {\n                api = mixins[i](api);\n            }\n        }\n\n        var r = factory(function initialize(O) {\n            api.initializeInstanceElements(O, decorated.elements);\n        }, superClass);\n        var decorated = api.decorateClass(\n            _coalesceClassElements(r.d.map(_createElementDescriptor)),\n            decorators\n        );\n        api.initializeClassElements(r.F, decorated.elements);\n        return api.runClassFinishers(r.F, decorated.finishers);\n    }\n\n    function _getDecoratorsApi() {\n        _getDecoratorsApi = function() {\n            return api;\n        };\n\n        var api = {\n            elementsDefinitionOrder: [['method'], ['field']],\n            initializeInstanceElements: function(O, elements) {\n                ['method', 'field'].forEach(function(kind) {\n                    elements.forEach(function(element) {\n                        if (element.kind === kind && element.placement === 'own') {\n                            this.defineClassElement(O, element);\n                        }\n                    }, this);\n                }, this);\n            },\n            initializeClassElements: function(F, elements) {\n                var proto = F.prototype;\n                ['method', 'field'].forEach(function(kind) {\n                    elements.forEach(function(element) {\n                        var placement = element.placement;\n\n                        if (\n                            element.kind === kind &&\n                            (placement === 'static' || placement === 'prototype')\n                        ) {\n                            var receiver = placement === 'static' ? F : proto;\n                            this.defineClassElement(receiver, element);\n                        }\n                    }, this);\n                }, this);\n            },\n            defineClassElement: function(receiver, element) {\n                var descriptor = element.descriptor;\n\n                if (element.kind === 'field') {\n                    var initializer = element.initializer;\n                    descriptor = {\n                        enumerable: descriptor.enumerable,\n                        writable: descriptor.writable,\n                        configurable: descriptor.configurable,\n                        value: initializer === void 0 ? void 0 : initializer.call(receiver),\n                    };\n                }\n\n                Object.defineProperty(receiver, element.key, descriptor);\n            },\n            decorateClass: function(elements, decorators) {\n                var newElements = [];\n                var finishers = [];\n                var placements = {\n                    static: [],\n                    prototype: [],\n                    own: [],\n                };\n                elements.forEach(function(element) {\n                    this.addElementPlacement(element, placements);\n                }, this);\n                elements.forEach(function(element) {\n                    if (!_hasDecorators(element)) return newElements.push(element);\n                    var elementFinishersExtras = this.decorateElement(element, placements);\n                    newElements.push(elementFinishersExtras.element);\n                    newElements.push.apply(newElements, elementFinishersExtras.extras);\n                    finishers.push.apply(finishers, elementFinishersExtras.finishers);\n                }, this);\n\n                if (!decorators) {\n                    return {\n                        elements: newElements,\n                        finishers: finishers,\n                    };\n                }\n\n                var result = this.decorateConstructor(newElements, decorators);\n                finishers.push.apply(finishers, result.finishers);\n                result.finishers = finishers;\n                return result;\n            },\n            addElementPlacement: function(element, placements, silent) {\n                var keys = placements[element.placement];\n\n                if (!silent && keys.indexOf(element.key) !== -1) {\n                    throw new TypeError('Duplicated element (' + element.key + ')');\n                }\n\n                keys.push(element.key);\n            },\n            decorateElement: function(element, placements) {\n                var extras = [];\n                var finishers = [];\n\n                for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) {\n                    var keys = placements[element.placement];\n                    keys.splice(keys.indexOf(element.key), 1);\n                    var elementObject = this.fromElementDescriptor(element);\n                    var elementFinisherExtras = this.toElementFinisherExtras(\n                        (0, decorators[i])(elementObject) || elementObject\n                    );\n                    element = elementFinisherExtras.element;\n                    this.addElementPlacement(element, placements);\n\n                    if (elementFinisherExtras.finisher) {\n                        finishers.push(elementFinisherExtras.finisher);\n                    }\n\n                    var newExtras = elementFinisherExtras.extras;\n\n                    if (newExtras) {\n                        for (var j = 0; j < newExtras.length; j++) {\n                            this.addElementPlacement(newExtras[j], placements);\n                        }\n\n                        extras.push.apply(extras, newExtras);\n                    }\n                }\n\n                return {\n                    element: element,\n                    finishers: finishers,\n                    extras: extras,\n                };\n            },\n            decorateConstructor: function(elements, decorators) {\n                var finishers = [];\n\n                for (var i = decorators.length - 1; i >= 0; i--) {\n                    var obj = this.fromClassDescriptor(elements);\n                    var elementsAndFinisher = this.toClassDescriptor(\n                        (0, decorators[i])(obj) || obj\n                    );\n\n                    if (elementsAndFinisher.finisher !== undefined) {\n                        finishers.push(elementsAndFinisher.finisher);\n                    }\n\n                    if (elementsAndFinisher.elements !== undefined) {\n                        elements = elementsAndFinisher.elements;\n\n                        for (var j = 0; j < elements.length - 1; j++) {\n                            for (var k = j + 1; k < elements.length; k++) {\n                                if (\n                                    elements[j].key === elements[k].key &&\n                                    elements[j].placement === elements[k].placement\n                                ) {\n                                    throw new TypeError(\n                                        'Duplicated element (' + elements[j].key + ')'\n                                    );\n                                }\n                            }\n                        }\n                    }\n                }\n\n                return {\n                    elements: elements,\n                    finishers: finishers,\n                };\n            },\n            fromElementDescriptor: function(element) {\n                var obj = {\n                    kind: element.kind,\n                    key: element.key,\n                    placement: element.placement,\n                    descriptor: element.descriptor,\n                };\n                var desc = {\n                    value: 'Descriptor',\n                    configurable: true,\n                };\n                Object.defineProperty(obj, Symbol.toStringTag, desc);\n                if (element.kind === 'field') obj.initializer = element.initializer;\n                return obj;\n            },\n            toElementDescriptors: function(elementObjects) {\n                if (elementObjects === undefined) return;\n                return _toArray(elementObjects).map(function(elementObject) {\n                    var element = this.toElementDescriptor(elementObject);\n                    this.disallowProperty(elementObject, 'finisher', 'An element descriptor');\n                    this.disallowProperty(elementObject, 'extras', 'An element descriptor');\n                    return element;\n                }, this);\n            },\n            toElementDescriptor: function(elementObject) {\n                var kind = String(elementObject.kind);\n\n                if (kind !== 'method' && kind !== 'field') {\n                    throw new TypeError(\n                        'An element descriptor\\'s .kind property must be either \"method\" or' +\n                            ' \"field\", but a decorator created an element descriptor with' +\n                            ' .kind \"' +\n                            kind +\n                            '\"'\n                    );\n                }\n\n                var key = _toPropertyKey(elementObject.key);\n\n                var placement = String(elementObject.placement);\n\n                if (placement !== 'static' && placement !== 'prototype' && placement !== 'own') {\n                    throw new TypeError(\n                        'An element descriptor\\'s .placement property must be one of \"static\",' +\n                            ' \"prototype\" or \"own\", but a decorator created an element descriptor' +\n                            ' with .placement \"' +\n                            placement +\n                            '\"'\n                    );\n                }\n\n                var descriptor = elementObject.descriptor;\n                this.disallowProperty(elementObject, 'elements', 'An element descriptor');\n                var element = {\n                    kind: kind,\n                    key: key,\n                    placement: placement,\n                    descriptor: Object.assign({}, descriptor),\n                };\n\n                if (kind !== 'field') {\n                    this.disallowProperty(elementObject, 'initializer', 'A method descriptor');\n                } else {\n                    this.disallowProperty(\n                        descriptor,\n                        'get',\n                        'The property descriptor of a field descriptor'\n                    );\n                    this.disallowProperty(\n                        descriptor,\n                        'set',\n                        'The property descriptor of a field descriptor'\n                    );\n                    this.disallowProperty(\n                        descriptor,\n                        'value',\n                        'The property descriptor of a field descriptor'\n                    );\n                    element.initializer = elementObject.initializer;\n                }\n\n                return element;\n            },\n            toElementFinisherExtras: function(elementObject) {\n                var element = this.toElementDescriptor(elementObject);\n\n                var finisher = _optionalCallableProperty(elementObject, 'finisher');\n\n                var extras = this.toElementDescriptors(elementObject.extras);\n                return {\n                    element: element,\n                    finisher: finisher,\n                    extras: extras,\n                };\n            },\n            fromClassDescriptor: function(elements) {\n                var obj = {\n                    kind: 'class',\n                    elements: elements.map(this.fromElementDescriptor, this),\n                };\n                var desc = {\n                    value: 'Descriptor',\n                    configurable: true,\n                };\n                Object.defineProperty(obj, Symbol.toStringTag, desc);\n                return obj;\n            },\n            toClassDescriptor: function(obj) {\n                var kind = String(obj.kind);\n\n                if (kind !== 'class') {\n                    throw new TypeError(\n                        'A class descriptor\\'s .kind property must be \"class\", but a decorator' +\n                            ' created a class descriptor with .kind \"' +\n                            kind +\n                            '\"'\n                    );\n                }\n\n                this.disallowProperty(obj, 'key', 'A class descriptor');\n                this.disallowProperty(obj, 'placement', 'A class descriptor');\n                this.disallowProperty(obj, 'descriptor', 'A class descriptor');\n                this.disallowProperty(obj, 'initializer', 'A class descriptor');\n                this.disallowProperty(obj, 'extras', 'A class descriptor');\n\n                var finisher = _optionalCallableProperty(obj, 'finisher');\n\n                var elements = this.toElementDescriptors(obj.elements);\n                return {\n                    elements: elements,\n                    finisher: finisher,\n                };\n            },\n            runClassFinishers: function(constructor, finishers) {\n                for (var i = 0; i < finishers.length; i++) {\n                    var newConstructor = (0, finishers[i])(constructor);\n\n                    if (newConstructor !== undefined) {\n                        if (typeof newConstructor !== 'function') {\n                            throw new TypeError('Finishers must return a constructor.');\n                        }\n\n                        constructor = newConstructor;\n                    }\n                }\n\n                return constructor;\n            },\n            disallowProperty: function(obj, name, objectType) {\n                if (obj[name] !== undefined) {\n                    throw new TypeError(objectType + \" can't have a .\" + name + ' property.');\n                }\n            },\n        };\n        return api;\n    }\n\n    function _createElementDescriptor(def) {\n        var key = _toPropertyKey(def.key);\n\n        var descriptor;\n\n        if (def.kind === 'method') {\n            descriptor = {\n                value: def.value,\n                writable: true,\n                configurable: true,\n                enumerable: false,\n            };\n        } else if (def.kind === 'get') {\n            descriptor = {\n                get: def.value,\n                configurable: true,\n                enumerable: false,\n            };\n        } else if (def.kind === 'set') {\n            descriptor = {\n                set: def.value,\n                configurable: true,\n                enumerable: false,\n            };\n        } else if (def.kind === 'field') {\n            descriptor = {\n                configurable: true,\n                writable: true,\n                enumerable: true,\n            };\n        }\n\n        var element = {\n            kind: def.kind === 'field' ? 'field' : 'method',\n            key: key,\n            placement: def.static ? 'static' : def.kind === 'field' ? 'own' : 'prototype',\n            descriptor: descriptor,\n        };\n        if (def.decorators) element.decorators = def.decorators;\n        if (def.kind === 'field') element.initializer = def.value;\n        return element;\n    }\n\n    function _coalesceGetterSetter(element, other) {\n        if (element.descriptor.get !== undefined) {\n            other.descriptor.get = element.descriptor.get;\n        } else {\n            other.descriptor.set = element.descriptor.set;\n        }\n    }\n\n    function _coalesceClassElements(elements) {\n        var newElements = [];\n\n        var isSameElement = function(other) {\n            return (\n                other.kind === 'method' &&\n                other.key === element.key &&\n                other.placement === element.placement\n            );\n        };\n\n        for (var i = 0; i < elements.length; i++) {\n            var element = elements[i];\n            var other;\n\n            if (element.kind === 'method' && (other = newElements.find(isSameElement))) {\n                if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) {\n                    if (_hasDecorators(element) || _hasDecorators(other)) {\n                        throw new ReferenceError(\n                            'Duplicated methods (' + element.key + \") can't be decorated.\"\n                        );\n                    }\n\n                    other.descriptor = element.descriptor;\n                } else {\n                    if (_hasDecorators(element)) {\n                        if (_hasDecorators(other)) {\n                            throw new ReferenceError(\n                                \"Decorators can't be placed on different accessors with for \" +\n                                    'the same property (' +\n                                    element.key +\n                                    ').'\n                            );\n                        }\n\n                        other.decorators = element.decorators;\n                    }\n\n                    _coalesceGetterSetter(element, other);\n                }\n            } else {\n                newElements.push(element);\n            }\n        }\n\n        return newElements;\n    }\n\n    function _hasDecorators(element) {\n        return element.decorators && element.decorators.length;\n    }\n\n    function _isDataDescriptor(desc) {\n        return desc !== undefined && !(desc.value === undefined && desc.writable === undefined);\n    }\n\n    function _optionalCallableProperty(obj, name) {\n        var value = obj[name];\n\n        if (value !== undefined && typeof value !== 'function') {\n            throw new TypeError(\"Expected '\" + name + \"' to be a function\");\n        }\n\n        return value;\n    }\n\n    function _classPrivateMethodGet(receiver, privateSet, fn) {\n        if (!privateSet.has(receiver)) {\n            throw new TypeError('attempted to get private field on non-instance');\n        }\n\n        return fn;\n    }\n\n    function _classPrivateMethodSet() {\n        throw new TypeError('attempted to reassign private method');\n    }\n\n    function _wrapRegExp(re, groups) {\n        _wrapRegExp = function(re, groups) {\n            return new BabelRegExp(re, groups);\n        };\n\n        var _RegExp = _wrapNativeSuper(RegExp);\n\n        var _super = RegExp.prototype;\n\n        var _groups = new WeakMap();\n\n        function BabelRegExp(re, groups) {\n            var _this = _RegExp.call(this, re);\n\n            _groups.set(_this, groups);\n\n            return _this;\n        }\n\n        _inherits(BabelRegExp, _RegExp);\n\n        BabelRegExp.prototype.exec = function(str) {\n            var result = _super.exec.call(this, str);\n\n            if (result) result.groups = buildGroups(result, this);\n            return result;\n        };\n\n        BabelRegExp.prototype[Symbol.replace] = function(str, substitution) {\n            if (typeof substitution === 'string') {\n                var groups = _groups.get(this);\n\n                return _super[Symbol.replace].call(\n                    this,\n                    str,\n                    substitution.replace(/\\$<([^>]+)>/g, function(_, name) {\n                        return '$' + groups[name];\n                    })\n                );\n            } else if (typeof substitution === 'function') {\n                var _this = this;\n\n                return _super[Symbol.replace].call(this, str, function() {\n                    var args = [];\n                    args.push.apply(args, arguments);\n\n                    if (typeof args[args.length - 1] !== 'object') {\n                        args.push(buildGroups(args, _this));\n                    }\n\n                    return substitution.apply(this, args);\n                });\n            } else {\n                return _super[Symbol.replace].call(this, str, substitution);\n            }\n        };\n\n        function buildGroups(result, re) {\n            var g = _groups.get(re);\n\n            return Object.keys(g).reduce(function(groups, name) {\n                groups[name] = result[g[name]];\n                return groups;\n            }, Object.create(null));\n        }\n\n        return _wrapRegExp.apply(this, arguments);\n    }\n\n    var arrayRemove = function arrayRemove(arr, index) {\n        return arr.splice(index, 1);\n    };\n\n    var run = function run(cb, sync) {\n        if (sync) {\n            cb();\n        } else if (document.hidden) {\n            Promise.resolve(1).then(cb);\n        } else {\n            setTimeout(cb, 0);\n        }\n    };\n\n    var on = function on() {\n        var listeners = [];\n        var off = function off(event, cb) {\n            arrayRemove(\n                listeners,\n                listeners.findIndex(function(listener) {\n                    return listener.event === event && (listener.cb === cb || !cb);\n                })\n            );\n        };\n        var _fire = function fire(event, args, sync) {\n            listeners\n                .filter(function(listener) {\n                    return listener.event === event;\n                })\n                .map(function(listener) {\n                    return listener.cb;\n                })\n                .forEach(function(cb) {\n                    return run(function() {\n                        return cb.apply(void 0, _toConsumableArray(args));\n                    }, sync);\n                });\n        };\n        return {\n            fireSync: function fireSync(event) {\n                for (\n                    var _len = arguments.length,\n                        args = new Array(_len > 1 ? _len - 1 : 0),\n                        _key = 1;\n                    _key < _len;\n                    _key++\n                ) {\n                    args[_key - 1] = arguments[_key];\n                }\n                _fire(event, args, true);\n            },\n            fire: function fire(event) {\n                for (\n                    var _len2 = arguments.length,\n                        args = new Array(_len2 > 1 ? _len2 - 1 : 0),\n                        _key2 = 1;\n                    _key2 < _len2;\n                    _key2++\n                ) {\n                    args[_key2 - 1] = arguments[_key2];\n                }\n                _fire(event, args, false);\n            },\n            on: function on(event, cb) {\n                listeners.push({ event: event, cb: cb });\n            },\n            onOnce: function onOnce(event, _cb) {\n                listeners.push({\n                    event: event,\n                    cb: function cb() {\n                        off(event, _cb);\n                        _cb.apply(void 0, arguments);\n                    },\n                });\n            },\n            off: off,\n        };\n    };\n\n    var copyObjectPropertiesToObject = function copyObjectPropertiesToObject(\n        src,\n        target,\n        excluded\n    ) {\n        Object.getOwnPropertyNames(src)\n            .filter(function(property) {\n                return !excluded.includes(property);\n            })\n            .forEach(function(key) {\n                return Object.defineProperty(\n                    target,\n                    key,\n                    Object.getOwnPropertyDescriptor(src, key)\n                );\n            });\n    };\n\n    var PRIVATE = [\n        'fire',\n        'process',\n        'revert',\n        'load',\n        'on',\n        'off',\n        'onOnce',\n        'retryLoad',\n        'extend',\n        'archive',\n        'archived',\n        'release',\n        'released',\n        'requestProcessing',\n        'freeze',\n    ];\n\n    var createItemAPI = function createItemAPI(item) {\n        var api = {};\n        copyObjectPropertiesToObject(item, api, PRIVATE);\n        return api;\n    };\n\n    var removeReleasedItems = function removeReleasedItems(items) {\n        items.forEach(function(item, index) {\n            if (item.released) {\n                arrayRemove(items, index);\n            }\n        });\n    };\n\n    var ItemStatus = {\n        INIT: 1,\n        IDLE: 2,\n        PROCESSING_QUEUED: 9,\n        PROCESSING: 3,\n        PROCESSING_COMPLETE: 5,\n        PROCESSING_ERROR: 6,\n        PROCESSING_REVERT_ERROR: 10,\n        LOADING: 7,\n        LOAD_ERROR: 8,\n    };\n\n    var FileOrigin = {\n        INPUT: 1,\n        LIMBO: 2,\n        LOCAL: 3,\n    };\n\n    var getNonNumeric = function getNonNumeric(str) {\n        return /[^0-9]+/.exec(str);\n    };\n\n    var getDecimalSeparator = function getDecimalSeparator() {\n        return getNonNumeric((1.1).toLocaleString())[0];\n    };\n\n    var getThousandsSeparator = function getThousandsSeparator() {\n        // Added for browsers that do not return the thousands separator (happend on native browser Android 4.4.4)\n        // We check against the normal toString output and if they're the same return a comma when decimal separator is a dot\n        var decimalSeparator = getDecimalSeparator();\n        var thousandsStringWithSeparator = (1000.0).toLocaleString();\n        var thousandsStringWithoutSeparator = (1000.0).toString();\n        if (thousandsStringWithSeparator !== thousandsStringWithoutSeparator) {\n            return getNonNumeric(thousandsStringWithSeparator)[0];\n        }\n        return decimalSeparator === '.' ? ',' : '.';\n    };\n\n    var Type = {\n        BOOLEAN: 'boolean',\n        INT: 'int',\n        NUMBER: 'number',\n        STRING: 'string',\n        ARRAY: 'array',\n        OBJECT: 'object',\n        FUNCTION: 'function',\n        ACTION: 'action',\n        SERVER_API: 'serverapi',\n        REGEX: 'regex',\n    };\n\n    // all registered filters\n    var filters = [];\n\n    // loops over matching filters and passes options to each filter, returning the mapped results\n    var applyFilterChain = function applyFilterChain(key, value, utils) {\n        return new Promise(function(resolve, reject) {\n            // find matching filters for this key\n            var matchingFilters = filters\n                .filter(function(f) {\n                    return f.key === key;\n                })\n                .map(function(f) {\n                    return f.cb;\n                });\n\n            // resolve now\n            if (matchingFilters.length === 0) {\n                resolve(value);\n                return;\n            }\n\n            // first filter to kick things of\n            var initialFilter = matchingFilters.shift();\n\n            // chain filters\n            matchingFilters\n                .reduce(\n                    // loop over promises passing value to next promise\n                    function(current, next) {\n                        return current.then(function(value) {\n                            return next(value, utils);\n                        });\n                    },\n\n                    // call initial filter, will return a promise\n                    initialFilter(value, utils)\n\n                    // all executed\n                )\n                .then(function(value) {\n                    return resolve(value);\n                })\n                .catch(function(error) {\n                    return reject(error);\n                });\n        });\n    };\n\n    var applyFilters = function applyFilters(key, value, utils) {\n        return filters\n            .filter(function(f) {\n                return f.key === key;\n            })\n            .map(function(f) {\n                return f.cb(value, utils);\n            });\n    };\n\n    // adds a new filter to the list\n    var addFilter = function addFilter(key, cb) {\n        return filters.push({ key: key, cb: cb });\n    };\n\n    var extendDefaultOptions = function extendDefaultOptions(additionalOptions) {\n        return Object.assign(defaultOptions, additionalOptions);\n    };\n\n    var getOptions = function getOptions() {\n        return Object.assign({}, defaultOptions);\n    };\n\n    var setOptions = function setOptions(opts) {\n        forin(opts, function(key, value) {\n            // key does not exist, so this option cannot be set\n            if (!defaultOptions[key]) {\n                return;\n            }\n            defaultOptions[key][0] = getValueByType(\n                value,\n                defaultOptions[key][0],\n                defaultOptions[key][1]\n            );\n        });\n    };\n\n    // default options on app\n    var defaultOptions = {\n        // the id to add to the root element\n        id: [null, Type.STRING],\n\n        // input field name to use\n        name: ['filepond', Type.STRING],\n\n        // disable the field\n        disabled: [false, Type.BOOLEAN],\n\n        // classname to put on wrapper\n        className: [null, Type.STRING],\n\n        // is the field required\n        required: [false, Type.BOOLEAN],\n\n        // Allow media capture when value is set\n        captureMethod: [null, Type.STRING],\n        // - \"camera\", \"microphone\" or \"camcorder\",\n        // - Does not work with multiple on apple devices\n        // - If set, acceptedFileTypes must be made to match with media wildcard \"image/*\", \"audio/*\" or \"video/*\"\n\n        // sync `acceptedFileTypes` property with `accept` attribute\n        allowSyncAcceptAttribute: [true, Type.BOOLEAN],\n\n        // Feature toggles\n        allowDrop: [true, Type.BOOLEAN], // Allow dropping of files\n        allowBrowse: [true, Type.BOOLEAN], // Allow browsing the file system\n        allowPaste: [true, Type.BOOLEAN], // Allow pasting files\n        allowMultiple: [false, Type.BOOLEAN], // Allow multiple files (disabled by default, as multiple attribute is also required on input to allow multiple)\n        allowReplace: [true, Type.BOOLEAN], // Allow dropping a file on other file to replace it (only works when multiple is set to false)\n        allowRevert: [true, Type.BOOLEAN], // Allows user to revert file upload\n        allowRemove: [true, Type.BOOLEAN], // Allow user to remove a file\n        allowProcess: [true, Type.BOOLEAN], // Allows user to process a file, when set to false, this removes the file upload button\n        allowReorder: [false, Type.BOOLEAN], // Allow reordering of files\n        allowDirectoriesOnly: [false, Type.BOOLEAN], // Allow only selecting directories with browse (no support for filtering dnd at this point)\n\n        // Try store file if `server` not set\n        storeAsFile: [false, Type.BOOLEAN],\n\n        // Revert mode\n        forceRevert: [false, Type.BOOLEAN], // Set to 'force' to require the file to be reverted before removal\n\n        // Input requirements\n        maxFiles: [null, Type.INT], // Max number of files\n        checkValidity: [false, Type.BOOLEAN], // Enables custom validity messages\n\n        // Where to put file\n        itemInsertLocationFreedom: [true, Type.BOOLEAN], // Set to false to always add items to begin or end of list\n        itemInsertLocation: ['before', Type.STRING], // Default index in list to add items that have been dropped at the top of the list\n        itemInsertInterval: [75, Type.INT],\n\n        // Drag 'n Drop related\n        dropOnPage: [false, Type.BOOLEAN], // Allow dropping of files anywhere on page (prevents browser from opening file if dropped outside of Up)\n        dropOnElement: [true, Type.BOOLEAN], // Drop needs to happen on element (set to false to also load drops outside of Up)\n        dropValidation: [false, Type.BOOLEAN], // Enable or disable validating files on drop\n        ignoredFiles: [['.ds_store', 'thumbs.db', 'desktop.ini'], Type.ARRAY],\n\n        // Upload related\n        instantUpload: [true, Type.BOOLEAN], // Should upload files immediately on drop\n        maxParallelUploads: [2, Type.INT], // Maximum files to upload in parallel\n        allowMinimumUploadDuration: [true, Type.BOOLEAN], // if true uploads take at least 750 ms, this ensures the user sees the upload progress giving trust the upload actually happened\n\n        // Chunks\n        chunkUploads: [false, Type.BOOLEAN], // Enable chunked uploads\n        chunkForce: [false, Type.BOOLEAN], // Force use of chunk uploads even for files smaller than chunk size\n        chunkSize: [5000000, Type.INT], // Size of chunks (5MB default)\n        chunkRetryDelays: [[500, 1000, 3000], Type.ARRAY], // Amount of times to retry upload of a chunk when it fails\n\n        // The server api end points to use for uploading (see docs)\n        server: [null, Type.SERVER_API],\n\n        // File size calculations, can set to 1024, this is only used for display, properties use file size base 1000\n        fileSizeBase: [1000, Type.INT],\n\n        // Labels and status messages\n        labelFileSizeBytes: ['bytes', Type.STRING],\n        labelFileSizeKilobytes: ['KB', Type.STRING],\n        labelFileSizeMegabytes: ['MB', Type.STRING],\n        labelFileSizeGigabytes: ['GB', Type.STRING],\n\n        labelDecimalSeparator: [getDecimalSeparator(), Type.STRING], // Default is locale separator\n        labelThousandsSeparator: [getThousandsSeparator(), Type.STRING], // Default is locale separator\n\n        labelIdle: [\n            'Drag & Drop your files or <span class=\"filepond--label-action\">Browse</span>',\n            Type.STRING,\n        ],\n\n        labelInvalidField: ['Field contains invalid files', Type.STRING],\n        labelFileWaitingForSize: ['Waiting for size', Type.STRING],\n        labelFileSizeNotAvailable: ['Size not available', Type.STRING],\n        labelFileCountSingular: ['file in list', Type.STRING],\n        labelFileCountPlural: ['files in list', Type.STRING],\n        labelFileLoading: ['Loading', Type.STRING],\n        labelFileAdded: ['Added', Type.STRING], // assistive only\n        labelFileLoadError: ['Error during load', Type.STRING],\n        labelFileRemoved: ['Removed', Type.STRING], // assistive only\n        labelFileRemoveError: ['Error during remove', Type.STRING],\n        labelFileProcessing: ['Uploading', Type.STRING],\n        labelFileProcessingComplete: ['Upload complete', Type.STRING],\n        labelFileProcessingAborted: ['Upload cancelled', Type.STRING],\n        labelFileProcessingError: ['Error during upload', Type.STRING],\n        labelFileProcessingRevertError: ['Error during revert', Type.STRING],\n\n        labelTapToCancel: ['tap to cancel', Type.STRING],\n        labelTapToRetry: ['tap to retry', Type.STRING],\n        labelTapToUndo: ['tap to undo', Type.STRING],\n\n        labelButtonRemoveItem: ['Remove', Type.STRING],\n        labelButtonAbortItemLoad: ['Abort', Type.STRING],\n        labelButtonRetryItemLoad: ['Retry', Type.STRING],\n        labelButtonAbortItemProcessing: ['Cancel', Type.STRING],\n        labelButtonUndoItemProcessing: ['Undo', Type.STRING],\n        labelButtonRetryItemProcessing: ['Retry', Type.STRING],\n        labelButtonProcessItem: ['Upload', Type.STRING],\n\n        // make sure width and height plus viewpox are even numbers so icons are nicely centered\n        iconRemove: [\n            '<svg width=\"26\" height=\"26\" viewBox=\"0 0 26 26\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M11.586 13l-2.293 2.293a1 1 0 0 0 1.414 1.414L13 14.414l2.293 2.293a1 1 0 0 0 1.414-1.414L14.414 13l2.293-2.293a1 1 0 0 0-1.414-1.414L13 11.586l-2.293-2.293a1 1 0 0 0-1.414 1.414L11.586 13z\" fill=\"currentColor\" fill-rule=\"nonzero\"/></svg>',\n            Type.STRING,\n        ],\n\n        iconProcess: [\n            '<svg width=\"26\" height=\"26\" viewBox=\"0 0 26 26\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M14 10.414v3.585a1 1 0 0 1-2 0v-3.585l-1.293 1.293a1 1 0 0 1-1.414-1.415l3-3a1 1 0 0 1 1.414 0l3 3a1 1 0 0 1-1.414 1.415L14 10.414zM9 18a1 1 0 0 1 0-2h8a1 1 0 0 1 0 2H9z\" fill=\"currentColor\" fill-rule=\"evenodd\"/></svg>',\n            Type.STRING,\n        ],\n\n        iconRetry: [\n            '<svg width=\"26\" height=\"26\" viewBox=\"0 0 26 26\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.81 9.185l-.038.02A4.997 4.997 0 0 0 8 13.683a5 5 0 0 0 5 5 5 5 0 0 0 5-5 1 1 0 0 1 2 0A7 7 0 1 1 9.722 7.496l-.842-.21a.999.999 0 1 1 .484-1.94l3.23.806c.535.133.86.675.73 1.21l-.804 3.233a.997.997 0 0 1-1.21.73.997.997 0 0 1-.73-1.21l.23-.928v-.002z\" fill=\"currentColor\" fill-rule=\"nonzero\"/></svg>',\n            Type.STRING,\n        ],\n\n        iconUndo: [\n            '<svg width=\"26\" height=\"26\" viewBox=\"0 0 26 26\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M9.185 10.81l.02-.038A4.997 4.997 0 0 1 13.683 8a5 5 0 0 1 5 5 5 5 0 0 1-5 5 1 1 0 0 0 0 2A7 7 0 1 0 7.496 9.722l-.21-.842a.999.999 0 1 0-1.94.484l.806 3.23c.133.535.675.86 1.21.73l3.233-.803a.997.997 0 0 0 .73-1.21.997.997 0 0 0-1.21-.73l-.928.23-.002-.001z\" fill=\"currentColor\" fill-rule=\"nonzero\"/></svg>',\n            Type.STRING,\n        ],\n\n        iconDone: [\n            '<svg width=\"26\" height=\"26\" viewBox=\"0 0 26 26\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M18.293 9.293a1 1 0 0 1 1.414 1.414l-7.002 7a1 1 0 0 1-1.414 0l-3.998-4a1 1 0 1 1 1.414-1.414L12 15.586l6.294-6.293z\" fill=\"currentColor\" fill-rule=\"nonzero\"/></svg>',\n            Type.STRING,\n        ],\n\n        // event handlers\n        oninit: [null, Type.FUNCTION],\n        onwarning: [null, Type.FUNCTION],\n        onerror: [null, Type.FUNCTION],\n        onactivatefile: [null, Type.FUNCTION],\n        oninitfile: [null, Type.FUNCTION],\n        onaddfilestart: [null, Type.FUNCTION],\n        onaddfileprogress: [null, Type.FUNCTION],\n        onaddfile: [null, Type.FUNCTION],\n        onprocessfilestart: [null, Type.FUNCTION],\n        onprocessfileprogress: [null, Type.FUNCTION],\n        onprocessfileabort: [null, Type.FUNCTION],\n        onprocessfilerevert: [null, Type.FUNCTION],\n        onprocessfile: [null, Type.FUNCTION],\n        onprocessfiles: [null, Type.FUNCTION],\n        onremovefile: [null, Type.FUNCTION],\n        onpreparefile: [null, Type.FUNCTION],\n        onupdatefiles: [null, Type.FUNCTION],\n        onreorderfiles: [null, Type.FUNCTION],\n\n        // hooks\n        beforeDropFile: [null, Type.FUNCTION],\n        beforeAddFile: [null, Type.FUNCTION],\n        beforeRemoveFile: [null, Type.FUNCTION],\n        beforePrepareFile: [null, Type.FUNCTION],\n\n        // styles\n        stylePanelLayout: [null, Type.STRING], // null 'integrated', 'compact', 'circle'\n        stylePanelAspectRatio: [null, Type.STRING], // null or '3:2' or 1\n        styleItemPanelAspectRatio: [null, Type.STRING],\n        styleButtonRemoveItemPosition: ['left', Type.STRING],\n        styleButtonProcessItemPosition: ['right', Type.STRING],\n        styleLoadIndicatorPosition: ['right', Type.STRING],\n        styleProgressIndicatorPosition: ['right', Type.STRING],\n        styleButtonRemoveItemAlign: [false, Type.BOOLEAN],\n\n        // custom initial files array\n        files: [[], Type.ARRAY],\n\n        // show support by displaying credits\n        credits: [['https://pqina.nl/', 'Powered by PQINA'], Type.ARRAY],\n    };\n\n    var getItemByQuery = function getItemByQuery(items, query) {\n        // just return first index\n        if (isEmpty(query)) {\n            return items[0] || null;\n        }\n\n        // query is index\n        if (isInt(query)) {\n            return items[query] || null;\n        }\n\n        // if query is item, get the id\n        if (typeof query === 'object') {\n            query = query.id;\n        }\n\n        // assume query is a string and return item by id\n        return (\n            items.find(function(item) {\n                return item.id === query;\n            }) || null\n        );\n    };\n\n    var getNumericAspectRatioFromString = function getNumericAspectRatioFromString(aspectRatio) {\n        if (isEmpty(aspectRatio)) {\n            return aspectRatio;\n        }\n        if (/:/.test(aspectRatio)) {\n            var parts = aspectRatio.split(':');\n            return parts[1] / parts[0];\n        }\n        return parseFloat(aspectRatio);\n    };\n\n    var getActiveItems = function getActiveItems(items) {\n        return items.filter(function(item) {\n            return !item.archived;\n        });\n    };\n\n    var Status = {\n        EMPTY: 0,\n        IDLE: 1, // waiting\n        ERROR: 2, // a file is in error state\n        BUSY: 3, // busy processing or loading\n        READY: 4, // all files uploaded\n    };\n\n    var res = null;\n    var canUpdateFileInput = function canUpdateFileInput() {\n        if (res === null) {\n            try {\n                var dataTransfer = new DataTransfer();\n                dataTransfer.items.add(new File(['hello world'], 'This_Works.txt'));\n                var el = document.createElement('input');\n                el.setAttribute('type', 'file');\n                el.files = dataTransfer.files;\n                res = el.files.length === 1;\n            } catch (err) {\n                res = false;\n            }\n        }\n        return res;\n    };\n\n    var ITEM_ERROR = [\n        ItemStatus.LOAD_ERROR,\n        ItemStatus.PROCESSING_ERROR,\n        ItemStatus.PROCESSING_REVERT_ERROR,\n    ];\n\n    var ITEM_BUSY = [\n        ItemStatus.LOADING,\n        ItemStatus.PROCESSING,\n        ItemStatus.PROCESSING_QUEUED,\n        ItemStatus.INIT,\n    ];\n\n    var ITEM_READY = [ItemStatus.PROCESSING_COMPLETE];\n\n    var isItemInErrorState = function isItemInErrorState(item) {\n        return ITEM_ERROR.includes(item.status);\n    };\n    var isItemInBusyState = function isItemInBusyState(item) {\n        return ITEM_BUSY.includes(item.status);\n    };\n    var isItemInReadyState = function isItemInReadyState(item) {\n        return ITEM_READY.includes(item.status);\n    };\n\n    var isAsync = function isAsync(state) {\n        return (\n            isObject(state.options.server) &&\n            (isObject(state.options.server.process) || isFunction(state.options.server.process))\n        );\n    };\n\n    var queries = function queries(state) {\n        return {\n            GET_STATUS: function GET_STATUS() {\n                var items = getActiveItems(state.items);\n                var EMPTY = Status.EMPTY,\n                    ERROR = Status.ERROR,\n                    BUSY = Status.BUSY,\n                    IDLE = Status.IDLE,\n                    READY = Status.READY;\n\n                if (items.length === 0) return EMPTY;\n\n                if (items.some(isItemInErrorState)) return ERROR;\n\n                if (items.some(isItemInBusyState)) return BUSY;\n\n                if (items.some(isItemInReadyState)) return READY;\n\n                return IDLE;\n            },\n\n            GET_ITEM: function GET_ITEM(query) {\n                return getItemByQuery(state.items, query);\n            },\n\n            GET_ACTIVE_ITEM: function GET_ACTIVE_ITEM(query) {\n                return getItemByQuery(getActiveItems(state.items), query);\n            },\n\n            GET_ACTIVE_ITEMS: function GET_ACTIVE_ITEMS() {\n                return getActiveItems(state.items);\n            },\n\n            GET_ITEMS: function GET_ITEMS() {\n                return state.items;\n            },\n\n            GET_ITEM_NAME: function GET_ITEM_NAME(query) {\n                var item = getItemByQuery(state.items, query);\n                return item ? item.filename : null;\n            },\n\n            GET_ITEM_SIZE: function GET_ITEM_SIZE(query) {\n                var item = getItemByQuery(state.items, query);\n                return item ? item.fileSize : null;\n            },\n\n            GET_STYLES: function GET_STYLES() {\n                return Object.keys(state.options)\n                    .filter(function(key) {\n                        return /^style/.test(key);\n                    })\n                    .map(function(option) {\n                        return {\n                            name: option,\n                            value: state.options[option],\n                        };\n                    });\n            },\n\n            GET_PANEL_ASPECT_RATIO: function GET_PANEL_ASPECT_RATIO() {\n                var isShapeCircle = /circle/.test(state.options.stylePanelLayout);\n                var aspectRatio = isShapeCircle\n                    ? 1\n                    : getNumericAspectRatioFromString(state.options.stylePanelAspectRatio);\n                return aspectRatio;\n            },\n\n            GET_ITEM_PANEL_ASPECT_RATIO: function GET_ITEM_PANEL_ASPECT_RATIO() {\n                return state.options.styleItemPanelAspectRatio;\n            },\n\n            GET_ITEMS_BY_STATUS: function GET_ITEMS_BY_STATUS(status) {\n                return getActiveItems(state.items).filter(function(item) {\n                    return item.status === status;\n                });\n            },\n\n            GET_TOTAL_ITEMS: function GET_TOTAL_ITEMS() {\n                return getActiveItems(state.items).length;\n            },\n\n            SHOULD_UPDATE_FILE_INPUT: function SHOULD_UPDATE_FILE_INPUT() {\n                return state.options.storeAsFile && canUpdateFileInput() && !isAsync(state);\n            },\n\n            IS_ASYNC: function IS_ASYNC() {\n                return isAsync(state);\n            },\n\n            GET_FILE_SIZE_LABELS: function GET_FILE_SIZE_LABELS(query) {\n                return {\n                    labelBytes: query('GET_LABEL_FILE_SIZE_BYTES') || undefined,\n                    labelKilobytes: query('GET_LABEL_FILE_SIZE_KILOBYTES') || undefined,\n                    labelMegabytes: query('GET_LABEL_FILE_SIZE_MEGABYTES') || undefined,\n                    labelGigabytes: query('GET_LABEL_FILE_SIZE_GIGABYTES') || undefined,\n                };\n            },\n        };\n    };\n\n    var hasRoomForItem = function hasRoomForItem(state) {\n        var count = getActiveItems(state.items).length;\n\n        // if cannot have multiple items, to add one item it should currently not contain items\n        if (!state.options.allowMultiple) {\n            return count === 0;\n        }\n\n        // if allows multiple items, we check if a max item count has been set, if not, there's no limit\n        var maxFileCount = state.options.maxFiles;\n        if (maxFileCount === null) {\n            return true;\n        }\n\n        // we check if the current count is smaller than the max count, if so, another file can still be added\n        if (count < maxFileCount) {\n            return true;\n        }\n\n        // no more room for another file\n        return false;\n    };\n\n    var limit = function limit(value, min, max) {\n        return Math.max(Math.min(max, value), min);\n    };\n\n    var arrayInsert = function arrayInsert(arr, index, item) {\n        return arr.splice(index, 0, item);\n    };\n\n    var insertItem = function insertItem(items, item, index) {\n        if (isEmpty(item)) {\n            return null;\n        }\n\n        // if index is undefined, append\n        if (typeof index === 'undefined') {\n            items.push(item);\n            return item;\n        }\n\n        // limit the index to the size of the items array\n        index = limit(index, 0, items.length);\n\n        // add item to array\n        arrayInsert(items, index, item);\n\n        // expose\n        return item;\n    };\n\n    var isBase64DataURI = function isBase64DataURI(str) {\n        return /^\\s*data:([a-z]+\\/[a-z0-9-+.]+(;[a-z-]+=[a-z0-9-]+)?)?(;base64)?,([a-z0-9!$&',()*+;=\\-._~:@\\/?%\\s]*)\\s*$/i.test(\n            str\n        );\n    };\n\n    var getFilenameFromURL = function getFilenameFromURL(url) {\n        return url\n            .split('/')\n            .pop()\n            .split('?')\n            .shift();\n    };\n\n    var getExtensionFromFilename = function getExtensionFromFilename(name) {\n        return name.split('.').pop();\n    };\n\n    var guesstimateExtension = function guesstimateExtension(type) {\n        // if no extension supplied, exit here\n        if (typeof type !== 'string') {\n            return '';\n        }\n\n        // get subtype\n        var subtype = type.split('/').pop();\n\n        // is svg subtype\n        if (/svg/.test(subtype)) {\n            return 'svg';\n        }\n\n        if (/zip|compressed/.test(subtype)) {\n            return 'zip';\n        }\n\n        if (/plain/.test(subtype)) {\n            return 'txt';\n        }\n\n        if (/msword/.test(subtype)) {\n            return 'doc';\n        }\n\n        // if is valid subtype\n        if (/[a-z]+/.test(subtype)) {\n            // always use jpg extension\n            if (subtype === 'jpeg') {\n                return 'jpg';\n            }\n\n            // return subtype\n            return subtype;\n        }\n\n        return '';\n    };\n\n    var leftPad = function leftPad(value) {\n        var padding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n        return (padding + value).slice(-padding.length);\n    };\n\n    var getDateString = function getDateString() {\n        var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Date();\n        return (\n            date.getFullYear() +\n            '-' +\n            leftPad(date.getMonth() + 1, '00') +\n            '-' +\n            leftPad(date.getDate(), '00') +\n            '_' +\n            leftPad(date.getHours(), '00') +\n            '-' +\n            leftPad(date.getMinutes(), '00') +\n            '-' +\n            leftPad(date.getSeconds(), '00')\n        );\n    };\n\n    var getFileFromBlob = function getFileFromBlob(blob, filename) {\n        var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n        var extension = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n        var file =\n            typeof type === 'string'\n                ? blob.slice(0, blob.size, type)\n                : blob.slice(0, blob.size, blob.type);\n        file.lastModifiedDate = new Date();\n\n        // copy relative path\n        if (blob._relativePath) file._relativePath = blob._relativePath;\n\n        // if blob has name property, use as filename if no filename supplied\n        if (!isString(filename)) {\n            filename = getDateString();\n        }\n\n        // if filename supplied but no extension and filename has extension\n        if (filename && extension === null && getExtensionFromFilename(filename)) {\n            file.name = filename;\n        } else {\n            extension = extension || guesstimateExtension(file.type);\n            file.name = filename + (extension ? '.' + extension : '');\n        }\n\n        return file;\n    };\n\n    var getBlobBuilder = function getBlobBuilder() {\n        return (window.BlobBuilder =\n            window.BlobBuilder ||\n            window.WebKitBlobBuilder ||\n            window.MozBlobBuilder ||\n            window.MSBlobBuilder);\n    };\n\n    var createBlob = function createBlob(arrayBuffer, mimeType) {\n        var BB = getBlobBuilder();\n\n        if (BB) {\n            var bb = new BB();\n            bb.append(arrayBuffer);\n            return bb.getBlob(mimeType);\n        }\n\n        return new Blob([arrayBuffer], {\n            type: mimeType,\n        });\n    };\n\n    var getBlobFromByteStringWithMimeType = function getBlobFromByteStringWithMimeType(\n        byteString,\n        mimeType\n    ) {\n        var ab = new ArrayBuffer(byteString.length);\n        var ia = new Uint8Array(ab);\n\n        for (var i = 0; i < byteString.length; i++) {\n            ia[i] = byteString.charCodeAt(i);\n        }\n\n        return createBlob(ab, mimeType);\n    };\n\n    var getMimeTypeFromBase64DataURI = function getMimeTypeFromBase64DataURI(dataURI) {\n        return (/^data:(.+);/.exec(dataURI) || [])[1] || null;\n    };\n\n    var getBase64DataFromBase64DataURI = function getBase64DataFromBase64DataURI(dataURI) {\n        // get data part of string (remove data:image/jpeg...,)\n        var data = dataURI.split(',')[1];\n\n        // remove any whitespace as that causes InvalidCharacterError in IE\n        return data.replace(/\\s/g, '');\n    };\n\n    var getByteStringFromBase64DataURI = function getByteStringFromBase64DataURI(dataURI) {\n        return atob(getBase64DataFromBase64DataURI(dataURI));\n    };\n\n    var getBlobFromBase64DataURI = function getBlobFromBase64DataURI(dataURI) {\n        var mimeType = getMimeTypeFromBase64DataURI(dataURI);\n        var byteString = getByteStringFromBase64DataURI(dataURI);\n\n        return getBlobFromByteStringWithMimeType(byteString, mimeType);\n    };\n\n    var getFileFromBase64DataURI = function getFileFromBase64DataURI(dataURI, filename, extension) {\n        return getFileFromBlob(getBlobFromBase64DataURI(dataURI), filename, null, extension);\n    };\n\n    var getFileNameFromHeader = function getFileNameFromHeader(header) {\n        // test if is content disposition header, if not exit\n        if (!/^content-disposition:/i.test(header)) return null;\n\n        // get filename parts\n        var matches = header\n            .split(/filename=|filename\\*=.+''/)\n            .splice(1)\n            .map(function(name) {\n                return name.trim().replace(/^[\"']|[;\"']{0,2}$/g, '');\n            })\n            .filter(function(name) {\n                return name.length;\n            });\n\n        return matches.length ? decodeURI(matches[matches.length - 1]) : null;\n    };\n\n    var getFileSizeFromHeader = function getFileSizeFromHeader(header) {\n        if (/content-length:/i.test(header)) {\n            var size = header.match(/[0-9]+/)[0];\n            return size ? parseInt(size, 10) : null;\n        }\n        return null;\n    };\n\n    var getTranfserIdFromHeader = function getTranfserIdFromHeader(header) {\n        if (/x-content-transfer-id:/i.test(header)) {\n            var id = (header.split(':')[1] || '').trim();\n            return id || null;\n        }\n        return null;\n    };\n\n    var getFileInfoFromHeaders = function getFileInfoFromHeaders(headers) {\n        var info = {\n            source: null,\n            name: null,\n            size: null,\n        };\n\n        var rows = headers.split('\\n');\n        var _iteratorNormalCompletion = true;\n        var _didIteratorError = false;\n        var _iteratorError = undefined;\n        try {\n            for (\n                var _iterator = rows[Symbol.iterator](), _step;\n                !(_iteratorNormalCompletion = (_step = _iterator.next()).done);\n                _iteratorNormalCompletion = true\n            ) {\n                var header = _step.value;\n\n                var name = getFileNameFromHeader(header);\n                if (name) {\n                    info.name = name;\n                    continue;\n                }\n\n                var size = getFileSizeFromHeader(header);\n                if (size) {\n                    info.size = size;\n                    continue;\n                }\n\n                var source = getTranfserIdFromHeader(header);\n                if (source) {\n                    info.source = source;\n                    continue;\n                }\n            }\n        } catch (err) {\n            _didIteratorError = true;\n            _iteratorError = err;\n        } finally {\n            try {\n                if (!_iteratorNormalCompletion && _iterator.return != null) {\n                    _iterator.return();\n                }\n            } finally {\n                if (_didIteratorError) {\n                    throw _iteratorError;\n                }\n            }\n        }\n\n        return info;\n    };\n\n    var createFileLoader = function createFileLoader(fetchFn) {\n        var state = {\n            source: null,\n            complete: false,\n            progress: 0,\n            size: null,\n            timestamp: null,\n            duration: 0,\n            request: null,\n        };\n\n        var getProgress = function getProgress() {\n            return state.progress;\n        };\n        var abort = function abort() {\n            if (state.request && state.request.abort) {\n                state.request.abort();\n            }\n        };\n\n        // load source\n        var load = function load() {\n            // get quick reference\n            var source = state.source;\n\n            api.fire('init', source);\n\n            // Load Files\n            if (source instanceof File) {\n                api.fire('load', source);\n            } else if (source instanceof Blob) {\n                // Load blobs, set default name to current date\n                api.fire('load', getFileFromBlob(source, source.name));\n            } else if (isBase64DataURI(source)) {\n                // Load base 64, set default name to current date\n                api.fire('load', getFileFromBase64DataURI(source));\n            } else {\n                // Deal as if is external URL, let's load it!\n                loadURL(source);\n            }\n        };\n\n        // loads a url\n        var loadURL = function loadURL(url) {\n            // is remote url and no fetch method supplied\n            if (!fetchFn) {\n                api.fire('error', {\n                    type: 'error',\n                    body: \"Can't load URL\",\n                    code: 400,\n                });\n\n                return;\n            }\n\n            // set request start\n            state.timestamp = Date.now();\n\n            // load file\n            state.request = fetchFn(\n                url,\n                function(response) {\n                    // update duration\n                    state.duration = Date.now() - state.timestamp;\n\n                    // done!\n                    state.complete = true;\n\n                    // turn blob response into a file\n                    if (response instanceof Blob) {\n                        response = getFileFromBlob(\n                            response,\n                            response.name || getFilenameFromURL(url)\n                        );\n                    }\n\n                    api.fire(\n                        'load',\n                        // if has received blob, we go with blob, if no response, we return null\n                        response instanceof Blob ? response : response ? response.body : null\n                    );\n                },\n                function(error) {\n                    api.fire(\n                        'error',\n                        typeof error === 'string'\n                            ? {\n                                  type: 'error',\n                                  code: 0,\n                                  body: error,\n                              }\n                            : error\n                    );\n                },\n                function(computable, current, total) {\n                    // collected some meta data already\n                    if (total) {\n                        state.size = total;\n                    }\n\n                    // update duration\n                    state.duration = Date.now() - state.timestamp;\n\n                    // if we can't compute progress, we're not going to fire progress events\n                    if (!computable) {\n                        state.progress = null;\n                        return;\n                    }\n\n                    // update progress percentage\n                    state.progress = current / total;\n\n                    // expose\n                    api.fire('progress', state.progress);\n                },\n                function() {\n                    api.fire('abort');\n                },\n                function(response) {\n                    var fileinfo = getFileInfoFromHeaders(\n                        typeof response === 'string' ? response : response.headers\n                    );\n                    api.fire('meta', {\n                        size: state.size || fileinfo.size,\n                        filename: fileinfo.name,\n                        source: fileinfo.source,\n                    });\n                }\n            );\n        };\n\n        var api = Object.assign({}, on(), {\n            setSource: function setSource(source) {\n                return (state.source = source);\n            },\n            getProgress: getProgress, // file load progress\n            abort: abort, // abort file load\n            load: load, // start load\n        });\n\n        return api;\n    };\n\n    var isGet = function isGet(method) {\n        return /GET|HEAD/.test(method);\n    };\n\n    var sendRequest = function sendRequest(data, url, options) {\n        var api = {\n            onheaders: function onheaders() {},\n            onprogress: function onprogress() {},\n            onload: function onload() {},\n            ontimeout: function ontimeout() {},\n            onerror: function onerror() {},\n            onabort: function onabort() {},\n            abort: function abort() {\n                aborted = true;\n                xhr.abort();\n            },\n        };\n\n        // timeout identifier, only used when timeout is defined\n        var aborted = false;\n        var headersReceived = false;\n\n        // set default options\n        options = Object.assign(\n            {\n                method: 'POST',\n                headers: {},\n                withCredentials: false,\n            },\n            options\n        );\n\n        // encode url\n        url = encodeURI(url);\n\n        // if method is GET, add any received data to url\n\n        if (isGet(options.method) && data) {\n            url =\n                '' +\n                url +\n                encodeURIComponent(typeof data === 'string' ? data : JSON.stringify(data));\n        }\n\n        // create request\n        var xhr = new XMLHttpRequest();\n\n        // progress of load\n        var process = isGet(options.method) ? xhr : xhr.upload;\n        process.onprogress = function(e) {\n            // no progress event when aborted ( onprogress is called once after abort() )\n            if (aborted) {\n                return;\n            }\n\n            api.onprogress(e.lengthComputable, e.loaded, e.total);\n        };\n\n        // tries to get header info to the app as fast as possible\n        xhr.onreadystatechange = function() {\n            // not interesting in these states ('unsent' and 'openend' as they don't give us any additional info)\n            if (xhr.readyState < 2) {\n                return;\n            }\n\n            // no server response\n            if (xhr.readyState === 4 && xhr.status === 0) {\n                return;\n            }\n\n            if (headersReceived) {\n                return;\n            }\n\n            headersReceived = true;\n\n            // we've probably received some useful data in response headers\n            api.onheaders(xhr);\n        };\n\n        // load successful\n        xhr.onload = function() {\n            // is classified as valid response\n            if (xhr.status >= 200 && xhr.status < 300) {\n                api.onload(xhr);\n            } else {\n                api.onerror(xhr);\n            }\n        };\n\n        // error during load\n        xhr.onerror = function() {\n            return api.onerror(xhr);\n        };\n\n        // request aborted\n        xhr.onabort = function() {\n            aborted = true;\n            api.onabort();\n        };\n\n        // request timeout\n        xhr.ontimeout = function() {\n            return api.ontimeout(xhr);\n        };\n\n        // open up open up!\n        xhr.open(options.method, url, true);\n\n        // set timeout if defined (do it after open so IE11 plays ball)\n        if (isInt(options.timeout)) {\n            xhr.timeout = options.timeout;\n        }\n\n        // add headers\n        Object.keys(options.headers).forEach(function(key) {\n            var value = unescape(encodeURIComponent(options.headers[key]));\n            xhr.setRequestHeader(key, value);\n        });\n\n        // set type of response\n        if (options.responseType) {\n            xhr.responseType = options.responseType;\n        }\n\n        // set credentials\n        if (options.withCredentials) {\n            xhr.withCredentials = true;\n        }\n\n        // let's send our data\n        xhr.send(data);\n\n        return api;\n    };\n\n    var createResponse = function createResponse(type, code, body, headers) {\n        return {\n            type: type,\n            code: code,\n            body: body,\n            headers: headers,\n        };\n    };\n\n    var createTimeoutResponse = function createTimeoutResponse(cb) {\n        return function(xhr) {\n            cb(createResponse('error', 0, 'Timeout', xhr.getAllResponseHeaders()));\n        };\n    };\n\n    var hasQS = function hasQS(str) {\n        return /\\?/.test(str);\n    };\n    var buildURL = function buildURL() {\n        var url = '';\n        for (var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++) {\n            parts[_key] = arguments[_key];\n        }\n        parts.forEach(function(part) {\n            url += hasQS(url) && hasQS(part) ? part.replace(/\\?/, '&') : part;\n        });\n        return url;\n    };\n\n    var createFetchFunction = function createFetchFunction() {\n        var apiUrl = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n        var action = arguments.length > 1 ? arguments[1] : undefined;\n        // custom handler (should also handle file, load, error, progress and abort)\n        if (typeof action === 'function') {\n            return action;\n        }\n\n        // no action supplied\n        if (!action || !isString(action.url)) {\n            return null;\n        }\n\n        // set onload hanlder\n        var onload =\n            action.onload ||\n            function(res) {\n                return res;\n            };\n        var onerror =\n            action.onerror ||\n            function(res) {\n                return null;\n            };\n\n        // internal handler\n        return function(url, load, error, progress, abort, headers) {\n            // do local or remote request based on if the url is external\n            var request = sendRequest(\n                url,\n                buildURL(apiUrl, action.url),\n                Object.assign({}, action, {\n                    responseType: 'blob',\n                })\n            );\n\n            request.onload = function(xhr) {\n                // get headers\n                var headers = xhr.getAllResponseHeaders();\n\n                // get filename\n                var filename = getFileInfoFromHeaders(headers).name || getFilenameFromURL(url);\n\n                // create response\n                load(\n                    createResponse(\n                        'load',\n                        xhr.status,\n                        action.method === 'HEAD'\n                            ? null\n                            : getFileFromBlob(onload(xhr.response), filename),\n                        headers\n                    )\n                );\n            };\n\n            request.onerror = function(xhr) {\n                error(\n                    createResponse(\n                        'error',\n                        xhr.status,\n                        onerror(xhr.response) || xhr.statusText,\n                        xhr.getAllResponseHeaders()\n                    )\n                );\n            };\n\n            request.onheaders = function(xhr) {\n                headers(createResponse('headers', xhr.status, null, xhr.getAllResponseHeaders()));\n            };\n\n            request.ontimeout = createTimeoutResponse(error);\n            request.onprogress = progress;\n            request.onabort = abort;\n\n            // should return request\n            return request;\n        };\n    };\n\n    var ChunkStatus = {\n        QUEUED: 0,\n        COMPLETE: 1,\n        PROCESSING: 2,\n        ERROR: 3,\n        WAITING: 4,\n    };\n\n    /*\n                                                       function signature:\n                                                         (file, metadata, load, error, progress, abort, transfer, options) => {\n                                                           return {\n                                                           abort:() => {}\n                                                         }\n                                                       }\n                                                       */\n\n    // apiUrl, action, name, file, metadata, load, error, progress, abort, transfer, options\n    var processFileChunked = function processFileChunked(\n        apiUrl,\n        action,\n        name,\n        file,\n        metadata,\n        load,\n        error,\n        progress,\n        abort,\n        transfer,\n        options\n    ) {\n        // all chunks\n        var chunks = [];\n        var chunkTransferId = options.chunkTransferId,\n            chunkServer = options.chunkServer,\n            chunkSize = options.chunkSize,\n            chunkRetryDelays = options.chunkRetryDelays;\n\n        // default state\n        var state = {\n            serverId: chunkTransferId,\n            aborted: false,\n        };\n\n        // set onload handlers\n        var ondata =\n            action.ondata ||\n            function(fd) {\n                return fd;\n            };\n        var onload =\n            action.onload ||\n            function(xhr, method) {\n                return method === 'HEAD' ? xhr.getResponseHeader('Upload-Offset') : xhr.response;\n            };\n        var onerror =\n            action.onerror ||\n            function(res) {\n                return null;\n            };\n\n        // create server hook\n        var requestTransferId = function requestTransferId(cb) {\n            var formData = new FormData();\n\n            // add metadata under same name\n            if (isObject(metadata)) formData.append(name, JSON.stringify(metadata));\n\n            var headers =\n                typeof action.headers === 'function'\n                    ? action.headers(file, metadata)\n                    : Object.assign({}, action.headers, {\n                          'Upload-Length': file.size,\n                      });\n\n            var requestParams = Object.assign({}, action, {\n                headers: headers,\n            });\n\n            // send request object\n            var request = sendRequest(\n                ondata(formData),\n                buildURL(apiUrl, action.url),\n                requestParams\n            );\n\n            request.onload = function(xhr) {\n                return cb(onload(xhr, requestParams.method));\n            };\n\n            request.onerror = function(xhr) {\n                return error(\n                    createResponse(\n                        'error',\n                        xhr.status,\n                        onerror(xhr.response) || xhr.statusText,\n                        xhr.getAllResponseHeaders()\n                    )\n                );\n            };\n\n            request.ontimeout = createTimeoutResponse(error);\n        };\n\n        var requestTransferOffset = function requestTransferOffset(cb) {\n            var requestUrl = buildURL(apiUrl, chunkServer.url, state.serverId);\n\n            var headers =\n                typeof action.headers === 'function'\n                    ? action.headers(state.serverId)\n                    : Object.assign({}, action.headers);\n\n            var requestParams = {\n                headers: headers,\n                method: 'HEAD',\n            };\n\n            var request = sendRequest(null, requestUrl, requestParams);\n\n            request.onload = function(xhr) {\n                return cb(onload(xhr, requestParams.method));\n            };\n\n            request.onerror = function(xhr) {\n                return error(\n                    createResponse(\n                        'error',\n                        xhr.status,\n                        onerror(xhr.response) || xhr.statusText,\n                        xhr.getAllResponseHeaders()\n                    )\n                );\n            };\n\n            request.ontimeout = createTimeoutResponse(error);\n        };\n\n        // create chunks\n        var lastChunkIndex = Math.floor(file.size / chunkSize);\n        for (var i = 0; i <= lastChunkIndex; i++) {\n            var offset = i * chunkSize;\n            var data = file.slice(offset, offset + chunkSize, 'application/offset+octet-stream');\n            chunks[i] = {\n                index: i,\n                size: data.size,\n                offset: offset,\n                data: data,\n                file: file,\n                progress: 0,\n                retries: _toConsumableArray(chunkRetryDelays),\n                status: ChunkStatus.QUEUED,\n                error: null,\n                request: null,\n                timeout: null,\n            };\n        }\n\n        var completeProcessingChunks = function completeProcessingChunks() {\n            return load(state.serverId);\n        };\n\n        var canProcessChunk = function canProcessChunk(chunk) {\n            return chunk.status === ChunkStatus.QUEUED || chunk.status === ChunkStatus.ERROR;\n        };\n\n        var processChunk = function processChunk(chunk) {\n            // processing is paused, wait here\n            if (state.aborted) return;\n\n            // get next chunk to process\n            chunk = chunk || chunks.find(canProcessChunk);\n\n            // no more chunks to process\n            if (!chunk) {\n                // all done?\n                if (\n                    chunks.every(function(chunk) {\n                        return chunk.status === ChunkStatus.COMPLETE;\n                    })\n                ) {\n                    completeProcessingChunks();\n                }\n\n                // no chunk to handle\n                return;\n            }\n\n            // now processing this chunk\n            chunk.status = ChunkStatus.PROCESSING;\n            chunk.progress = null;\n\n            // allow parsing of formdata\n            var ondata =\n                chunkServer.ondata ||\n                function(fd) {\n                    return fd;\n                };\n            var onerror =\n                chunkServer.onerror ||\n                function(res) {\n                    return null;\n                };\n\n            // send request object\n            var requestUrl = buildURL(apiUrl, chunkServer.url, state.serverId);\n\n            var headers =\n                typeof chunkServer.headers === 'function'\n                    ? chunkServer.headers(chunk)\n                    : Object.assign({}, chunkServer.headers, {\n                          'Content-Type': 'application/offset+octet-stream',\n                          'Upload-Offset': chunk.offset,\n                          'Upload-Length': file.size,\n                          'Upload-Name': file.name,\n                      });\n\n            var request = (chunk.request = sendRequest(\n                ondata(chunk.data),\n                requestUrl,\n                Object.assign({}, chunkServer, {\n                    headers: headers,\n                })\n            ));\n\n            request.onload = function() {\n                // done!\n                chunk.status = ChunkStatus.COMPLETE;\n\n                // remove request reference\n                chunk.request = null;\n\n                // start processing more chunks\n                processChunks();\n            };\n\n            request.onprogress = function(lengthComputable, loaded, total) {\n                chunk.progress = lengthComputable ? loaded : null;\n                updateTotalProgress();\n            };\n\n            request.onerror = function(xhr) {\n                chunk.status = ChunkStatus.ERROR;\n                chunk.request = null;\n                chunk.error = onerror(xhr.response) || xhr.statusText;\n                if (!retryProcessChunk(chunk)) {\n                    error(\n                        createResponse(\n                            'error',\n                            xhr.status,\n                            onerror(xhr.response) || xhr.statusText,\n                            xhr.getAllResponseHeaders()\n                        )\n                    );\n                }\n            };\n\n            request.ontimeout = function(xhr) {\n                chunk.status = ChunkStatus.ERROR;\n                chunk.request = null;\n                if (!retryProcessChunk(chunk)) {\n                    createTimeoutResponse(error)(xhr);\n                }\n            };\n\n            request.onabort = function() {\n                chunk.status = ChunkStatus.QUEUED;\n                chunk.request = null;\n                abort();\n            };\n        };\n\n        var retryProcessChunk = function retryProcessChunk(chunk) {\n            // no more retries left\n            if (chunk.retries.length === 0) return false;\n\n            // new retry\n            chunk.status = ChunkStatus.WAITING;\n            clearTimeout(chunk.timeout);\n            chunk.timeout = setTimeout(function() {\n                processChunk(chunk);\n            }, chunk.retries.shift());\n\n            // we're going to retry\n            return true;\n        };\n\n        var updateTotalProgress = function updateTotalProgress() {\n            // calculate total progress fraction\n            var totalBytesTransfered = chunks.reduce(function(p, chunk) {\n                if (p === null || chunk.progress === null) return null;\n                return p + chunk.progress;\n            }, 0);\n\n            // can't compute progress\n            if (totalBytesTransfered === null) return progress(false, 0, 0);\n\n            // calculate progress values\n            var totalSize = chunks.reduce(function(total, chunk) {\n                return total + chunk.size;\n            }, 0);\n\n            // can update progress indicator\n            progress(true, totalBytesTransfered, totalSize);\n        };\n\n        // process new chunks\n        var processChunks = function processChunks() {\n            var totalProcessing = chunks.filter(function(chunk) {\n                return chunk.status === ChunkStatus.PROCESSING;\n            }).length;\n            if (totalProcessing >= 1) return;\n            processChunk();\n        };\n\n        var abortChunks = function abortChunks() {\n            chunks.forEach(function(chunk) {\n                clearTimeout(chunk.timeout);\n                if (chunk.request) {\n                    chunk.request.abort();\n                }\n            });\n        };\n\n        // let's go!\n        if (!state.serverId) {\n            requestTransferId(function(serverId) {\n                // stop here if aborted, might have happened in between request and callback\n                if (state.aborted) return;\n\n                // pass back to item so we can use it if something goes wrong\n                transfer(serverId);\n\n                // store internally\n                state.serverId = serverId;\n                processChunks();\n            });\n        } else {\n            requestTransferOffset(function(offset) {\n                // stop here if aborted, might have happened in between request and callback\n                if (state.aborted) return;\n\n                // mark chunks with lower offset as complete\n                chunks\n                    .filter(function(chunk) {\n                        return chunk.offset < offset;\n                    })\n                    .forEach(function(chunk) {\n                        chunk.status = ChunkStatus.COMPLETE;\n                        chunk.progress = chunk.size;\n                    });\n\n                // continue processing\n                processChunks();\n            });\n        }\n\n        return {\n            abort: function abort() {\n                state.aborted = true;\n                abortChunks();\n            },\n        };\n    };\n\n    /*\n                                                               function signature:\n                                                                 (file, metadata, load, error, progress, abort) => {\n                                                                   return {\n                                                                   abort:() => {}\n                                                                 }\n                                                               }\n                                                               */\n    var createFileProcessorFunction = function createFileProcessorFunction(\n        apiUrl,\n        action,\n        name,\n        options\n    ) {\n        return function(file, metadata, load, error, progress, abort, transfer) {\n            // no file received\n            if (!file) return;\n\n            // if was passed a file, and we can chunk it, exit here\n            var canChunkUpload = options.chunkUploads;\n            var shouldChunkUpload = canChunkUpload && file.size > options.chunkSize;\n            var willChunkUpload = canChunkUpload && (shouldChunkUpload || options.chunkForce);\n            if (file instanceof Blob && willChunkUpload)\n                return processFileChunked(\n                    apiUrl,\n                    action,\n                    name,\n                    file,\n                    metadata,\n                    load,\n                    error,\n                    progress,\n                    abort,\n                    transfer,\n                    options\n                );\n\n            // set handlers\n            var ondata =\n                action.ondata ||\n                function(fd) {\n                    return fd;\n                };\n            var onload =\n                action.onload ||\n                function(res) {\n                    return res;\n                };\n            var onerror =\n                action.onerror ||\n                function(res) {\n                    return null;\n                };\n\n            var headers =\n                typeof action.headers === 'function'\n                    ? action.headers(file, metadata) || {}\n                    : Object.assign(\n                          {},\n\n                          action.headers\n                      );\n\n            var requestParams = Object.assign({}, action, {\n                headers: headers,\n            });\n\n            // create formdata object\n            var formData = new FormData();\n\n            // add metadata under same name\n            if (isObject(metadata)) {\n                formData.append(name, JSON.stringify(metadata));\n            }\n\n            // Turn into an array of objects so no matter what the input, we can handle it the same way\n            (file instanceof Blob ? [{ name: null, file: file }] : file).forEach(function(item) {\n                formData.append(\n                    name,\n                    item.file,\n                    item.name === null ? item.file.name : '' + item.name + item.file.name\n                );\n            });\n\n            // send request object\n            var request = sendRequest(\n                ondata(formData),\n                buildURL(apiUrl, action.url),\n                requestParams\n            );\n            request.onload = function(xhr) {\n                load(\n                    createResponse(\n                        'load',\n                        xhr.status,\n                        onload(xhr.response),\n                        xhr.getAllResponseHeaders()\n                    )\n                );\n            };\n\n            request.onerror = function(xhr) {\n                error(\n                    createResponse(\n                        'error',\n                        xhr.status,\n                        onerror(xhr.response) || xhr.statusText,\n                        xhr.getAllResponseHeaders()\n                    )\n                );\n            };\n\n            request.ontimeout = createTimeoutResponse(error);\n            request.onprogress = progress;\n            request.onabort = abort;\n\n            // should return request\n            return request;\n        };\n    };\n\n    var createProcessorFunction = function createProcessorFunction() {\n        var apiUrl = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n        var action = arguments.length > 1 ? arguments[1] : undefined;\n        var name = arguments.length > 2 ? arguments[2] : undefined;\n        var options = arguments.length > 3 ? arguments[3] : undefined;\n\n        // custom handler (should also handle file, load, error, progress and abort)\n        if (typeof action === 'function')\n            return function() {\n                for (\n                    var _len = arguments.length, params = new Array(_len), _key = 0;\n                    _key < _len;\n                    _key++\n                ) {\n                    params[_key] = arguments[_key];\n                }\n                return action.apply(void 0, [name].concat(params, [options]));\n            };\n\n        // no action supplied\n        if (!action || !isString(action.url)) return null;\n\n        // internal handler\n        return createFileProcessorFunction(apiUrl, action, name, options);\n    };\n\n    /*\n                                                      function signature:\n                                                      (uniqueFileId, load, error) => { }\n                                                      */\n    var createRevertFunction = function createRevertFunction() {\n        var apiUrl = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n        var action = arguments.length > 1 ? arguments[1] : undefined;\n        // is custom implementation\n        if (typeof action === 'function') {\n            return action;\n        }\n\n        // no action supplied, return stub function, interface will work, but file won't be removed\n        if (!action || !isString(action.url)) {\n            return function(uniqueFileId, load) {\n                return load();\n            };\n        }\n\n        // set onload hanlder\n        var onload =\n            action.onload ||\n            function(res) {\n                return res;\n            };\n        var onerror =\n            action.onerror ||\n            function(res) {\n                return null;\n            };\n\n        // internal implementation\n        return function(uniqueFileId, load, error) {\n            var request = sendRequest(\n                uniqueFileId,\n                apiUrl + action.url,\n                action // contains method, headers and withCredentials properties\n            );\n            request.onload = function(xhr) {\n                load(\n                    createResponse(\n                        'load',\n                        xhr.status,\n                        onload(xhr.response),\n                        xhr.getAllResponseHeaders()\n                    )\n                );\n            };\n\n            request.onerror = function(xhr) {\n                error(\n                    createResponse(\n                        'error',\n                        xhr.status,\n                        onerror(xhr.response) || xhr.statusText,\n                        xhr.getAllResponseHeaders()\n                    )\n                );\n            };\n\n            request.ontimeout = createTimeoutResponse(error);\n\n            return request;\n        };\n    };\n\n    var getRandomNumber = function getRandomNumber() {\n        var min = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n        var max = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;\n        return min + Math.random() * (max - min);\n    };\n\n    var createPerceivedPerformanceUpdater = function createPerceivedPerformanceUpdater(cb) {\n        var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n        var offset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n        var tickMin = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 25;\n        var tickMax = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 250;\n        var timeout = null;\n        var start = Date.now();\n\n        var tick = function tick() {\n            var runtime = Date.now() - start;\n            var delay = getRandomNumber(tickMin, tickMax);\n\n            if (runtime + delay > duration) {\n                delay = runtime + delay - duration;\n            }\n\n            var progress = runtime / duration;\n            if (progress >= 1 || document.hidden) {\n                cb(1);\n                return;\n            }\n\n            cb(progress);\n\n            timeout = setTimeout(tick, delay);\n        };\n\n        if (duration > 0) tick();\n\n        return {\n            clear: function clear() {\n                clearTimeout(timeout);\n            },\n        };\n    };\n\n    var createFileProcessor = function createFileProcessor(processFn, options) {\n        var state = {\n            complete: false,\n            perceivedProgress: 0,\n            perceivedPerformanceUpdater: null,\n            progress: null,\n            timestamp: null,\n            perceivedDuration: 0,\n            duration: 0,\n            request: null,\n            response: null,\n        };\n        var allowMinimumUploadDuration = options.allowMinimumUploadDuration;\n\n        var process = function process(file, metadata) {\n            var progressFn = function progressFn() {\n                // we've not yet started the real download, stop here\n                // the request might not go through, for instance, there might be some server trouble\n                // if state.progress is null, the server does not allow computing progress and we show the spinner instead\n                if (state.duration === 0 || state.progress === null) return;\n\n                // as we're now processing, fire the progress event\n                api.fire('progress', api.getProgress());\n            };\n\n            var completeFn = function completeFn() {\n                state.complete = true;\n                api.fire('load-perceived', state.response.body);\n            };\n\n            // let's start processing\n            api.fire('start');\n\n            // set request start\n            state.timestamp = Date.now();\n\n            // create perceived performance progress indicator\n            state.perceivedPerformanceUpdater = createPerceivedPerformanceUpdater(\n                function(progress) {\n                    state.perceivedProgress = progress;\n                    state.perceivedDuration = Date.now() - state.timestamp;\n\n                    progressFn();\n\n                    // if fake progress is done, and a response has been received,\n                    // and we've not yet called the complete method\n                    if (state.response && state.perceivedProgress === 1 && !state.complete) {\n                        // we done!\n                        completeFn();\n                    }\n                },\n                // random delay as in a list of files you start noticing\n                // files uploading at the exact same speed\n                allowMinimumUploadDuration ? getRandomNumber(750, 1500) : 0\n            );\n\n            // remember request so we can abort it later\n            state.request = processFn(\n                // the file to process\n                file,\n\n                // the metadata to send along\n                metadata,\n\n                // callbacks (load, error, progress, abort, transfer)\n                // load expects the body to be a server id if\n                // you want to make use of revert\n                function(response) {\n                    // we put the response in state so we can access\n                    // it outside of this method\n                    state.response = isObject(response)\n                        ? response\n                        : {\n                              type: 'load',\n                              code: 200,\n                              body: '' + response,\n                              headers: {},\n                          };\n\n                    // update duration\n                    state.duration = Date.now() - state.timestamp;\n\n                    // force progress to 1 as we're now done\n                    state.progress = 1;\n\n                    // actual load is done let's share results\n                    api.fire('load', state.response.body);\n\n                    // we are really done\n                    // if perceived progress is 1 ( wait for perceived progress to complete )\n                    // or if server does not support progress ( null )\n                    if (\n                        !allowMinimumUploadDuration ||\n                        (allowMinimumUploadDuration && state.perceivedProgress === 1)\n                    ) {\n                        completeFn();\n                    }\n                },\n\n                // error is expected to be an object with type, code, body\n                function(error) {\n                    // cancel updater\n                    state.perceivedPerformanceUpdater.clear();\n\n                    // update others about this error\n                    api.fire(\n                        'error',\n                        isObject(error)\n                            ? error\n                            : {\n                                  type: 'error',\n                                  code: 0,\n                                  body: '' + error,\n                              }\n                    );\n                },\n\n                // actual processing progress\n                function(computable, current, total) {\n                    // update actual duration\n                    state.duration = Date.now() - state.timestamp;\n\n                    // update actual progress\n                    state.progress = computable ? current / total : null;\n\n                    progressFn();\n                },\n\n                // abort does not expect a value\n                function() {\n                    // stop updater\n                    state.perceivedPerformanceUpdater.clear();\n\n                    // fire the abort event so we can switch visuals\n                    api.fire('abort', state.response ? state.response.body : null);\n                },\n\n                // register the id for this transfer\n                function(transferId) {\n                    api.fire('transfer', transferId);\n                }\n            );\n        };\n\n        var abort = function abort() {\n            // no request running, can't abort\n            if (!state.request) return;\n\n            // stop updater\n            state.perceivedPerformanceUpdater.clear();\n\n            // abort actual request\n            if (state.request.abort) state.request.abort();\n\n            // if has response object, we've completed the request\n            state.complete = true;\n        };\n\n        var reset = function reset() {\n            abort();\n            state.complete = false;\n            state.perceivedProgress = 0;\n            state.progress = 0;\n            state.timestamp = null;\n            state.perceivedDuration = 0;\n            state.duration = 0;\n            state.request = null;\n            state.response = null;\n        };\n\n        var getProgress = allowMinimumUploadDuration\n            ? function() {\n                  return state.progress ? Math.min(state.progress, state.perceivedProgress) : null;\n              }\n            : function() {\n                  return state.progress || null;\n              };\n\n        var getDuration = allowMinimumUploadDuration\n            ? function() {\n                  return Math.min(state.duration, state.perceivedDuration);\n              }\n            : function() {\n                  return state.duration;\n              };\n\n        var api = Object.assign({}, on(), {\n            process: process, // start processing file\n            abort: abort, // abort active process request\n            getProgress: getProgress,\n            getDuration: getDuration,\n            reset: reset,\n        });\n\n        return api;\n    };\n\n    var getFilenameWithoutExtension = function getFilenameWithoutExtension(name) {\n        return name.substring(0, name.lastIndexOf('.')) || name;\n    };\n\n    var createFileStub = function createFileStub(source) {\n        var data = [source.name, source.size, source.type];\n\n        // is blob or base64, then we need to set the name\n        if (source instanceof Blob || isBase64DataURI(source)) {\n            data[0] = source.name || getDateString();\n        } else if (isBase64DataURI(source)) {\n            // if is base64 data uri we need to determine the average size and type\n            data[1] = source.length;\n            data[2] = getMimeTypeFromBase64DataURI(source);\n        } else if (isString(source)) {\n            // url\n            data[0] = getFilenameFromURL(source);\n            data[1] = 0;\n            data[2] = 'application/octet-stream';\n        }\n\n        return {\n            name: data[0],\n            size: data[1],\n            type: data[2],\n        };\n    };\n\n    var isFile = function isFile(value) {\n        return !!(value instanceof File || (value instanceof Blob && value.name));\n    };\n\n    var deepCloneObject = function deepCloneObject(src) {\n        if (!isObject(src)) return src;\n        var target = isArray(src) ? [] : {};\n        for (var key in src) {\n            if (!src.hasOwnProperty(key)) continue;\n            var v = src[key];\n            target[key] = v && isObject(v) ? deepCloneObject(v) : v;\n        }\n        return target;\n    };\n\n    var createItem = function createItem() {\n        var origin = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n        var serverFileReference =\n            arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n        var file = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n        // unique id for this item, is used to identify the item across views\n        var id = getUniqueId();\n\n        /**\n         * Internal item state\n         */\n        var state = {\n            // is archived\n            archived: false,\n\n            // if is frozen, no longer fires events\n            frozen: false,\n\n            // removed from view\n            released: false,\n\n            // original source\n            source: null,\n\n            // file model reference\n            file: file,\n\n            // id of file on server\n            serverFileReference: serverFileReference,\n\n            // id of file transfer on server\n            transferId: null,\n\n            // is aborted\n            processingAborted: false,\n\n            // current item status\n            status: serverFileReference ? ItemStatus.PROCESSING_COMPLETE : ItemStatus.INIT,\n\n            // active processes\n            activeLoader: null,\n            activeProcessor: null,\n        };\n\n        // callback used when abort processing is called to link back to the resolve method\n        var abortProcessingRequestComplete = null;\n\n        /**\n         * Externally added item metadata\n         */\n        var metadata = {};\n\n        // item data\n        var setStatus = function setStatus(status) {\n            return (state.status = status);\n        };\n\n        // fire event unless the item has been archived\n        var fire = function fire(event) {\n            if (state.released || state.frozen) return;\n            for (\n                var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1;\n                _key < _len;\n                _key++\n            ) {\n                params[_key - 1] = arguments[_key];\n            }\n            api.fire.apply(api, [event].concat(params));\n        };\n\n        // file data\n        var getFileExtension = function getFileExtension() {\n            return getExtensionFromFilename(state.file.name);\n        };\n        var getFileType = function getFileType() {\n            return state.file.type;\n        };\n        var getFileSize = function getFileSize() {\n            return state.file.size;\n        };\n        var getFile = function getFile() {\n            return state.file;\n        };\n\n        //\n        // logic to load a file\n        //\n        var load = function load(source, loader, onload) {\n            // remember the original item source\n            state.source = source;\n\n            // source is known\n            api.fireSync('init');\n\n            // file stub is already there\n            if (state.file) {\n                api.fireSync('load-skip');\n                return;\n            }\n\n            // set a stub file object while loading the actual data\n            state.file = createFileStub(source);\n\n            // starts loading\n            loader.on('init', function() {\n                fire('load-init');\n            });\n\n            // we'eve received a size indication, let's update the stub\n            loader.on('meta', function(meta) {\n                // set size of file stub\n                state.file.size = meta.size;\n\n                // set name of file stub\n                state.file.filename = meta.filename;\n\n                // if has received source, we done\n                if (meta.source) {\n                    origin = FileOrigin.LIMBO;\n                    state.serverFileReference = meta.source;\n                    state.status = ItemStatus.PROCESSING_COMPLETE;\n                }\n\n                // size has been updated\n                fire('load-meta');\n            });\n\n            // the file is now loading we need to update the progress indicators\n            loader.on('progress', function(progress) {\n                setStatus(ItemStatus.LOADING);\n\n                fire('load-progress', progress);\n            });\n\n            // an error was thrown while loading the file, we need to switch to error state\n            loader.on('error', function(error) {\n                setStatus(ItemStatus.LOAD_ERROR);\n\n                fire('load-request-error', error);\n            });\n\n            // user or another process aborted the file load (cannot retry)\n            loader.on('abort', function() {\n                setStatus(ItemStatus.INIT);\n                fire('load-abort');\n            });\n\n            // done loading\n            loader.on('load', function(file) {\n                // as we've now loaded the file the loader is no longer required\n                state.activeLoader = null;\n\n                // called when file has loaded succesfully\n                var success = function success(result) {\n                    // set (possibly) transformed file\n                    state.file = isFile(result) ? result : state.file;\n\n                    // file received\n                    if (origin === FileOrigin.LIMBO && state.serverFileReference) {\n                        setStatus(ItemStatus.PROCESSING_COMPLETE);\n                    } else {\n                        setStatus(ItemStatus.IDLE);\n                    }\n\n                    fire('load');\n                };\n\n                var error = function error(result) {\n                    // set original file\n                    state.file = file;\n                    fire('load-meta');\n\n                    setStatus(ItemStatus.LOAD_ERROR);\n                    fire('load-file-error', result);\n                };\n\n                // if we already have a server file reference, we don't need to call the onload method\n                if (state.serverFileReference) {\n                    success(file);\n                    return;\n                }\n\n                // no server id, let's give this file the full treatment\n                onload(file, success, error);\n            });\n\n            // set loader source data\n            loader.setSource(source);\n\n            // set as active loader\n            state.activeLoader = loader;\n\n            // load the source data\n            loader.load();\n        };\n\n        var retryLoad = function retryLoad() {\n            if (!state.activeLoader) {\n                return;\n            }\n            state.activeLoader.load();\n        };\n\n        var abortLoad = function abortLoad() {\n            if (state.activeLoader) {\n                state.activeLoader.abort();\n                return;\n            }\n            setStatus(ItemStatus.INIT);\n            fire('load-abort');\n        };\n\n        //\n        // logic to process a file\n        //\n        var process = function process(processor, onprocess) {\n            // processing was aborted\n            if (state.processingAborted) {\n                state.processingAborted = false;\n                return;\n            }\n\n            // now processing\n            setStatus(ItemStatus.PROCESSING);\n\n            // reset abort callback\n            abortProcessingRequestComplete = null;\n\n            // if no file loaded we'll wait for the load event\n            if (!(state.file instanceof Blob)) {\n                api.on('load', function() {\n                    process(processor, onprocess);\n                });\n                return;\n            }\n\n            // setup processor\n            processor.on('load', function(serverFileReference) {\n                // need this id to be able to revert the upload\n                state.transferId = null;\n                state.serverFileReference = serverFileReference;\n            });\n\n            // register transfer id\n            processor.on('transfer', function(transferId) {\n                // need this id to be able to revert the upload\n                state.transferId = transferId;\n            });\n\n            processor.on('load-perceived', function(serverFileReference) {\n                // no longer required\n                state.activeProcessor = null;\n\n                // need this id to be able to rever the upload\n                state.transferId = null;\n                state.serverFileReference = serverFileReference;\n\n                setStatus(ItemStatus.PROCESSING_COMPLETE);\n                fire('process-complete', serverFileReference);\n            });\n\n            processor.on('start', function() {\n                fire('process-start');\n            });\n\n            processor.on('error', function(error) {\n                state.activeProcessor = null;\n                setStatus(ItemStatus.PROCESSING_ERROR);\n                fire('process-error', error);\n            });\n\n            processor.on('abort', function(serverFileReference) {\n                state.activeProcessor = null;\n\n                // if file was uploaded but processing was cancelled during perceived processor time store file reference\n                state.serverFileReference = serverFileReference;\n\n                setStatus(ItemStatus.IDLE);\n                fire('process-abort');\n\n                // has timeout so doesn't interfere with remove action\n                if (abortProcessingRequestComplete) {\n                    abortProcessingRequestComplete();\n                }\n            });\n\n            processor.on('progress', function(progress) {\n                fire('process-progress', progress);\n            });\n\n            // when successfully transformed\n            var success = function success(file) {\n                // if was archived in the mean time, don't process\n                if (state.archived) return;\n\n                // process file!\n                processor.process(file, Object.assign({}, metadata));\n            };\n\n            // something went wrong during transform phase\n            var error = console.error;\n\n            // start processing the file\n            onprocess(state.file, success, error);\n\n            // set as active processor\n            state.activeProcessor = processor;\n        };\n\n        var requestProcessing = function requestProcessing() {\n            state.processingAborted = false;\n            setStatus(ItemStatus.PROCESSING_QUEUED);\n        };\n\n        var abortProcessing = function abortProcessing() {\n            return new Promise(function(resolve) {\n                if (!state.activeProcessor) {\n                    state.processingAborted = true;\n\n                    setStatus(ItemStatus.IDLE);\n                    fire('process-abort');\n\n                    resolve();\n                    return;\n                }\n\n                abortProcessingRequestComplete = function abortProcessingRequestComplete() {\n                    resolve();\n                };\n\n                state.activeProcessor.abort();\n            });\n        };\n\n        //\n        // logic to revert a processed file\n        //\n        var revert = function revert(revertFileUpload, forceRevert) {\n            return new Promise(function(resolve, reject) {\n                // a completed upload will have a serverFileReference, a failed chunked upload where\n                // getting a serverId succeeded but >=0 chunks have been uploaded will have transferId set\n                var serverTransferId =\n                    state.serverFileReference !== null\n                        ? state.serverFileReference\n                        : state.transferId;\n\n                // cannot revert without a server id for this process\n                if (serverTransferId === null) {\n                    resolve();\n                    return;\n                }\n\n                // revert the upload (fire and forget)\n                revertFileUpload(\n                    serverTransferId,\n                    function() {\n                        // reset file server id and transfer id as now it's not available on the server\n                        state.serverFileReference = null;\n                        state.transferId = null;\n                        resolve();\n                    },\n                    function(error) {\n                        // don't set error state when reverting is optional, it will always resolve\n                        if (!forceRevert) {\n                            resolve();\n                            return;\n                        }\n\n                        // oh no errors\n                        setStatus(ItemStatus.PROCESSING_REVERT_ERROR);\n                        fire('process-revert-error');\n                        reject(error);\n                    }\n                );\n\n                // fire event\n                setStatus(ItemStatus.IDLE);\n                fire('process-revert');\n            });\n        };\n\n        // exposed methods\n        var _setMetadata = function setMetadata(key, value, silent) {\n            var keys = key.split('.');\n            var root = keys[0];\n            var last = keys.pop();\n            var data = metadata;\n            keys.forEach(function(key) {\n                return (data = data[key]);\n            });\n\n            // compare old value against new value, if they're the same, we're not updating\n            if (JSON.stringify(data[last]) === JSON.stringify(value)) return;\n\n            // update value\n            data[last] = value;\n\n            // fire update\n            fire('metadata-update', {\n                key: root,\n                value: metadata[root],\n                silent: silent,\n            });\n        };\n\n        var getMetadata = function getMetadata(key) {\n            return deepCloneObject(key ? metadata[key] : metadata);\n        };\n\n        var api = Object.assign(\n            {\n                id: {\n                    get: function get() {\n                        return id;\n                    },\n                },\n                origin: {\n                    get: function get() {\n                        return origin;\n                    },\n                    set: function set(value) {\n                        return (origin = value);\n                    },\n                },\n                serverId: {\n                    get: function get() {\n                        return state.serverFileReference;\n                    },\n                },\n                transferId: {\n                    get: function get() {\n                        return state.transferId;\n                    },\n                },\n                status: {\n                    get: function get() {\n                        return state.status;\n                    },\n                },\n                filename: {\n                    get: function get() {\n                        return state.file.name;\n                    },\n                },\n                filenameWithoutExtension: {\n                    get: function get() {\n                        return getFilenameWithoutExtension(state.file.name);\n                    },\n                },\n                fileExtension: { get: getFileExtension },\n                fileType: { get: getFileType },\n                fileSize: { get: getFileSize },\n                file: { get: getFile },\n                relativePath: {\n                    get: function get() {\n                        return state.file._relativePath;\n                    },\n                },\n\n                source: {\n                    get: function get() {\n                        return state.source;\n                    },\n                },\n\n                getMetadata: getMetadata,\n                setMetadata: function setMetadata(key, value, silent) {\n                    if (isObject(key)) {\n                        var data = key;\n                        Object.keys(data).forEach(function(key) {\n                            _setMetadata(key, data[key], value);\n                        });\n                        return key;\n                    }\n                    _setMetadata(key, value, silent);\n                    return value;\n                },\n\n                extend: function extend(name, handler) {\n                    return (itemAPI[name] = handler);\n                },\n\n                abortLoad: abortLoad,\n                retryLoad: retryLoad,\n                requestProcessing: requestProcessing,\n                abortProcessing: abortProcessing,\n\n                load: load,\n                process: process,\n                revert: revert,\n            },\n\n            on(),\n            {\n                freeze: function freeze() {\n                    return (state.frozen = true);\n                },\n\n                release: function release() {\n                    return (state.released = true);\n                },\n                released: {\n                    get: function get() {\n                        return state.released;\n                    },\n                },\n\n                archive: function archive() {\n                    return (state.archived = true);\n                },\n                archived: {\n                    get: function get() {\n                        return state.archived;\n                    },\n                },\n            }\n        );\n\n        // create it here instead of returning it instantly so we can extend it later\n        var itemAPI = createObject(api);\n\n        return itemAPI;\n    };\n\n    var getItemIndexByQuery = function getItemIndexByQuery(items, query) {\n        // just return first index\n        if (isEmpty(query)) {\n            return 0;\n        }\n\n        // invalid queries\n        if (!isString(query)) {\n            return -1;\n        }\n\n        // return item by id (or -1 if not found)\n        return items.findIndex(function(item) {\n            return item.id === query;\n        });\n    };\n\n    var getItemById = function getItemById(items, itemId) {\n        var index = getItemIndexByQuery(items, itemId);\n        if (index < 0) {\n            return;\n        }\n        return items[index] || null;\n    };\n\n    var fetchBlob = function fetchBlob(url, load, error, progress, abort, headers) {\n        var request = sendRequest(null, url, {\n            method: 'GET',\n            responseType: 'blob',\n        });\n\n        request.onload = function(xhr) {\n            // get headers\n            var headers = xhr.getAllResponseHeaders();\n\n            // get filename\n            var filename = getFileInfoFromHeaders(headers).name || getFilenameFromURL(url);\n\n            // create response\n            load(\n                createResponse('load', xhr.status, getFileFromBlob(xhr.response, filename), headers)\n            );\n        };\n\n        request.onerror = function(xhr) {\n            error(createResponse('error', xhr.status, xhr.statusText, xhr.getAllResponseHeaders()));\n        };\n\n        request.onheaders = function(xhr) {\n            headers(createResponse('headers', xhr.status, null, xhr.getAllResponseHeaders()));\n        };\n\n        request.ontimeout = createTimeoutResponse(error);\n        request.onprogress = progress;\n        request.onabort = abort;\n\n        // should return request\n        return request;\n    };\n\n    var getDomainFromURL = function getDomainFromURL(url) {\n        if (url.indexOf('//') === 0) {\n            url = location.protocol + url;\n        }\n        return url\n            .toLowerCase()\n            .replace('blob:', '')\n            .replace(/([a-z])?:\\/\\//, '$1')\n            .split('/')[0];\n    };\n\n    var isExternalURL = function isExternalURL(url) {\n        return (\n            (url.indexOf(':') > -1 || url.indexOf('//') > -1) &&\n            getDomainFromURL(location.href) !== getDomainFromURL(url)\n        );\n    };\n\n    var dynamicLabel = function dynamicLabel(label) {\n        return function() {\n            return isFunction(label) ? label.apply(void 0, arguments) : label;\n        };\n    };\n\n    var isMockItem = function isMockItem(item) {\n        return !isFile(item.file);\n    };\n\n    var listUpdated = function listUpdated(dispatch, state) {\n        clearTimeout(state.listUpdateTimeout);\n        state.listUpdateTimeout = setTimeout(function() {\n            dispatch('DID_UPDATE_ITEMS', { items: getActiveItems(state.items) });\n        }, 0);\n    };\n\n    var optionalPromise = function optionalPromise(fn) {\n        for (\n            var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1;\n            _key < _len;\n            _key++\n        ) {\n            params[_key - 1] = arguments[_key];\n        }\n        return new Promise(function(resolve) {\n            if (!fn) {\n                return resolve(true);\n            }\n\n            var result = fn.apply(void 0, params);\n\n            if (result == null) {\n                return resolve(true);\n            }\n\n            if (typeof result === 'boolean') {\n                return resolve(result);\n            }\n\n            if (typeof result.then === 'function') {\n                result.then(resolve);\n            }\n        });\n    };\n\n    var sortItems = function sortItems(state, compare) {\n        state.items.sort(function(a, b) {\n            return compare(createItemAPI(a), createItemAPI(b));\n        });\n    };\n\n    // returns item based on state\n    var getItemByQueryFromState = function getItemByQueryFromState(state, itemHandler) {\n        return function() {\n            var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n            var query = _ref.query,\n                _ref$success = _ref.success,\n                success = _ref$success === void 0 ? function() {} : _ref$success,\n                _ref$failure = _ref.failure,\n                failure = _ref$failure === void 0 ? function() {} : _ref$failure,\n                options = _objectWithoutProperties(_ref, ['query', 'success', 'failure']);\n            var item = getItemByQuery(state.items, query);\n            if (!item) {\n                failure({\n                    error: createResponse('error', 0, 'Item not found'),\n                    file: null,\n                });\n\n                return;\n            }\n            itemHandler(item, success, failure, options || {});\n        };\n    };\n\n    var actions = function actions(dispatch, query, state) {\n        return {\n            /**\n             * Aborts all ongoing processes\n             */\n            ABORT_ALL: function ABORT_ALL() {\n                getActiveItems(state.items).forEach(function(item) {\n                    item.freeze();\n                    item.abortLoad();\n                    item.abortProcessing();\n                });\n            },\n\n            /**\n             * Sets initial files\n             */\n            DID_SET_FILES: function DID_SET_FILES(_ref2) {\n                var _ref2$value = _ref2.value,\n                    value = _ref2$value === void 0 ? [] : _ref2$value;\n                // map values to file objects\n                var files = value.map(function(file) {\n                    return {\n                        source: file.source ? file.source : file,\n                        options: file.options,\n                    };\n                });\n\n                // loop over files, if file is in list, leave it be, if not, remove\n                // test if items should be moved\n                var activeItems = getActiveItems(state.items);\n\n                activeItems.forEach(function(item) {\n                    // if item not is in new value, remove\n                    if (\n                        !files.find(function(file) {\n                            return file.source === item.source || file.source === item.file;\n                        })\n                    ) {\n                        dispatch('REMOVE_ITEM', { query: item, remove: false });\n                    }\n                });\n\n                // add new files\n                activeItems = getActiveItems(state.items);\n                files.forEach(function(file, index) {\n                    // if file is already in list\n                    if (\n                        activeItems.find(function(item) {\n                            return item.source === file.source || item.file === file.source;\n                        })\n                    )\n                        return;\n\n                    // not in list, add\n                    dispatch(\n                        'ADD_ITEM',\n                        Object.assign({}, file, {\n                            interactionMethod: InteractionMethod.NONE,\n                            index: index,\n                        })\n                    );\n                });\n            },\n\n            DID_UPDATE_ITEM_METADATA: function DID_UPDATE_ITEM_METADATA(_ref3) {\n                var id = _ref3.id,\n                    action = _ref3.action,\n                    change = _ref3.change;\n                // don't do anything\n                if (change.silent) return;\n\n                // if is called multiple times in close succession we combined all calls together to save resources\n                clearTimeout(state.itemUpdateTimeout);\n                state.itemUpdateTimeout = setTimeout(function() {\n                    var item = getItemById(state.items, id);\n\n                    // only revert and attempt to upload when we're uploading to a server\n                    if (!query('IS_ASYNC')) {\n                        // should we update the output data\n                        applyFilterChain('SHOULD_PREPARE_OUTPUT', false, {\n                            item: item,\n                            query: query,\n                            action: action,\n                            change: change,\n                        }).then(function(shouldPrepareOutput) {\n                            // plugins determined the output data should be prepared (or not), can be adjusted with beforePrepareOutput hook\n                            var beforePrepareFile = query('GET_BEFORE_PREPARE_FILE');\n                            if (beforePrepareFile)\n                                shouldPrepareOutput = beforePrepareFile(item, shouldPrepareOutput);\n\n                            if (!shouldPrepareOutput) return;\n\n                            dispatch(\n                                'REQUEST_PREPARE_OUTPUT',\n                                {\n                                    query: id,\n                                    item: item,\n                                    success: function success(file) {\n                                        dispatch('DID_PREPARE_OUTPUT', { id: id, file: file });\n                                    },\n                                },\n\n                                true\n                            );\n                        });\n\n                        return;\n                    }\n\n                    // if is local item we need to enable upload button so change can be propagated to server\n                    if (item.origin === FileOrigin.LOCAL) {\n                        dispatch('DID_LOAD_ITEM', {\n                            id: item.id,\n                            error: null,\n                            serverFileReference: item.source,\n                        });\n                    }\n\n                    // for async scenarios\n                    var upload = function upload() {\n                        // we push this forward a bit so the interface is updated correctly\n                        setTimeout(function() {\n                            dispatch('REQUEST_ITEM_PROCESSING', { query: id });\n                        }, 32);\n                    };\n\n                    var revert = function revert(doUpload) {\n                        item.revert(\n                            createRevertFunction(\n                                state.options.server.url,\n                                state.options.server.revert\n                            ),\n                            query('GET_FORCE_REVERT')\n                        )\n                            .then(doUpload ? upload : function() {})\n                            .catch(function() {});\n                    };\n\n                    var abort = function abort(doUpload) {\n                        item.abortProcessing().then(doUpload ? upload : function() {});\n                    };\n\n                    // if we should re-upload the file immediately\n                    if (item.status === ItemStatus.PROCESSING_COMPLETE) {\n                        return revert(state.options.instantUpload);\n                    }\n\n                    // if currently uploading, cancel upload\n                    if (item.status === ItemStatus.PROCESSING) {\n                        return abort(state.options.instantUpload);\n                    }\n\n                    if (state.options.instantUpload) {\n                        upload();\n                    }\n                }, 0);\n            },\n\n            MOVE_ITEM: function MOVE_ITEM(_ref4) {\n                var query = _ref4.query,\n                    index = _ref4.index;\n                var item = getItemByQuery(state.items, query);\n                if (!item) return;\n                var currentIndex = state.items.indexOf(item);\n                index = limit(index, 0, state.items.length - 1);\n                if (currentIndex === index) return;\n                state.items.splice(index, 0, state.items.splice(currentIndex, 1)[0]);\n            },\n\n            SORT: function SORT(_ref5) {\n                var compare = _ref5.compare;\n                sortItems(state, compare);\n                dispatch('DID_SORT_ITEMS', {\n                    items: query('GET_ACTIVE_ITEMS'),\n                });\n            },\n\n            ADD_ITEMS: function ADD_ITEMS(_ref6) {\n                var items = _ref6.items,\n                    index = _ref6.index,\n                    interactionMethod = _ref6.interactionMethod,\n                    _ref6$success = _ref6.success,\n                    success = _ref6$success === void 0 ? function() {} : _ref6$success,\n                    _ref6$failure = _ref6.failure,\n                    failure = _ref6$failure === void 0 ? function() {} : _ref6$failure;\n                var currentIndex = index;\n\n                if (index === -1 || typeof index === 'undefined') {\n                    var insertLocation = query('GET_ITEM_INSERT_LOCATION');\n                    var totalItems = query('GET_TOTAL_ITEMS');\n                    currentIndex = insertLocation === 'before' ? 0 : totalItems;\n                }\n\n                var ignoredFiles = query('GET_IGNORED_FILES');\n                var isValidFile = function isValidFile(source) {\n                    return isFile(source)\n                        ? !ignoredFiles.includes(source.name.toLowerCase())\n                        : !isEmpty(source);\n                };\n                var validItems = items.filter(isValidFile);\n\n                var promises = validItems.map(function(source) {\n                    return new Promise(function(resolve, reject) {\n                        dispatch('ADD_ITEM', {\n                            interactionMethod: interactionMethod,\n                            source: source.source || source,\n                            success: resolve,\n                            failure: reject,\n                            index: currentIndex++,\n                            options: source.options || {},\n                        });\n                    });\n                });\n\n                Promise.all(promises)\n                    .then(success)\n                    .catch(failure);\n            },\n\n            /**\n             * @param source\n             * @param index\n             * @param interactionMethod\n             */\n            ADD_ITEM: function ADD_ITEM(_ref7) {\n                var source = _ref7.source,\n                    _ref7$index = _ref7.index,\n                    index = _ref7$index === void 0 ? -1 : _ref7$index,\n                    interactionMethod = _ref7.interactionMethod,\n                    _ref7$success = _ref7.success,\n                    success = _ref7$success === void 0 ? function() {} : _ref7$success,\n                    _ref7$failure = _ref7.failure,\n                    failure = _ref7$failure === void 0 ? function() {} : _ref7$failure,\n                    _ref7$options = _ref7.options,\n                    options = _ref7$options === void 0 ? {} : _ref7$options;\n                // if no source supplied\n                if (isEmpty(source)) {\n                    failure({\n                        error: createResponse('error', 0, 'No source'),\n                        file: null,\n                    });\n\n                    return;\n                }\n\n                // filter out invalid file items, used to filter dropped directory contents\n                if (\n                    isFile(source) &&\n                    state.options.ignoredFiles.includes(source.name.toLowerCase())\n                ) {\n                    // fail silently\n                    return;\n                }\n\n                // test if there's still room in the list of files\n                if (!hasRoomForItem(state)) {\n                    // if multiple allowed, we can't replace\n                    // or if only a single item is allowed but we're not allowed to replace it we exit\n                    if (\n                        state.options.allowMultiple ||\n                        (!state.options.allowMultiple && !state.options.allowReplace)\n                    ) {\n                        var error = createResponse('warning', 0, 'Max files');\n\n                        dispatch('DID_THROW_MAX_FILES', {\n                            source: source,\n                            error: error,\n                        });\n\n                        failure({ error: error, file: null });\n\n                        return;\n                    }\n\n                    // let's replace the item\n                    // id of first item we're about to remove\n                    var _item = getActiveItems(state.items)[0];\n\n                    // if has been processed remove it from the server as well\n                    if (\n                        _item.status === ItemStatus.PROCESSING_COMPLETE ||\n                        _item.status === ItemStatus.PROCESSING_REVERT_ERROR\n                    ) {\n                        var forceRevert = query('GET_FORCE_REVERT');\n                        _item\n                            .revert(\n                                createRevertFunction(\n                                    state.options.server.url,\n                                    state.options.server.revert\n                                ),\n                                forceRevert\n                            )\n                            .then(function() {\n                                if (!forceRevert) return;\n\n                                // try to add now\n                                dispatch('ADD_ITEM', {\n                                    source: source,\n                                    index: index,\n                                    interactionMethod: interactionMethod,\n                                    success: success,\n                                    failure: failure,\n                                    options: options,\n                                });\n                            })\n                            .catch(function() {}); // no need to handle this catch state for now\n\n                        if (forceRevert) return;\n                    }\n\n                    // remove first item as it will be replaced by this item\n                    dispatch('REMOVE_ITEM', { query: _item.id });\n                }\n\n                // where did the file originate\n                var origin =\n                    options.type === 'local'\n                        ? FileOrigin.LOCAL\n                        : options.type === 'limbo'\n                        ? FileOrigin.LIMBO\n                        : FileOrigin.INPUT;\n\n                // create a new blank item\n                var item = createItem(\n                    // where did this file come from\n                    origin,\n\n                    // an input file never has a server file reference\n                    origin === FileOrigin.INPUT ? null : source,\n\n                    // file mock data, if defined\n                    options.file\n                );\n\n                // set initial meta data\n                Object.keys(options.metadata || {}).forEach(function(key) {\n                    item.setMetadata(key, options.metadata[key]);\n                });\n\n                // created the item, let plugins add methods\n                applyFilters('DID_CREATE_ITEM', item, { query: query, dispatch: dispatch });\n\n                // where to insert new items\n                var itemInsertLocation = query('GET_ITEM_INSERT_LOCATION');\n\n                // adjust index if is not allowed to pick location\n                if (!state.options.itemInsertLocationFreedom) {\n                    index = itemInsertLocation === 'before' ? -1 : state.items.length;\n                }\n\n                // add item to list\n                insertItem(state.items, item, index);\n\n                // sort items in list\n                if (isFunction(itemInsertLocation) && source) {\n                    sortItems(state, itemInsertLocation);\n                }\n\n                // get a quick reference to the item id\n                var id = item.id;\n\n                // observe item events\n                item.on('init', function() {\n                    dispatch('DID_INIT_ITEM', { id: id });\n                });\n\n                item.on('load-init', function() {\n                    dispatch('DID_START_ITEM_LOAD', { id: id });\n                });\n\n                item.on('load-meta', function() {\n                    dispatch('DID_UPDATE_ITEM_META', { id: id });\n                });\n\n                item.on('load-progress', function(progress) {\n                    dispatch('DID_UPDATE_ITEM_LOAD_PROGRESS', { id: id, progress: progress });\n                });\n\n                item.on('load-request-error', function(error) {\n                    var mainStatus = dynamicLabel(state.options.labelFileLoadError)(error);\n\n                    // is client error, no way to recover\n                    if (error.code >= 400 && error.code < 500) {\n                        dispatch('DID_THROW_ITEM_INVALID', {\n                            id: id,\n                            error: error,\n                            status: {\n                                main: mainStatus,\n                                sub: error.code + ' (' + error.body + ')',\n                            },\n                        });\n\n                        // reject the file so can be dealt with through API\n                        failure({ error: error, file: createItemAPI(item) });\n                        return;\n                    }\n\n                    // is possible server error, so might be possible to retry\n                    dispatch('DID_THROW_ITEM_LOAD_ERROR', {\n                        id: id,\n                        error: error,\n                        status: {\n                            main: mainStatus,\n                            sub: state.options.labelTapToRetry,\n                        },\n                    });\n                });\n\n                item.on('load-file-error', function(error) {\n                    dispatch('DID_THROW_ITEM_INVALID', {\n                        id: id,\n                        error: error.status,\n                        status: error.status,\n                    });\n\n                    failure({ error: error.status, file: createItemAPI(item) });\n                });\n\n                item.on('load-abort', function() {\n                    dispatch('REMOVE_ITEM', { query: id });\n                });\n\n                item.on('load-skip', function() {\n                    dispatch('COMPLETE_LOAD_ITEM', {\n                        query: id,\n                        item: item,\n                        data: {\n                            source: source,\n                            success: success,\n                        },\n                    });\n                });\n\n                item.on('load', function() {\n                    var handleAdd = function handleAdd(shouldAdd) {\n                        // no should not add this file\n                        if (!shouldAdd) {\n                            dispatch('REMOVE_ITEM', {\n                                query: id,\n                            });\n\n                            return;\n                        }\n\n                        // now interested in metadata updates\n                        item.on('metadata-update', function(change) {\n                            dispatch('DID_UPDATE_ITEM_METADATA', { id: id, change: change });\n                        });\n\n                        // let plugins decide if the output data should be prepared at this point\n                        // means we'll do this and wait for idle state\n                        applyFilterChain('SHOULD_PREPARE_OUTPUT', false, {\n                            item: item,\n                            query: query,\n                        }).then(function(shouldPrepareOutput) {\n                            // plugins determined the output data should be prepared (or not), can be adjusted with beforePrepareOutput hook\n                            var beforePrepareFile = query('GET_BEFORE_PREPARE_FILE');\n                            if (beforePrepareFile)\n                                shouldPrepareOutput = beforePrepareFile(item, shouldPrepareOutput);\n\n                            var loadComplete = function loadComplete() {\n                                dispatch('COMPLETE_LOAD_ITEM', {\n                                    query: id,\n                                    item: item,\n                                    data: {\n                                        source: source,\n                                        success: success,\n                                    },\n                                });\n\n                                listUpdated(dispatch, state);\n                            };\n\n                            // exit\n                            if (shouldPrepareOutput) {\n                                // wait for idle state and then run PREPARE_OUTPUT\n                                dispatch(\n                                    'REQUEST_PREPARE_OUTPUT',\n                                    {\n                                        query: id,\n                                        item: item,\n                                        success: function success(file) {\n                                            dispatch('DID_PREPARE_OUTPUT', { id: id, file: file });\n                                            loadComplete();\n                                        },\n                                    },\n\n                                    true\n                                );\n\n                                return;\n                            }\n\n                            loadComplete();\n                        });\n                    };\n\n                    // item loaded, allow plugins to\n                    // - read data (quickly)\n                    // - add metadata\n                    applyFilterChain('DID_LOAD_ITEM', item, { query: query, dispatch: dispatch })\n                        .then(function() {\n                            optionalPromise(query('GET_BEFORE_ADD_FILE'), createItemAPI(item)).then(\n                                handleAdd\n                            );\n                        })\n                        .catch(function(e) {\n                            if (!e || !e.error || !e.status) return handleAdd(false);\n                            dispatch('DID_THROW_ITEM_INVALID', {\n                                id: id,\n                                error: e.error,\n                                status: e.status,\n                            });\n                        });\n                });\n\n                item.on('process-start', function() {\n                    dispatch('DID_START_ITEM_PROCESSING', { id: id });\n                });\n\n                item.on('process-progress', function(progress) {\n                    dispatch('DID_UPDATE_ITEM_PROCESS_PROGRESS', { id: id, progress: progress });\n                });\n\n                item.on('process-error', function(error) {\n                    dispatch('DID_THROW_ITEM_PROCESSING_ERROR', {\n                        id: id,\n                        error: error,\n                        status: {\n                            main: dynamicLabel(state.options.labelFileProcessingError)(error),\n                            sub: state.options.labelTapToRetry,\n                        },\n                    });\n                });\n\n                item.on('process-revert-error', function(error) {\n                    dispatch('DID_THROW_ITEM_PROCESSING_REVERT_ERROR', {\n                        id: id,\n                        error: error,\n                        status: {\n                            main: dynamicLabel(state.options.labelFileProcessingRevertError)(error),\n                            sub: state.options.labelTapToRetry,\n                        },\n                    });\n                });\n\n                item.on('process-complete', function(serverFileReference) {\n                    dispatch('DID_COMPLETE_ITEM_PROCESSING', {\n                        id: id,\n                        error: null,\n                        serverFileReference: serverFileReference,\n                    });\n\n                    dispatch('DID_DEFINE_VALUE', { id: id, value: serverFileReference });\n                });\n\n                item.on('process-abort', function() {\n                    dispatch('DID_ABORT_ITEM_PROCESSING', { id: id });\n                });\n\n                item.on('process-revert', function() {\n                    dispatch('DID_REVERT_ITEM_PROCESSING', { id: id });\n                    dispatch('DID_DEFINE_VALUE', { id: id, value: null });\n                });\n\n                // let view know the item has been inserted\n                dispatch('DID_ADD_ITEM', {\n                    id: id,\n                    index: index,\n                    interactionMethod: interactionMethod,\n                });\n\n                listUpdated(dispatch, state);\n\n                // start loading the source\n                var _ref8 = state.options.server || {},\n                    url = _ref8.url,\n                    load = _ref8.load,\n                    restore = _ref8.restore,\n                    fetch = _ref8.fetch;\n\n                item.load(\n                    source,\n\n                    // this creates a function that loads the file based on the type of file (string, base64, blob, file) and location of file (local, remote, limbo)\n                    createFileLoader(\n                        origin === FileOrigin.INPUT\n                            ? // input, if is remote, see if should use custom fetch, else use default fetchBlob\n                              isString(source) && isExternalURL(source)\n                                ? fetch\n                                    ? createFetchFunction(url, fetch)\n                                    : fetchBlob // remote url\n                                : fetchBlob // try to fetch url\n                            : // limbo or local\n                            origin === FileOrigin.LIMBO\n                            ? createFetchFunction(url, restore) // limbo\n                            : createFetchFunction(url, load) // local\n                    ),\n\n                    // called when the file is loaded so it can be piped through the filters\n                    function(file, success, error) {\n                        // let's process the file\n                        applyFilterChain('LOAD_FILE', file, { query: query })\n                            .then(success)\n                            .catch(error);\n                    }\n                );\n            },\n\n            REQUEST_PREPARE_OUTPUT: function REQUEST_PREPARE_OUTPUT(_ref9) {\n                var item = _ref9.item,\n                    success = _ref9.success,\n                    _ref9$failure = _ref9.failure,\n                    failure = _ref9$failure === void 0 ? function() {} : _ref9$failure;\n                // error response if item archived\n                var err = {\n                    error: createResponse('error', 0, 'Item not found'),\n                    file: null,\n                };\n\n                // don't handle archived items, an item could have been archived (load aborted) while waiting to be prepared\n                if (item.archived) return failure(err);\n\n                // allow plugins to alter the file data\n                applyFilterChain('PREPARE_OUTPUT', item.file, { query: query, item: item }).then(\n                    function(result) {\n                        applyFilterChain('COMPLETE_PREPARE_OUTPUT', result, {\n                            query: query,\n                            item: item,\n                        }).then(function(result) {\n                            // don't handle archived items, an item could have been archived (load aborted) while being prepared\n                            if (item.archived) return failure(err);\n\n                            // we done!\n                            success(result);\n                        });\n                    }\n                );\n            },\n\n            COMPLETE_LOAD_ITEM: function COMPLETE_LOAD_ITEM(_ref10) {\n                var item = _ref10.item,\n                    data = _ref10.data;\n                var success = data.success,\n                    source = data.source;\n\n                // sort items in list\n                var itemInsertLocation = query('GET_ITEM_INSERT_LOCATION');\n                if (isFunction(itemInsertLocation) && source) {\n                    sortItems(state, itemInsertLocation);\n                }\n\n                // let interface know the item has loaded\n                dispatch('DID_LOAD_ITEM', {\n                    id: item.id,\n                    error: null,\n                    serverFileReference: item.origin === FileOrigin.INPUT ? null : source,\n                });\n\n                // item has been successfully loaded and added to the\n                // list of items so can now be safely returned for use\n                success(createItemAPI(item));\n\n                // if this is a local server file we need to show a different state\n                if (item.origin === FileOrigin.LOCAL) {\n                    dispatch('DID_LOAD_LOCAL_ITEM', { id: item.id });\n                    return;\n                }\n\n                // if is a temp server file we prevent async upload call here (as the file is already on the server)\n                if (item.origin === FileOrigin.LIMBO) {\n                    dispatch('DID_COMPLETE_ITEM_PROCESSING', {\n                        id: item.id,\n                        error: null,\n                        serverFileReference: source,\n                    });\n\n                    dispatch('DID_DEFINE_VALUE', {\n                        id: item.id,\n                        value: item.serverId || source,\n                    });\n\n                    return;\n                }\n\n                // id we are allowed to upload the file immediately, lets do it\n                if (query('IS_ASYNC') && state.options.instantUpload) {\n                    dispatch('REQUEST_ITEM_PROCESSING', { query: item.id });\n                }\n            },\n\n            RETRY_ITEM_LOAD: getItemByQueryFromState(state, function(item) {\n                // try loading the source one more time\n                item.retryLoad();\n            }),\n\n            REQUEST_ITEM_PREPARE: getItemByQueryFromState(state, function(item, _success, failure) {\n                dispatch(\n                    'REQUEST_PREPARE_OUTPUT',\n                    {\n                        query: item.id,\n                        item: item,\n                        success: function success(file) {\n                            dispatch('DID_PREPARE_OUTPUT', { id: item.id, file: file });\n                            _success({\n                                file: item,\n                                output: file,\n                            });\n                        },\n                        failure: failure,\n                    },\n\n                    true\n                );\n            }),\n\n            REQUEST_ITEM_PROCESSING: getItemByQueryFromState(state, function(\n                item,\n                success,\n                failure\n            ) {\n                // cannot be queued (or is already queued)\n                var itemCanBeQueuedForProcessing =\n                    // waiting for something\n                    item.status === ItemStatus.IDLE ||\n                    // processing went wrong earlier\n                    item.status === ItemStatus.PROCESSING_ERROR;\n\n                // not ready to be processed\n                if (!itemCanBeQueuedForProcessing) {\n                    var processNow = function processNow() {\n                        return dispatch('REQUEST_ITEM_PROCESSING', {\n                            query: item,\n                            success: success,\n                            failure: failure,\n                        });\n                    };\n\n                    var process = function process() {\n                        return document.hidden ? processNow() : setTimeout(processNow, 32);\n                    };\n\n                    // if already done processing or tried to revert but didn't work, try again\n                    if (\n                        item.status === ItemStatus.PROCESSING_COMPLETE ||\n                        item.status === ItemStatus.PROCESSING_REVERT_ERROR\n                    ) {\n                        item.revert(\n                            createRevertFunction(\n                                state.options.server.url,\n                                state.options.server.revert\n                            ),\n                            query('GET_FORCE_REVERT')\n                        )\n                            .then(process)\n                            .catch(function() {}); // don't continue with processing if something went wrong\n                    } else if (item.status === ItemStatus.PROCESSING) {\n                        item.abortProcessing().then(process);\n                    }\n\n                    return;\n                }\n\n                // already queued for processing\n                if (item.status === ItemStatus.PROCESSING_QUEUED) return;\n\n                item.requestProcessing();\n\n                dispatch('DID_REQUEST_ITEM_PROCESSING', { id: item.id });\n\n                dispatch('PROCESS_ITEM', { query: item, success: success, failure: failure }, true);\n            }),\n\n            PROCESS_ITEM: getItemByQueryFromState(state, function(item, success, failure) {\n                var maxParallelUploads = query('GET_MAX_PARALLEL_UPLOADS');\n                var totalCurrentUploads = query('GET_ITEMS_BY_STATUS', ItemStatus.PROCESSING)\n                    .length;\n\n                // queue and wait till queue is freed up\n                if (totalCurrentUploads === maxParallelUploads) {\n                    // queue for later processing\n                    state.processingQueue.push({\n                        id: item.id,\n                        success: success,\n                        failure: failure,\n                    });\n\n                    // stop it!\n                    return;\n                }\n\n                // if was not queued or is already processing exit here\n                if (item.status === ItemStatus.PROCESSING) return;\n\n                var processNext = function processNext() {\n                    // process queueud items\n                    var queueEntry = state.processingQueue.shift();\n\n                    // no items left\n                    if (!queueEntry) return;\n\n                    // get item reference\n                    var id = queueEntry.id,\n                        success = queueEntry.success,\n                        failure = queueEntry.failure;\n                    var itemReference = getItemByQuery(state.items, id);\n\n                    // if item was archived while in queue, jump to next\n                    if (!itemReference || itemReference.archived) {\n                        processNext();\n                        return;\n                    }\n\n                    // process queued item\n                    dispatch(\n                        'PROCESS_ITEM',\n                        { query: id, success: success, failure: failure },\n                        true\n                    );\n                };\n\n                // we done function\n                item.onOnce('process-complete', function() {\n                    success(createItemAPI(item));\n                    processNext();\n\n                    // if origin is local, and we're instant uploading, trigger remove of original\n                    // as revert will remove file from list\n                    var server = state.options.server;\n                    var instantUpload = state.options.instantUpload;\n                    if (\n                        instantUpload &&\n                        item.origin === FileOrigin.LOCAL &&\n                        isFunction(server.remove)\n                    ) {\n                        var noop = function noop() {};\n                        item.origin = FileOrigin.LIMBO;\n                        state.options.server.remove(item.source, noop, noop);\n                    }\n\n                    // All items processed? No errors?\n                    var allItemsProcessed =\n                        query('GET_ITEMS_BY_STATUS', ItemStatus.PROCESSING_COMPLETE).length ===\n                        state.items.length;\n                    if (allItemsProcessed) {\n                        dispatch('DID_COMPLETE_ITEM_PROCESSING_ALL');\n                    }\n                });\n\n                // we error function\n                item.onOnce('process-error', function(error) {\n                    failure({ error: error, file: createItemAPI(item) });\n                    processNext();\n                });\n\n                // start file processing\n                var options = state.options;\n                item.process(\n                    createFileProcessor(\n                        createProcessorFunction(\n                            options.server.url,\n                            options.server.process,\n                            options.name,\n                            {\n                                chunkTransferId: item.transferId,\n                                chunkServer: options.server.patch,\n                                chunkUploads: options.chunkUploads,\n                                chunkForce: options.chunkForce,\n                                chunkSize: options.chunkSize,\n                                chunkRetryDelays: options.chunkRetryDelays,\n                            }\n                        ),\n\n                        {\n                            allowMinimumUploadDuration: query('GET_ALLOW_MINIMUM_UPLOAD_DURATION'),\n                        }\n                    ),\n\n                    // called when the file is about to be processed so it can be piped through the transform filters\n                    function(file, success, error) {\n                        // allow plugins to alter the file data\n                        applyFilterChain('PREPARE_OUTPUT', file, { query: query, item: item })\n                            .then(function(file) {\n                                dispatch('DID_PREPARE_OUTPUT', { id: item.id, file: file });\n\n                                success(file);\n                            })\n                            .catch(error);\n                    }\n                );\n            }),\n\n            RETRY_ITEM_PROCESSING: getItemByQueryFromState(state, function(item) {\n                dispatch('REQUEST_ITEM_PROCESSING', { query: item });\n            }),\n\n            REQUEST_REMOVE_ITEM: getItemByQueryFromState(state, function(item) {\n                optionalPromise(query('GET_BEFORE_REMOVE_FILE'), createItemAPI(item)).then(function(\n                    shouldRemove\n                ) {\n                    if (!shouldRemove) {\n                        return;\n                    }\n                    dispatch('REMOVE_ITEM', { query: item });\n                });\n            }),\n\n            RELEASE_ITEM: getItemByQueryFromState(state, function(item) {\n                item.release();\n            }),\n\n            REMOVE_ITEM: getItemByQueryFromState(state, function(item, success, failure, options) {\n                var removeFromView = function removeFromView() {\n                    // get id reference\n                    var id = item.id;\n\n                    // archive the item, this does not remove it from the list\n                    getItemById(state.items, id).archive();\n\n                    // tell the view the item has been removed\n                    dispatch('DID_REMOVE_ITEM', { error: null, id: id, item: item });\n\n                    // now the list has been modified\n                    listUpdated(dispatch, state);\n\n                    // correctly removed\n                    success(createItemAPI(item));\n                };\n\n                // if this is a local file and the `server.remove` function has been configured,\n                // send source there so dev can remove file from server\n                var server = state.options.server;\n                if (\n                    item.origin === FileOrigin.LOCAL &&\n                    server &&\n                    isFunction(server.remove) &&\n                    options.remove !== false\n                ) {\n                    dispatch('DID_START_ITEM_REMOVE', { id: item.id });\n\n                    server.remove(\n                        item.source,\n                        function() {\n                            return removeFromView();\n                        },\n                        function(status) {\n                            dispatch('DID_THROW_ITEM_REMOVE_ERROR', {\n                                id: item.id,\n                                error: createResponse('error', 0, status, null),\n                                status: {\n                                    main: dynamicLabel(state.options.labelFileRemoveError)(status),\n                                    sub: state.options.labelTapToRetry,\n                                },\n                            });\n                        }\n                    );\n                } else {\n                    // if is requesting revert and can revert need to call revert handler (not calling request_ because that would also trigger beforeRemoveHook)\n                    if (\n                        (options.revert &&\n                            item.origin !== FileOrigin.LOCAL &&\n                            item.serverId !== null) ||\n                        // if chunked uploads are enabled and we're uploading in chunks for this specific file\n                        // or if the file isn't big enough for chunked uploads but chunkForce is set then call\n                        // revert before removing from the view...\n                        (state.options.chunkUploads && item.file.size > state.options.chunkSize) ||\n                        (state.options.chunkUploads && state.options.chunkForce)\n                    ) {\n                        item.revert(\n                            createRevertFunction(\n                                state.options.server.url,\n                                state.options.server.revert\n                            ),\n                            query('GET_FORCE_REVERT')\n                        );\n                    }\n\n                    // can now safely remove from view\n                    removeFromView();\n                }\n            }),\n\n            ABORT_ITEM_LOAD: getItemByQueryFromState(state, function(item) {\n                item.abortLoad();\n            }),\n\n            ABORT_ITEM_PROCESSING: getItemByQueryFromState(state, function(item) {\n                // test if is already processed\n                if (item.serverId) {\n                    dispatch('REVERT_ITEM_PROCESSING', { id: item.id });\n                    return;\n                }\n\n                // abort\n                item.abortProcessing().then(function() {\n                    var shouldRemove = state.options.instantUpload;\n                    if (shouldRemove) {\n                        dispatch('REMOVE_ITEM', { query: item.id });\n                    }\n                });\n            }),\n\n            REQUEST_REVERT_ITEM_PROCESSING: getItemByQueryFromState(state, function(item) {\n                // not instant uploading, revert immediately\n                if (!state.options.instantUpload) {\n                    dispatch('REVERT_ITEM_PROCESSING', { query: item });\n                    return;\n                }\n\n                // if we're instant uploading the file will also be removed if we revert,\n                // so if a before remove file hook is defined we need to run it now\n                var handleRevert = function handleRevert(shouldRevert) {\n                    if (!shouldRevert) return;\n                    dispatch('REVERT_ITEM_PROCESSING', { query: item });\n                };\n\n                var fn = query('GET_BEFORE_REMOVE_FILE');\n                if (!fn) {\n                    return handleRevert(true);\n                }\n\n                var requestRemoveResult = fn(createItemAPI(item));\n                if (requestRemoveResult == null) {\n                    // undefined or null\n                    return handleRevert(true);\n                }\n\n                if (typeof requestRemoveResult === 'boolean') {\n                    return handleRevert(requestRemoveResult);\n                }\n\n                if (typeof requestRemoveResult.then === 'function') {\n                    requestRemoveResult.then(handleRevert);\n                }\n            }),\n\n            REVERT_ITEM_PROCESSING: getItemByQueryFromState(state, function(item) {\n                item.revert(\n                    createRevertFunction(state.options.server.url, state.options.server.revert),\n                    query('GET_FORCE_REVERT')\n                )\n                    .then(function() {\n                        var shouldRemove = state.options.instantUpload || isMockItem(item);\n                        if (shouldRemove) {\n                            dispatch('REMOVE_ITEM', { query: item.id });\n                        }\n                    })\n                    .catch(function() {});\n            }),\n\n            SET_OPTIONS: function SET_OPTIONS(_ref11) {\n                var options = _ref11.options;\n                // get all keys passed\n                var optionKeys = Object.keys(options);\n\n                // get prioritized keyed to include (remove once not in options object)\n                var prioritizedOptionKeys = PrioritizedOptions.filter(function(key) {\n                    return optionKeys.includes(key);\n                });\n\n                // order the keys, prioritized first, then rest\n                var orderedOptionKeys = [].concat(\n                    _toConsumableArray(prioritizedOptionKeys),\n                    _toConsumableArray(\n                        Object.keys(options).filter(function(key) {\n                            return !prioritizedOptionKeys.includes(key);\n                        })\n                    )\n                );\n\n                // dispatch set event for each option\n                orderedOptionKeys.forEach(function(key) {\n                    dispatch('SET_' + fromCamels(key, '_').toUpperCase(), {\n                        value: options[key],\n                    });\n                });\n            },\n        };\n    };\n\n    var PrioritizedOptions = ['server'];\n\n    var formatFilename = function formatFilename(name) {\n        return name;\n    };\n\n    var createElement$1 = function createElement(tagName) {\n        return document.createElement(tagName);\n    };\n\n    var text = function text(node, value) {\n        var textNode = node.childNodes[0];\n        if (!textNode) {\n            textNode = document.createTextNode(value);\n            node.appendChild(textNode);\n        } else if (value !== textNode.nodeValue) {\n            textNode.nodeValue = value;\n        }\n    };\n\n    var polarToCartesian = function polarToCartesian(centerX, centerY, radius, angleInDegrees) {\n        var angleInRadians = (((angleInDegrees % 360) - 90) * Math.PI) / 180.0;\n        return {\n            x: centerX + radius * Math.cos(angleInRadians),\n            y: centerY + radius * Math.sin(angleInRadians),\n        };\n    };\n\n    var describeArc = function describeArc(x, y, radius, startAngle, endAngle, arcSweep) {\n        var start = polarToCartesian(x, y, radius, endAngle);\n        var end = polarToCartesian(x, y, radius, startAngle);\n        return ['M', start.x, start.y, 'A', radius, radius, 0, arcSweep, 0, end.x, end.y].join(' ');\n    };\n\n    var percentageArc = function percentageArc(x, y, radius, from, to) {\n        var arcSweep = 1;\n        if (to > from && to - from <= 0.5) {\n            arcSweep = 0;\n        }\n        if (from > to && from - to >= 0.5) {\n            arcSweep = 0;\n        }\n        return describeArc(\n            x,\n            y,\n            radius,\n            Math.min(0.9999, from) * 360,\n            Math.min(0.9999, to) * 360,\n            arcSweep\n        );\n    };\n\n    var create = function create(_ref) {\n        var root = _ref.root,\n            props = _ref.props;\n        // start at 0\n        props.spin = false;\n        props.progress = 0;\n        props.opacity = 0;\n\n        // svg\n        var svg = createElement('svg');\n        root.ref.path = createElement('path', {\n            'stroke-width': 2,\n            'stroke-linecap': 'round',\n        });\n\n        svg.appendChild(root.ref.path);\n\n        root.ref.svg = svg;\n\n        root.appendChild(svg);\n    };\n\n    var write = function write(_ref2) {\n        var root = _ref2.root,\n            props = _ref2.props;\n        if (props.opacity === 0) {\n            return;\n        }\n\n        if (props.align) {\n            root.element.dataset.align = props.align;\n        }\n\n        // get width of stroke\n        var ringStrokeWidth = parseInt(attr(root.ref.path, 'stroke-width'), 10);\n\n        // calculate size of ring\n        var size = root.rect.element.width * 0.5;\n\n        // ring state\n        var ringFrom = 0;\n        var ringTo = 0;\n\n        // now in busy mode\n        if (props.spin) {\n            ringFrom = 0;\n            ringTo = 0.5;\n        } else {\n            ringFrom = 0;\n            ringTo = props.progress;\n        }\n\n        // get arc path\n        var coordinates = percentageArc(size, size, size - ringStrokeWidth, ringFrom, ringTo);\n\n        // update progress bar\n        attr(root.ref.path, 'd', coordinates);\n\n        // hide while contains 0 value\n        attr(root.ref.path, 'stroke-opacity', props.spin || props.progress > 0 ? 1 : 0);\n    };\n\n    var progressIndicator = createView({\n        tag: 'div',\n        name: 'progress-indicator',\n        ignoreRectUpdate: true,\n        ignoreRect: true,\n        create: create,\n        write: write,\n        mixins: {\n            apis: ['progress', 'spin', 'align'],\n            styles: ['opacity'],\n            animations: {\n                opacity: { type: 'tween', duration: 500 },\n                progress: {\n                    type: 'spring',\n                    stiffness: 0.95,\n                    damping: 0.65,\n                    mass: 10,\n                },\n            },\n        },\n    });\n\n    var create$1 = function create(_ref) {\n        var root = _ref.root,\n            props = _ref.props;\n        root.element.innerHTML = (props.icon || '') + ('<span>' + props.label + '</span>');\n\n        props.isDisabled = false;\n    };\n\n    var write$1 = function write(_ref2) {\n        var root = _ref2.root,\n            props = _ref2.props;\n        var isDisabled = props.isDisabled;\n        var shouldDisable = root.query('GET_DISABLED') || props.opacity === 0;\n\n        if (shouldDisable && !isDisabled) {\n            props.isDisabled = true;\n            attr(root.element, 'disabled', 'disabled');\n        } else if (!shouldDisable && isDisabled) {\n            props.isDisabled = false;\n            root.element.removeAttribute('disabled');\n        }\n    };\n\n    var fileActionButton = createView({\n        tag: 'button',\n        attributes: {\n            type: 'button',\n        },\n\n        ignoreRect: true,\n        ignoreRectUpdate: true,\n        name: 'file-action-button',\n        mixins: {\n            apis: ['label'],\n            styles: ['translateX', 'translateY', 'scaleX', 'scaleY', 'opacity'],\n            animations: {\n                scaleX: 'spring',\n                scaleY: 'spring',\n                translateX: 'spring',\n                translateY: 'spring',\n                opacity: { type: 'tween', duration: 250 },\n            },\n\n            listeners: true,\n        },\n\n        create: create$1,\n        write: write$1,\n    });\n\n    var toNaturalFileSize = function toNaturalFileSize(bytes) {\n        var decimalSeparator =\n            arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '.';\n        var base = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1000;\n        var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n        var _options$labelBytes = options.labelBytes,\n            labelBytes = _options$labelBytes === void 0 ? 'bytes' : _options$labelBytes,\n            _options$labelKilobyt = options.labelKilobytes,\n            labelKilobytes = _options$labelKilobyt === void 0 ? 'KB' : _options$labelKilobyt,\n            _options$labelMegabyt = options.labelMegabytes,\n            labelMegabytes = _options$labelMegabyt === void 0 ? 'MB' : _options$labelMegabyt,\n            _options$labelGigabyt = options.labelGigabytes,\n            labelGigabytes = _options$labelGigabyt === void 0 ? 'GB' : _options$labelGigabyt;\n\n        // no negative byte sizes\n        bytes = Math.round(Math.abs(bytes));\n\n        var KB = base;\n        var MB = base * base;\n        var GB = base * base * base;\n\n        // just bytes\n        if (bytes < KB) {\n            return bytes + ' ' + labelBytes;\n        }\n\n        // kilobytes\n        if (bytes < MB) {\n            return Math.floor(bytes / KB) + ' ' + labelKilobytes;\n        }\n\n        // megabytes\n        if (bytes < GB) {\n            return removeDecimalsWhenZero(bytes / MB, 1, decimalSeparator) + ' ' + labelMegabytes;\n        }\n\n        // gigabytes\n        return removeDecimalsWhenZero(bytes / GB, 2, decimalSeparator) + ' ' + labelGigabytes;\n    };\n\n    var removeDecimalsWhenZero = function removeDecimalsWhenZero(value, decimalCount, separator) {\n        return value\n            .toFixed(decimalCount)\n            .split('.')\n            .filter(function(part) {\n                return part !== '0';\n            })\n            .join(separator);\n    };\n\n    var create$2 = function create(_ref) {\n        var root = _ref.root,\n            props = _ref.props;\n        // filename\n        var fileName = createElement$1('span');\n        fileName.className = 'filepond--file-info-main';\n        // hide for screenreaders\n        // the file is contained in a fieldset with legend that contains the filename\n        // no need to read it twice\n        attr(fileName, 'aria-hidden', 'true');\n        root.appendChild(fileName);\n        root.ref.fileName = fileName;\n\n        // filesize\n        var fileSize = createElement$1('span');\n        fileSize.className = 'filepond--file-info-sub';\n        root.appendChild(fileSize);\n        root.ref.fileSize = fileSize;\n\n        // set initial values\n        text(fileSize, root.query('GET_LABEL_FILE_WAITING_FOR_SIZE'));\n        text(fileName, formatFilename(root.query('GET_ITEM_NAME', props.id)));\n    };\n\n    var updateFile = function updateFile(_ref2) {\n        var root = _ref2.root,\n            props = _ref2.props;\n        text(\n            root.ref.fileSize,\n            toNaturalFileSize(\n                root.query('GET_ITEM_SIZE', props.id),\n                '.',\n                root.query('GET_FILE_SIZE_BASE'),\n                root.query('GET_FILE_SIZE_LABELS', root.query)\n            )\n        );\n\n        text(root.ref.fileName, formatFilename(root.query('GET_ITEM_NAME', props.id)));\n    };\n\n    var updateFileSizeOnError = function updateFileSizeOnError(_ref3) {\n        var root = _ref3.root,\n            props = _ref3.props;\n        // if size is available don't fallback to unknown size message\n        if (isInt(root.query('GET_ITEM_SIZE', props.id))) {\n            updateFile({ root: root, props: props });\n            return;\n        }\n\n        text(root.ref.fileSize, root.query('GET_LABEL_FILE_SIZE_NOT_AVAILABLE'));\n    };\n\n    var fileInfo = createView({\n        name: 'file-info',\n        ignoreRect: true,\n        ignoreRectUpdate: true,\n        write: createRoute({\n            DID_LOAD_ITEM: updateFile,\n            DID_UPDATE_ITEM_META: updateFile,\n            DID_THROW_ITEM_LOAD_ERROR: updateFileSizeOnError,\n            DID_THROW_ITEM_INVALID: updateFileSizeOnError,\n        }),\n\n        didCreateView: function didCreateView(root) {\n            applyFilters('CREATE_VIEW', Object.assign({}, root, { view: root }));\n        },\n        create: create$2,\n        mixins: {\n            styles: ['translateX', 'translateY'],\n            animations: {\n                translateX: 'spring',\n                translateY: 'spring',\n            },\n        },\n    });\n\n    var toPercentage = function toPercentage(value) {\n        return Math.round(value * 100);\n    };\n\n    var create$3 = function create(_ref) {\n        var root = _ref.root;\n\n        // main status\n        var main = createElement$1('span');\n        main.className = 'filepond--file-status-main';\n        root.appendChild(main);\n        root.ref.main = main;\n\n        // sub status\n        var sub = createElement$1('span');\n        sub.className = 'filepond--file-status-sub';\n        root.appendChild(sub);\n        root.ref.sub = sub;\n\n        didSetItemLoadProgress({ root: root, action: { progress: null } });\n    };\n\n    var didSetItemLoadProgress = function didSetItemLoadProgress(_ref2) {\n        var root = _ref2.root,\n            action = _ref2.action;\n        var title =\n            action.progress === null\n                ? root.query('GET_LABEL_FILE_LOADING')\n                : root.query('GET_LABEL_FILE_LOADING') + ' ' + toPercentage(action.progress) + '%';\n\n        text(root.ref.main, title);\n        text(root.ref.sub, root.query('GET_LABEL_TAP_TO_CANCEL'));\n    };\n\n    var didSetItemProcessProgress = function didSetItemProcessProgress(_ref3) {\n        var root = _ref3.root,\n            action = _ref3.action;\n        var title =\n            action.progress === null\n                ? root.query('GET_LABEL_FILE_PROCESSING')\n                : root.query('GET_LABEL_FILE_PROCESSING') +\n                  ' ' +\n                  toPercentage(action.progress) +\n                  '%';\n\n        text(root.ref.main, title);\n        text(root.ref.sub, root.query('GET_LABEL_TAP_TO_CANCEL'));\n    };\n\n    var didRequestItemProcessing = function didRequestItemProcessing(_ref4) {\n        var root = _ref4.root;\n        text(root.ref.main, root.query('GET_LABEL_FILE_PROCESSING'));\n        text(root.ref.sub, root.query('GET_LABEL_TAP_TO_CANCEL'));\n    };\n\n    var didAbortItemProcessing = function didAbortItemProcessing(_ref5) {\n        var root = _ref5.root;\n        text(root.ref.main, root.query('GET_LABEL_FILE_PROCESSING_ABORTED'));\n        text(root.ref.sub, root.query('GET_LABEL_TAP_TO_RETRY'));\n    };\n\n    var didCompleteItemProcessing = function didCompleteItemProcessing(_ref6) {\n        var root = _ref6.root;\n        text(root.ref.main, root.query('GET_LABEL_FILE_PROCESSING_COMPLETE'));\n        text(root.ref.sub, root.query('GET_LABEL_TAP_TO_UNDO'));\n    };\n\n    var clear = function clear(_ref7) {\n        var root = _ref7.root;\n        text(root.ref.main, '');\n        text(root.ref.sub, '');\n    };\n\n    var error = function error(_ref8) {\n        var root = _ref8.root,\n            action = _ref8.action;\n        text(root.ref.main, action.status.main);\n        text(root.ref.sub, action.status.sub);\n    };\n\n    var fileStatus = createView({\n        name: 'file-status',\n        ignoreRect: true,\n        ignoreRectUpdate: true,\n        write: createRoute({\n            DID_LOAD_ITEM: clear,\n            DID_REVERT_ITEM_PROCESSING: clear,\n            DID_REQUEST_ITEM_PROCESSING: didRequestItemProcessing,\n            DID_ABORT_ITEM_PROCESSING: didAbortItemProcessing,\n            DID_COMPLETE_ITEM_PROCESSING: didCompleteItemProcessing,\n            DID_UPDATE_ITEM_PROCESS_PROGRESS: didSetItemProcessProgress,\n            DID_UPDATE_ITEM_LOAD_PROGRESS: didSetItemLoadProgress,\n            DID_THROW_ITEM_LOAD_ERROR: error,\n            DID_THROW_ITEM_INVALID: error,\n            DID_THROW_ITEM_PROCESSING_ERROR: error,\n            DID_THROW_ITEM_PROCESSING_REVERT_ERROR: error,\n            DID_THROW_ITEM_REMOVE_ERROR: error,\n        }),\n\n        didCreateView: function didCreateView(root) {\n            applyFilters('CREATE_VIEW', Object.assign({}, root, { view: root }));\n        },\n        create: create$3,\n        mixins: {\n            styles: ['translateX', 'translateY', 'opacity'],\n            animations: {\n                opacity: { type: 'tween', duration: 250 },\n                translateX: 'spring',\n                translateY: 'spring',\n            },\n        },\n    });\n\n    /**\n     * Button definitions for the file view\n     */\n\n    var Buttons = {\n        AbortItemLoad: {\n            label: 'GET_LABEL_BUTTON_ABORT_ITEM_LOAD',\n            action: 'ABORT_ITEM_LOAD',\n            className: 'filepond--action-abort-item-load',\n            align: 'LOAD_INDICATOR_POSITION', // right\n        },\n        RetryItemLoad: {\n            label: 'GET_LABEL_BUTTON_RETRY_ITEM_LOAD',\n            action: 'RETRY_ITEM_LOAD',\n            icon: 'GET_ICON_RETRY',\n            className: 'filepond--action-retry-item-load',\n            align: 'BUTTON_PROCESS_ITEM_POSITION', // right\n        },\n        RemoveItem: {\n            label: 'GET_LABEL_BUTTON_REMOVE_ITEM',\n            action: 'REQUEST_REMOVE_ITEM',\n            icon: 'GET_ICON_REMOVE',\n            className: 'filepond--action-remove-item',\n            align: 'BUTTON_REMOVE_ITEM_POSITION', // left\n        },\n        ProcessItem: {\n            label: 'GET_LABEL_BUTTON_PROCESS_ITEM',\n            action: 'REQUEST_ITEM_PROCESSING',\n            icon: 'GET_ICON_PROCESS',\n            className: 'filepond--action-process-item',\n            align: 'BUTTON_PROCESS_ITEM_POSITION', // right\n        },\n        AbortItemProcessing: {\n            label: 'GET_LABEL_BUTTON_ABORT_ITEM_PROCESSING',\n            action: 'ABORT_ITEM_PROCESSING',\n            className: 'filepond--action-abort-item-processing',\n            align: 'BUTTON_PROCESS_ITEM_POSITION', // right\n        },\n        RetryItemProcessing: {\n            label: 'GET_LABEL_BUTTON_RETRY_ITEM_PROCESSING',\n            action: 'RETRY_ITEM_PROCESSING',\n            icon: 'GET_ICON_RETRY',\n            className: 'filepond--action-retry-item-processing',\n            align: 'BUTTON_PROCESS_ITEM_POSITION', // right\n        },\n        RevertItemProcessing: {\n            label: 'GET_LABEL_BUTTON_UNDO_ITEM_PROCESSING',\n            action: 'REQUEST_REVERT_ITEM_PROCESSING',\n            icon: 'GET_ICON_UNDO',\n            className: 'filepond--action-revert-item-processing',\n            align: 'BUTTON_PROCESS_ITEM_POSITION', // right\n        },\n    };\n\n    // make a list of buttons, we can then remove buttons from this list if they're disabled\n    var ButtonKeys = [];\n    forin(Buttons, function(key) {\n        ButtonKeys.push(key);\n    });\n\n    var calculateFileInfoOffset = function calculateFileInfoOffset(root) {\n        if (getRemoveIndicatorAligment(root) === 'right') return 0;\n        var buttonRect = root.ref.buttonRemoveItem.rect.element;\n        return buttonRect.hidden ? null : buttonRect.width + buttonRect.left;\n    };\n\n    var calculateButtonWidth = function calculateButtonWidth(root) {\n        var buttonRect = root.ref.buttonAbortItemLoad.rect.element;\n        return buttonRect.width;\n    };\n\n    // Force on full pixels so text stays crips\n    var calculateFileVerticalCenterOffset = function calculateFileVerticalCenterOffset(root) {\n        return Math.floor(root.ref.buttonRemoveItem.rect.element.height / 4);\n    };\n    var calculateFileHorizontalCenterOffset = function calculateFileHorizontalCenterOffset(root) {\n        return Math.floor(root.ref.buttonRemoveItem.rect.element.left / 2);\n    };\n\n    var getLoadIndicatorAlignment = function getLoadIndicatorAlignment(root) {\n        return root.query('GET_STYLE_LOAD_INDICATOR_POSITION');\n    };\n    var getProcessIndicatorAlignment = function getProcessIndicatorAlignment(root) {\n        return root.query('GET_STYLE_PROGRESS_INDICATOR_POSITION');\n    };\n    var getRemoveIndicatorAligment = function getRemoveIndicatorAligment(root) {\n        return root.query('GET_STYLE_BUTTON_REMOVE_ITEM_POSITION');\n    };\n\n    var DefaultStyle = {\n        buttonAbortItemLoad: { opacity: 0 },\n        buttonRetryItemLoad: { opacity: 0 },\n        buttonRemoveItem: { opacity: 0 },\n        buttonProcessItem: { opacity: 0 },\n        buttonAbortItemProcessing: { opacity: 0 },\n        buttonRetryItemProcessing: { opacity: 0 },\n        buttonRevertItemProcessing: { opacity: 0 },\n        loadProgressIndicator: { opacity: 0, align: getLoadIndicatorAlignment },\n        processProgressIndicator: { opacity: 0, align: getProcessIndicatorAlignment },\n        processingCompleteIndicator: { opacity: 0, scaleX: 0.75, scaleY: 0.75 },\n        info: { translateX: 0, translateY: 0, opacity: 0 },\n        status: { translateX: 0, translateY: 0, opacity: 0 },\n    };\n\n    var IdleStyle = {\n        buttonRemoveItem: { opacity: 1 },\n        buttonProcessItem: { opacity: 1 },\n        info: { translateX: calculateFileInfoOffset },\n        status: { translateX: calculateFileInfoOffset },\n    };\n\n    var ProcessingStyle = {\n        buttonAbortItemProcessing: { opacity: 1 },\n        processProgressIndicator: { opacity: 1 },\n        status: { opacity: 1 },\n    };\n\n    var StyleMap = {\n        DID_THROW_ITEM_INVALID: {\n            buttonRemoveItem: { opacity: 1 },\n            info: { translateX: calculateFileInfoOffset },\n            status: { translateX: calculateFileInfoOffset, opacity: 1 },\n        },\n\n        DID_START_ITEM_LOAD: {\n            buttonAbortItemLoad: { opacity: 1 },\n            loadProgressIndicator: { opacity: 1 },\n            status: { opacity: 1 },\n        },\n\n        DID_THROW_ITEM_LOAD_ERROR: {\n            buttonRetryItemLoad: { opacity: 1 },\n            buttonRemoveItem: { opacity: 1 },\n            info: { translateX: calculateFileInfoOffset },\n            status: { opacity: 1 },\n        },\n\n        DID_START_ITEM_REMOVE: {\n            processProgressIndicator: { opacity: 1, align: getRemoveIndicatorAligment },\n            info: { translateX: calculateFileInfoOffset },\n            status: { opacity: 0 },\n        },\n\n        DID_THROW_ITEM_REMOVE_ERROR: {\n            processProgressIndicator: { opacity: 0, align: getRemoveIndicatorAligment },\n            buttonRemoveItem: { opacity: 1 },\n            info: { translateX: calculateFileInfoOffset },\n            status: { opacity: 1, translateX: calculateFileInfoOffset },\n        },\n\n        DID_LOAD_ITEM: IdleStyle,\n        DID_LOAD_LOCAL_ITEM: {\n            buttonRemoveItem: { opacity: 1 },\n            info: { translateX: calculateFileInfoOffset },\n            status: { translateX: calculateFileInfoOffset },\n        },\n\n        DID_START_ITEM_PROCESSING: ProcessingStyle,\n        DID_REQUEST_ITEM_PROCESSING: ProcessingStyle,\n        DID_UPDATE_ITEM_PROCESS_PROGRESS: ProcessingStyle,\n        DID_COMPLETE_ITEM_PROCESSING: {\n            buttonRevertItemProcessing: { opacity: 1 },\n            info: { opacity: 1 },\n            status: { opacity: 1 },\n        },\n\n        DID_THROW_ITEM_PROCESSING_ERROR: {\n            buttonRemoveItem: { opacity: 1 },\n            buttonRetryItemProcessing: { opacity: 1 },\n            status: { opacity: 1 },\n            info: { translateX: calculateFileInfoOffset },\n        },\n\n        DID_THROW_ITEM_PROCESSING_REVERT_ERROR: {\n            buttonRevertItemProcessing: { opacity: 1 },\n            status: { opacity: 1 },\n            info: { opacity: 1 },\n        },\n\n        DID_ABORT_ITEM_PROCESSING: {\n            buttonRemoveItem: { opacity: 1 },\n            buttonProcessItem: { opacity: 1 },\n            info: { translateX: calculateFileInfoOffset },\n            status: { opacity: 1 },\n        },\n\n        DID_REVERT_ITEM_PROCESSING: IdleStyle,\n    };\n\n    // complete indicator view\n    var processingCompleteIndicatorView = createView({\n        create: function create(_ref) {\n            var root = _ref.root;\n            root.element.innerHTML = root.query('GET_ICON_DONE');\n        },\n        name: 'processing-complete-indicator',\n        ignoreRect: true,\n        mixins: {\n            styles: ['scaleX', 'scaleY', 'opacity'],\n            animations: {\n                scaleX: 'spring',\n                scaleY: 'spring',\n                opacity: { type: 'tween', duration: 250 },\n            },\n        },\n    });\n\n    /**\n     * Creates the file view\n     */\n    var create$4 = function create(_ref2) {\n        var root = _ref2.root,\n            props = _ref2.props;\n        // copy Buttons object\n        var LocalButtons = Object.keys(Buttons).reduce(function(prev, curr) {\n            prev[curr] = Object.assign({}, Buttons[curr]);\n            return prev;\n        }, {});\n        var id = props.id;\n\n        // allow reverting upload\n        var allowRevert = root.query('GET_ALLOW_REVERT');\n\n        // allow remove file\n        var allowRemove = root.query('GET_ALLOW_REMOVE');\n\n        // allow processing upload\n        var allowProcess = root.query('GET_ALLOW_PROCESS');\n\n        // is instant uploading, need this to determine the icon of the undo button\n        var instantUpload = root.query('GET_INSTANT_UPLOAD');\n\n        // is async set up\n        var isAsync = root.query('IS_ASYNC');\n\n        // should align remove item buttons\n        var alignRemoveItemButton = root.query('GET_STYLE_BUTTON_REMOVE_ITEM_ALIGN');\n\n        // enabled buttons array\n        var buttonFilter;\n        if (isAsync) {\n            if (allowProcess && !allowRevert) {\n                // only remove revert button\n                buttonFilter = function buttonFilter(key) {\n                    return !/RevertItemProcessing/.test(key);\n                };\n            } else if (!allowProcess && allowRevert) {\n                // only remove process button\n                buttonFilter = function buttonFilter(key) {\n                    return !/ProcessItem|RetryItemProcessing|AbortItemProcessing/.test(key);\n                };\n            } else if (!allowProcess && !allowRevert) {\n                // remove all process buttons\n                buttonFilter = function buttonFilter(key) {\n                    return !/Process/.test(key);\n                };\n            }\n        } else {\n            // no process controls available\n            buttonFilter = function buttonFilter(key) {\n                return !/Process/.test(key);\n            };\n        }\n\n        var enabledButtons = buttonFilter ? ButtonKeys.filter(buttonFilter) : ButtonKeys.concat();\n\n        // update icon and label for revert button when instant uploading\n        if (instantUpload && allowRevert) {\n            LocalButtons['RevertItemProcessing'].label = 'GET_LABEL_BUTTON_REMOVE_ITEM';\n            LocalButtons['RevertItemProcessing'].icon = 'GET_ICON_REMOVE';\n        }\n\n        // remove last button (revert) if not allowed\n        if (isAsync && !allowRevert) {\n            var map = StyleMap['DID_COMPLETE_ITEM_PROCESSING'];\n            map.info.translateX = calculateFileHorizontalCenterOffset;\n            map.info.translateY = calculateFileVerticalCenterOffset;\n            map.status.translateY = calculateFileVerticalCenterOffset;\n            map.processingCompleteIndicator = { opacity: 1, scaleX: 1, scaleY: 1 };\n        }\n\n        // should align center\n        if (isAsync && !allowProcess) {\n            [\n                'DID_START_ITEM_PROCESSING',\n                'DID_REQUEST_ITEM_PROCESSING',\n                'DID_UPDATE_ITEM_PROCESS_PROGRESS',\n                'DID_THROW_ITEM_PROCESSING_ERROR',\n            ].forEach(function(key) {\n                StyleMap[key].status.translateY = calculateFileVerticalCenterOffset;\n            });\n            StyleMap['DID_THROW_ITEM_PROCESSING_ERROR'].status.translateX = calculateButtonWidth;\n        }\n\n        // move remove button to right\n        if (alignRemoveItemButton && allowRevert) {\n            LocalButtons['RevertItemProcessing'].align = 'BUTTON_REMOVE_ITEM_POSITION';\n            var _map = StyleMap['DID_COMPLETE_ITEM_PROCESSING'];\n            _map.info.translateX = calculateFileInfoOffset;\n            _map.status.translateY = calculateFileVerticalCenterOffset;\n            _map.processingCompleteIndicator = { opacity: 1, scaleX: 1, scaleY: 1 };\n        }\n\n        // show/hide RemoveItem button\n        if (!allowRemove) {\n            LocalButtons['RemoveItem'].disabled = true;\n        }\n\n        // create the button views\n        forin(LocalButtons, function(key, definition) {\n            // create button\n            var buttonView = root.createChildView(fileActionButton, {\n                label: root.query(definition.label),\n                icon: root.query(definition.icon),\n                opacity: 0,\n            });\n\n            // should be appended?\n            if (enabledButtons.includes(key)) {\n                root.appendChildView(buttonView);\n            }\n\n            // toggle\n            if (definition.disabled) {\n                buttonView.element.setAttribute('disabled', 'disabled');\n                buttonView.element.setAttribute('hidden', 'hidden');\n            }\n\n            // add position attribute\n            buttonView.element.dataset.align = root.query('GET_STYLE_' + definition.align);\n\n            // add class\n            buttonView.element.classList.add(definition.className);\n\n            // handle interactions\n            buttonView.on('click', function(e) {\n                e.stopPropagation();\n                if (definition.disabled) return;\n                root.dispatch(definition.action, { query: id });\n            });\n\n            // set reference\n            root.ref['button' + key] = buttonView;\n        });\n\n        // checkmark\n        root.ref.processingCompleteIndicator = root.appendChildView(\n            root.createChildView(processingCompleteIndicatorView)\n        );\n\n        root.ref.processingCompleteIndicator.element.dataset.align = root.query(\n            'GET_STYLE_BUTTON_PROCESS_ITEM_POSITION'\n        );\n\n        // create file info view\n        root.ref.info = root.appendChildView(root.createChildView(fileInfo, { id: id }));\n\n        // create file status view\n        root.ref.status = root.appendChildView(root.createChildView(fileStatus, { id: id }));\n\n        // add progress indicators\n        var loadIndicatorView = root.appendChildView(\n            root.createChildView(progressIndicator, {\n                opacity: 0,\n                align: root.query('GET_STYLE_LOAD_INDICATOR_POSITION'),\n            })\n        );\n\n        loadIndicatorView.element.classList.add('filepond--load-indicator');\n        root.ref.loadProgressIndicator = loadIndicatorView;\n\n        var progressIndicatorView = root.appendChildView(\n            root.createChildView(progressIndicator, {\n                opacity: 0,\n                align: root.query('GET_STYLE_PROGRESS_INDICATOR_POSITION'),\n            })\n        );\n\n        progressIndicatorView.element.classList.add('filepond--process-indicator');\n        root.ref.processProgressIndicator = progressIndicatorView;\n\n        // current active styles\n        root.ref.activeStyles = [];\n    };\n\n    var write$2 = function write(_ref3) {\n        var root = _ref3.root,\n            actions = _ref3.actions,\n            props = _ref3.props;\n        // route actions\n        route({ root: root, actions: actions, props: props });\n\n        // select last state change action\n        var action = actions\n            .concat()\n            .filter(function(action) {\n                return /^DID_/.test(action.type);\n            })\n            .reverse()\n            .find(function(action) {\n                return StyleMap[action.type];\n            });\n\n        // a new action happened, let's get the matching styles\n        if (action) {\n            // define new active styles\n            root.ref.activeStyles = [];\n\n            var stylesToApply = StyleMap[action.type];\n            forin(DefaultStyle, function(name, defaultStyles) {\n                // get reference to control\n                var control = root.ref[name];\n\n                // loop over all styles for this control\n                forin(defaultStyles, function(key, defaultValue) {\n                    var value =\n                        stylesToApply[name] && typeof stylesToApply[name][key] !== 'undefined'\n                            ? stylesToApply[name][key]\n                            : defaultValue;\n                    root.ref.activeStyles.push({ control: control, key: key, value: value });\n                });\n            });\n        }\n\n        // apply active styles to element\n        root.ref.activeStyles.forEach(function(_ref4) {\n            var control = _ref4.control,\n                key = _ref4.key,\n                value = _ref4.value;\n            control[key] = typeof value === 'function' ? value(root) : value;\n        });\n    };\n\n    var route = createRoute({\n        DID_SET_LABEL_BUTTON_ABORT_ITEM_PROCESSING: function DID_SET_LABEL_BUTTON_ABORT_ITEM_PROCESSING(\n            _ref5\n        ) {\n            var root = _ref5.root,\n                action = _ref5.action;\n            root.ref.buttonAbortItemProcessing.label = action.value;\n        },\n        DID_SET_LABEL_BUTTON_ABORT_ITEM_LOAD: function DID_SET_LABEL_BUTTON_ABORT_ITEM_LOAD(_ref6) {\n            var root = _ref6.root,\n                action = _ref6.action;\n            root.ref.buttonAbortItemLoad.label = action.value;\n        },\n        DID_SET_LABEL_BUTTON_ABORT_ITEM_REMOVAL: function DID_SET_LABEL_BUTTON_ABORT_ITEM_REMOVAL(\n            _ref7\n        ) {\n            var root = _ref7.root,\n                action = _ref7.action;\n            root.ref.buttonAbortItemRemoval.label = action.value;\n        },\n        DID_REQUEST_ITEM_PROCESSING: function DID_REQUEST_ITEM_PROCESSING(_ref8) {\n            var root = _ref8.root;\n            root.ref.processProgressIndicator.spin = true;\n            root.ref.processProgressIndicator.progress = 0;\n        },\n        DID_START_ITEM_LOAD: function DID_START_ITEM_LOAD(_ref9) {\n            var root = _ref9.root;\n            root.ref.loadProgressIndicator.spin = true;\n            root.ref.loadProgressIndicator.progress = 0;\n        },\n        DID_START_ITEM_REMOVE: function DID_START_ITEM_REMOVE(_ref10) {\n            var root = _ref10.root;\n            root.ref.processProgressIndicator.spin = true;\n            root.ref.processProgressIndicator.progress = 0;\n        },\n        DID_UPDATE_ITEM_LOAD_PROGRESS: function DID_UPDATE_ITEM_LOAD_PROGRESS(_ref11) {\n            var root = _ref11.root,\n                action = _ref11.action;\n            root.ref.loadProgressIndicator.spin = false;\n            root.ref.loadProgressIndicator.progress = action.progress;\n        },\n        DID_UPDATE_ITEM_PROCESS_PROGRESS: function DID_UPDATE_ITEM_PROCESS_PROGRESS(_ref12) {\n            var root = _ref12.root,\n                action = _ref12.action;\n            root.ref.processProgressIndicator.spin = false;\n            root.ref.processProgressIndicator.progress = action.progress;\n        },\n    });\n\n    var file = createView({\n        create: create$4,\n        write: write$2,\n        didCreateView: function didCreateView(root) {\n            applyFilters('CREATE_VIEW', Object.assign({}, root, { view: root }));\n        },\n        name: 'file',\n    });\n\n    /**\n     * Creates the file view\n     */\n    var create$5 = function create(_ref) {\n        var root = _ref.root,\n            props = _ref.props;\n\n        // filename\n        root.ref.fileName = createElement$1('legend');\n        root.appendChild(root.ref.fileName);\n\n        // file appended\n        root.ref.file = root.appendChildView(root.createChildView(file, { id: props.id }));\n\n        // data has moved to data.js\n        root.ref.data = false;\n    };\n\n    /**\n     * Data storage\n     */\n    var didLoadItem = function didLoadItem(_ref2) {\n        var root = _ref2.root,\n            props = _ref2.props;\n        // updates the legend of the fieldset so screenreaders can better group buttons\n        text(root.ref.fileName, formatFilename(root.query('GET_ITEM_NAME', props.id)));\n    };\n\n    var fileWrapper = createView({\n        create: create$5,\n        ignoreRect: true,\n        write: createRoute({\n            DID_LOAD_ITEM: didLoadItem,\n        }),\n\n        didCreateView: function didCreateView(root) {\n            applyFilters('CREATE_VIEW', Object.assign({}, root, { view: root }));\n        },\n        tag: 'fieldset',\n        name: 'file-wrapper',\n    });\n\n    var PANEL_SPRING_PROPS = { type: 'spring', damping: 0.6, mass: 7 };\n\n    var create$6 = function create(_ref) {\n        var root = _ref.root,\n            props = _ref.props;\n        [\n            {\n                name: 'top',\n            },\n\n            {\n                name: 'center',\n                props: {\n                    translateY: null,\n                    scaleY: null,\n                },\n\n                mixins: {\n                    animations: {\n                        scaleY: PANEL_SPRING_PROPS,\n                    },\n\n                    styles: ['translateY', 'scaleY'],\n                },\n            },\n\n            {\n                name: 'bottom',\n                props: {\n                    translateY: null,\n                },\n\n                mixins: {\n                    animations: {\n                        translateY: PANEL_SPRING_PROPS,\n                    },\n\n                    styles: ['translateY'],\n                },\n            },\n        ].forEach(function(section) {\n            createSection(root, section, props.name);\n        });\n\n        root.element.classList.add('filepond--' + props.name);\n\n        root.ref.scalable = null;\n    };\n\n    var createSection = function createSection(root, section, className) {\n        var viewConstructor = createView({\n            name: 'panel-' + section.name + ' filepond--' + className,\n            mixins: section.mixins,\n            ignoreRectUpdate: true,\n        });\n\n        var view = root.createChildView(viewConstructor, section.props);\n\n        root.ref[section.name] = root.appendChildView(view);\n    };\n\n    var write$3 = function write(_ref2) {\n        var root = _ref2.root,\n            props = _ref2.props;\n\n        // update scalable state\n        if (root.ref.scalable === null || props.scalable !== root.ref.scalable) {\n            root.ref.scalable = isBoolean(props.scalable) ? props.scalable : true;\n            root.element.dataset.scalable = root.ref.scalable;\n        }\n\n        // no height, can't set\n        if (!props.height) return;\n\n        // get child rects\n        var topRect = root.ref.top.rect.element;\n        var bottomRect = root.ref.bottom.rect.element;\n\n        // make sure height never is smaller than bottom and top seciton heights combined (will probably never happen, but who knows)\n        var height = Math.max(topRect.height + bottomRect.height, props.height);\n\n        // offset center part\n        root.ref.center.translateY = topRect.height;\n\n        // scale center part\n        // use math ceil to prevent transparent lines because of rounding errors\n        root.ref.center.scaleY = (height - topRect.height - bottomRect.height) / 100;\n\n        // offset bottom part\n        root.ref.bottom.translateY = height - bottomRect.height;\n    };\n\n    var panel = createView({\n        name: 'panel',\n        read: function read(_ref3) {\n            var root = _ref3.root,\n                props = _ref3.props;\n            return (props.heightCurrent = root.ref.bottom.translateY);\n        },\n        write: write$3,\n        create: create$6,\n        ignoreRect: true,\n        mixins: {\n            apis: ['height', 'heightCurrent', 'scalable'],\n        },\n    });\n\n    var createDragHelper = function createDragHelper(items) {\n        var itemIds = items.map(function(item) {\n            return item.id;\n        });\n        var prevIndex = undefined;\n        return {\n            setIndex: function setIndex(index) {\n                prevIndex = index;\n            },\n            getIndex: function getIndex() {\n                return prevIndex;\n            },\n            getItemIndex: function getItemIndex(item) {\n                return itemIds.indexOf(item.id);\n            },\n        };\n    };\n\n    var ITEM_TRANSLATE_SPRING = {\n        type: 'spring',\n        stiffness: 0.75,\n        damping: 0.45,\n        mass: 10,\n    };\n\n    var ITEM_SCALE_SPRING = 'spring';\n\n    var StateMap = {\n        DID_START_ITEM_LOAD: 'busy',\n        DID_UPDATE_ITEM_LOAD_PROGRESS: 'loading',\n        DID_THROW_ITEM_INVALID: 'load-invalid',\n        DID_THROW_ITEM_LOAD_ERROR: 'load-error',\n        DID_LOAD_ITEM: 'idle',\n        DID_THROW_ITEM_REMOVE_ERROR: 'remove-error',\n        DID_START_ITEM_REMOVE: 'busy',\n        DID_START_ITEM_PROCESSING: 'busy processing',\n        DID_REQUEST_ITEM_PROCESSING: 'busy processing',\n        DID_UPDATE_ITEM_PROCESS_PROGRESS: 'processing',\n        DID_COMPLETE_ITEM_PROCESSING: 'processing-complete',\n        DID_THROW_ITEM_PROCESSING_ERROR: 'processing-error',\n        DID_THROW_ITEM_PROCESSING_REVERT_ERROR: 'processing-revert-error',\n        DID_ABORT_ITEM_PROCESSING: 'cancelled',\n        DID_REVERT_ITEM_PROCESSING: 'idle',\n    };\n\n    /**\n     * Creates the file view\n     */\n    var create$7 = function create(_ref) {\n        var root = _ref.root,\n            props = _ref.props;\n\n        // select\n        root.ref.handleClick = function(e) {\n            return root.dispatch('DID_ACTIVATE_ITEM', { id: props.id });\n        };\n\n        // set id\n        root.element.id = 'filepond--item-' + props.id;\n        root.element.addEventListener('click', root.ref.handleClick);\n\n        // file view\n        root.ref.container = root.appendChildView(\n            root.createChildView(fileWrapper, { id: props.id })\n        );\n\n        // file panel\n        root.ref.panel = root.appendChildView(root.createChildView(panel, { name: 'item-panel' }));\n\n        // default start height\n        root.ref.panel.height = null;\n\n        // by default not marked for removal\n        props.markedForRemoval = false;\n\n        // if not allowed to reorder file items, exit here\n        if (!root.query('GET_ALLOW_REORDER')) return;\n\n        // set to idle so shows grab cursor\n        root.element.dataset.dragState = 'idle';\n\n        var grab = function grab(e) {\n            if (!e.isPrimary) return;\n\n            var removedActivateListener = false;\n\n            var origin = {\n                x: e.pageX,\n                y: e.pageY,\n            };\n\n            props.dragOrigin = {\n                x: root.translateX,\n                y: root.translateY,\n            };\n\n            props.dragCenter = {\n                x: e.offsetX,\n                y: e.offsetY,\n            };\n\n            var dragState = createDragHelper(root.query('GET_ACTIVE_ITEMS'));\n\n            root.dispatch('DID_GRAB_ITEM', { id: props.id, dragState: dragState });\n\n            var drag = function drag(e) {\n                if (!e.isPrimary) return;\n\n                e.stopPropagation();\n                e.preventDefault();\n\n                props.dragOffset = {\n                    x: e.pageX - origin.x,\n                    y: e.pageY - origin.y,\n                };\n\n                // if dragged stop listening to clicks, will re-add when done dragging\n                var dist =\n                    props.dragOffset.x * props.dragOffset.x +\n                    props.dragOffset.y * props.dragOffset.y;\n                if (dist > 16 && !removedActivateListener) {\n                    removedActivateListener = true;\n                    root.element.removeEventListener('click', root.ref.handleClick);\n                }\n\n                root.dispatch('DID_DRAG_ITEM', { id: props.id, dragState: dragState });\n            };\n\n            var drop = function drop(e) {\n                if (!e.isPrimary) return;\n\n                document.removeEventListener('pointermove', drag);\n                document.removeEventListener('pointerup', drop);\n\n                props.dragOffset = {\n                    x: e.pageX - origin.x,\n                    y: e.pageY - origin.y,\n                };\n\n                root.dispatch('DID_DROP_ITEM', { id: props.id, dragState: dragState });\n\n                // start listening to clicks again\n                if (removedActivateListener) {\n                    setTimeout(function() {\n                        return root.element.addEventListener('click', root.ref.handleClick);\n                    }, 0);\n                }\n            };\n\n            document.addEventListener('pointermove', drag);\n            document.addEventListener('pointerup', drop);\n        };\n\n        root.element.addEventListener('pointerdown', grab);\n    };\n\n    var route$1 = createRoute({\n        DID_UPDATE_PANEL_HEIGHT: function DID_UPDATE_PANEL_HEIGHT(_ref2) {\n            var root = _ref2.root,\n                action = _ref2.action;\n            root.height = action.height;\n        },\n    });\n\n    var write$4 = createRoute(\n        {\n            DID_GRAB_ITEM: function DID_GRAB_ITEM(_ref3) {\n                var root = _ref3.root,\n                    props = _ref3.props;\n                props.dragOrigin = {\n                    x: root.translateX,\n                    y: root.translateY,\n                };\n            },\n            DID_DRAG_ITEM: function DID_DRAG_ITEM(_ref4) {\n                var root = _ref4.root;\n                root.element.dataset.dragState = 'drag';\n            },\n            DID_DROP_ITEM: function DID_DROP_ITEM(_ref5) {\n                var root = _ref5.root,\n                    props = _ref5.props;\n                props.dragOffset = null;\n                props.dragOrigin = null;\n                root.element.dataset.dragState = 'drop';\n            },\n        },\n        function(_ref6) {\n            var root = _ref6.root,\n                actions = _ref6.actions,\n                props = _ref6.props,\n                shouldOptimize = _ref6.shouldOptimize;\n\n            if (root.element.dataset.dragState === 'drop') {\n                if (root.scaleX <= 1) {\n                    root.element.dataset.dragState = 'idle';\n                }\n            }\n\n            // select last state change action\n            var action = actions\n                .concat()\n                .filter(function(action) {\n                    return /^DID_/.test(action.type);\n                })\n                .reverse()\n                .find(function(action) {\n                    return StateMap[action.type];\n                });\n\n            // no need to set same state twice\n            if (action && action.type !== props.currentState) {\n                // set current state\n                props.currentState = action.type;\n\n                // set state\n                root.element.dataset.filepondItemState = StateMap[props.currentState] || '';\n            }\n\n            // route actions\n            var aspectRatio =\n                root.query('GET_ITEM_PANEL_ASPECT_RATIO') || root.query('GET_PANEL_ASPECT_RATIO');\n            if (!aspectRatio) {\n                route$1({ root: root, actions: actions, props: props });\n                if (!root.height && root.ref.container.rect.element.height > 0) {\n                    root.height = root.ref.container.rect.element.height;\n                }\n            } else if (!shouldOptimize) {\n                root.height = root.rect.element.width * aspectRatio;\n            }\n\n            // sync panel height with item height\n            if (shouldOptimize) {\n                root.ref.panel.height = null;\n            }\n\n            root.ref.panel.height = root.height;\n        }\n    );\n\n    var item = createView({\n        create: create$7,\n        write: write$4,\n        destroy: function destroy(_ref7) {\n            var root = _ref7.root,\n                props = _ref7.props;\n            root.element.removeEventListener('click', root.ref.handleClick);\n            root.dispatch('RELEASE_ITEM', { query: props.id });\n        },\n        tag: 'li',\n        name: 'item',\n        mixins: {\n            apis: [\n                'id',\n                'interactionMethod',\n                'markedForRemoval',\n                'spawnDate',\n                'dragCenter',\n                'dragOrigin',\n                'dragOffset',\n            ],\n            styles: ['translateX', 'translateY', 'scaleX', 'scaleY', 'opacity', 'height'],\n\n            animations: {\n                scaleX: ITEM_SCALE_SPRING,\n                scaleY: ITEM_SCALE_SPRING,\n                translateX: ITEM_TRANSLATE_SPRING,\n                translateY: ITEM_TRANSLATE_SPRING,\n                opacity: { type: 'tween', duration: 150 },\n            },\n        },\n    });\n\n    var getItemsPerRow = function(horizontalSpace, itemWidth) {\n        // add one pixel leeway, when using percentages for item width total items can be 1.99 per row\n\n        return Math.max(1, Math.floor((horizontalSpace + 1) / itemWidth));\n    };\n\n    var getItemIndexByPosition = function getItemIndexByPosition(view, children, positionInView) {\n        if (!positionInView) return;\n\n        var horizontalSpace = view.rect.element.width;\n        // const children = view.childViews;\n        var l = children.length;\n        var last = null;\n\n        // -1, don't move items to accomodate (either add to top or bottom)\n        if (l === 0 || positionInView.top < children[0].rect.element.top) return -1;\n\n        // let's get the item width\n        var item = children[0];\n        var itemRect = item.rect.element;\n        var itemHorizontalMargin = itemRect.marginLeft + itemRect.marginRight;\n        var itemWidth = itemRect.width + itemHorizontalMargin;\n        var itemsPerRow = getItemsPerRow(horizontalSpace, itemWidth);\n\n        // stack\n        if (itemsPerRow === 1) {\n            for (var index = 0; index < l; index++) {\n                var child = children[index];\n                var childMid = child.rect.outer.top + child.rect.element.height * 0.5;\n                if (positionInView.top < childMid) {\n                    return index;\n                }\n            }\n            return l;\n        }\n\n        // grid\n        var itemVerticalMargin = itemRect.marginTop + itemRect.marginBottom;\n        var itemHeight = itemRect.height + itemVerticalMargin;\n        for (var _index = 0; _index < l; _index++) {\n            var indexX = _index % itemsPerRow;\n            var indexY = Math.floor(_index / itemsPerRow);\n\n            var offsetX = indexX * itemWidth;\n            var offsetY = indexY * itemHeight;\n\n            var itemTop = offsetY - itemRect.marginTop;\n            var itemRight = offsetX + itemWidth;\n            var itemBottom = offsetY + itemHeight + itemRect.marginBottom;\n\n            if (positionInView.top < itemBottom && positionInView.top > itemTop) {\n                if (positionInView.left < itemRight) {\n                    return _index;\n                } else if (_index !== l - 1) {\n                    last = _index;\n                } else {\n                    last = null;\n                }\n            }\n        }\n\n        if (last !== null) {\n            return last;\n        }\n\n        return l;\n    };\n\n    var dropAreaDimensions = {\n        height: 0,\n        width: 0,\n        get getHeight() {\n            return this.height;\n        },\n        set setHeight(val) {\n            if (this.height === 0 || val === 0) this.height = val;\n        },\n        get getWidth() {\n            return this.width;\n        },\n        set setWidth(val) {\n            if (this.width === 0 || val === 0) this.width = val;\n        },\n        setDimensions: function setDimensions(height, width) {\n            if (this.height === 0 || height === 0) this.height = height;\n            if (this.width === 0 || width === 0) this.width = width;\n        },\n    };\n\n    var create$8 = function create(_ref) {\n        var root = _ref.root;\n        // need to set role to list as otherwise it won't be read as a list by VoiceOver\n        attr(root.element, 'role', 'list');\n\n        root.ref.lastItemSpanwDate = Date.now();\n    };\n\n    /**\n     * Inserts a new item\n     * @param root\n     * @param action\n     */\n    var addItemView = function addItemView(_ref2) {\n        var root = _ref2.root,\n            action = _ref2.action;\n        var id = action.id,\n            index = action.index,\n            interactionMethod = action.interactionMethod;\n\n        root.ref.addIndex = index;\n\n        var now = Date.now();\n        var spawnDate = now;\n        var opacity = 1;\n\n        if (interactionMethod !== InteractionMethod.NONE) {\n            opacity = 0;\n            var cooldown = root.query('GET_ITEM_INSERT_INTERVAL');\n            var dist = now - root.ref.lastItemSpanwDate;\n            spawnDate = dist < cooldown ? now + (cooldown - dist) : now;\n        }\n\n        root.ref.lastItemSpanwDate = spawnDate;\n\n        root.appendChildView(\n            root.createChildView(\n                // view type\n                item,\n\n                // props\n                {\n                    spawnDate: spawnDate,\n                    id: id,\n                    opacity: opacity,\n                    interactionMethod: interactionMethod,\n                }\n            ),\n\n            index\n        );\n    };\n\n    var moveItem = function moveItem(item, x, y) {\n        var vx = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n        var vy = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;\n        // set to null to remove animation while dragging\n        if (item.dragOffset) {\n            item.translateX = null;\n            item.translateY = null;\n            item.translateX = item.dragOrigin.x + item.dragOffset.x;\n            item.translateY = item.dragOrigin.y + item.dragOffset.y;\n            item.scaleX = 1.025;\n            item.scaleY = 1.025;\n        } else {\n            item.translateX = x;\n            item.translateY = y;\n\n            if (Date.now() > item.spawnDate) {\n                // reveal element\n                if (item.opacity === 0) {\n                    introItemView(item, x, y, vx, vy);\n                }\n\n                // make sure is default scale every frame\n                item.scaleX = 1;\n                item.scaleY = 1;\n                item.opacity = 1;\n            }\n        }\n    };\n\n    var introItemView = function introItemView(item, x, y, vx, vy) {\n        if (item.interactionMethod === InteractionMethod.NONE) {\n            item.translateX = null;\n            item.translateX = x;\n            item.translateY = null;\n            item.translateY = y;\n        } else if (item.interactionMethod === InteractionMethod.DROP) {\n            item.translateX = null;\n            item.translateX = x - vx * 20;\n\n            item.translateY = null;\n            item.translateY = y - vy * 10;\n\n            item.scaleX = 0.8;\n            item.scaleY = 0.8;\n        } else if (item.interactionMethod === InteractionMethod.BROWSE) {\n            item.translateY = null;\n            item.translateY = y - 30;\n        } else if (item.interactionMethod === InteractionMethod.API) {\n            item.translateX = null;\n            item.translateX = x - 30;\n            item.translateY = null;\n        }\n    };\n\n    /**\n     * Removes an existing item\n     * @param root\n     * @param action\n     */\n    var removeItemView = function removeItemView(_ref3) {\n        var root = _ref3.root,\n            action = _ref3.action;\n        var id = action.id;\n\n        // get the view matching the given id\n        var view = root.childViews.find(function(child) {\n            return child.id === id;\n        });\n\n        // if no view found, exit\n        if (!view) {\n            return;\n        }\n\n        // animate view out of view\n        view.scaleX = 0.9;\n        view.scaleY = 0.9;\n        view.opacity = 0;\n\n        // mark for removal\n        view.markedForRemoval = true;\n    };\n\n    var getItemHeight = function getItemHeight(child) {\n        return (\n            child.rect.element.height +\n            child.rect.element.marginBottom * 0.5 +\n            child.rect.element.marginTop * 0.5\n        );\n    };\n    var getItemWidth = function getItemWidth(child) {\n        return (\n            child.rect.element.width +\n            child.rect.element.marginLeft * 0.5 +\n            child.rect.element.marginRight * 0.5\n        );\n    };\n\n    var dragItem = function dragItem(_ref4) {\n        var root = _ref4.root,\n            action = _ref4.action;\n        var id = action.id,\n            dragState = action.dragState;\n\n        // reference to item\n        var item = root.query('GET_ITEM', { id: id });\n\n        // get the view matching the given id\n        var view = root.childViews.find(function(child) {\n            return child.id === id;\n        });\n\n        var numItems = root.childViews.length;\n        var oldIndex = dragState.getItemIndex(item);\n\n        // if no view found, exit\n        if (!view) return;\n\n        var dragPosition = {\n            x: view.dragOrigin.x + view.dragOffset.x + view.dragCenter.x,\n            y: view.dragOrigin.y + view.dragOffset.y + view.dragCenter.y,\n        };\n\n        // get drag area dimensions\n        var dragHeight = getItemHeight(view);\n        var dragWidth = getItemWidth(view);\n\n        // get rows and columns (There will always be at least one row and one column if a file is present)\n        var cols = Math.floor(root.rect.outer.width / dragWidth);\n        if (cols > numItems) cols = numItems;\n\n        // rows are used to find when we have left the preview area bounding box\n        var rows = Math.floor(numItems / cols + 1);\n\n        dropAreaDimensions.setHeight = dragHeight * rows;\n        dropAreaDimensions.setWidth = dragWidth * cols;\n\n        // get new index of dragged item\n        var location = {\n            y: Math.floor(dragPosition.y / dragHeight),\n            x: Math.floor(dragPosition.x / dragWidth),\n            getGridIndex: function getGridIndex() {\n                if (\n                    dragPosition.y > dropAreaDimensions.getHeight ||\n                    dragPosition.y < 0 ||\n                    dragPosition.x > dropAreaDimensions.getWidth ||\n                    dragPosition.x < 0\n                )\n                    return oldIndex;\n                return this.y * cols + this.x;\n            },\n            getColIndex: function getColIndex() {\n                var items = root.query('GET_ACTIVE_ITEMS');\n                var visibleChildren = root.childViews.filter(function(child) {\n                    return child.rect.element.height;\n                });\n                var children = items.map(function(item) {\n                    return visibleChildren.find(function(childView) {\n                        return childView.id === item.id;\n                    });\n                });\n\n                var currentIndex = children.findIndex(function(child) {\n                    return child === view;\n                });\n                var dragHeight = getItemHeight(view);\n                var l = children.length;\n                var idx = l;\n                var childHeight = 0;\n                var childBottom = 0;\n                var childTop = 0;\n                for (var i = 0; i < l; i++) {\n                    childHeight = getItemHeight(children[i]);\n                    childTop = childBottom;\n                    childBottom = childTop + childHeight;\n                    if (dragPosition.y < childBottom) {\n                        if (currentIndex > i) {\n                            if (dragPosition.y < childTop + dragHeight) {\n                                idx = i;\n                                break;\n                            }\n                            continue;\n                        }\n                        idx = i;\n                        break;\n                    }\n                }\n                return idx;\n            },\n        };\n\n        // get new index\n        var index = cols > 1 ? location.getGridIndex() : location.getColIndex();\n        root.dispatch('MOVE_ITEM', { query: view, index: index });\n\n        // if the index of the item changed, dispatch reorder action\n        var currentIndex = dragState.getIndex();\n\n        if (currentIndex === undefined || currentIndex !== index) {\n            dragState.setIndex(index);\n\n            if (currentIndex === undefined) return;\n\n            root.dispatch('DID_REORDER_ITEMS', {\n                items: root.query('GET_ACTIVE_ITEMS'),\n                origin: oldIndex,\n                target: index,\n            });\n        }\n    };\n\n    /**\n     * Setup action routes\n     */\n    var route$2 = createRoute({\n        DID_ADD_ITEM: addItemView,\n        DID_REMOVE_ITEM: removeItemView,\n        DID_DRAG_ITEM: dragItem,\n    });\n\n    /**\n     * Write to view\n     * @param root\n     * @param actions\n     * @param props\n     */\n    var write$5 = function write(_ref5) {\n        var root = _ref5.root,\n            props = _ref5.props,\n            actions = _ref5.actions,\n            shouldOptimize = _ref5.shouldOptimize;\n        // route actions\n        route$2({ root: root, props: props, actions: actions });\n        var dragCoordinates = props.dragCoordinates;\n\n        // available space on horizontal axis\n        var horizontalSpace = root.rect.element.width;\n\n        // only draw children that have dimensions\n        var visibleChildren = root.childViews.filter(function(child) {\n            return child.rect.element.height;\n        });\n\n        // sort based on current active items\n        var children = root\n            .query('GET_ACTIVE_ITEMS')\n            .map(function(item) {\n                return visibleChildren.find(function(child) {\n                    return child.id === item.id;\n                });\n            })\n            .filter(function(item) {\n                return item;\n            });\n\n        // get index\n        var dragIndex = dragCoordinates\n            ? getItemIndexByPosition(root, children, dragCoordinates)\n            : null;\n\n        // add index is used to reserve the dropped/added item index till the actual item is rendered\n        var addIndex = root.ref.addIndex || null;\n\n        // add index no longer needed till possibly next draw\n        root.ref.addIndex = null;\n\n        var dragIndexOffset = 0;\n        var removeIndexOffset = 0;\n        var addIndexOffset = 0;\n\n        if (children.length === 0) return;\n\n        var childRect = children[0].rect.element;\n        var itemVerticalMargin = childRect.marginTop + childRect.marginBottom;\n        var itemHorizontalMargin = childRect.marginLeft + childRect.marginRight;\n        var itemWidth = childRect.width + itemHorizontalMargin;\n        var itemHeight = childRect.height + itemVerticalMargin;\n        var itemsPerRow = getItemsPerRow(horizontalSpace, itemWidth);\n\n        // stack\n        if (itemsPerRow === 1) {\n            var offsetY = 0;\n            var dragOffset = 0;\n\n            children.forEach(function(child, index) {\n                if (dragIndex) {\n                    var dist = index - dragIndex;\n                    if (dist === -2) {\n                        dragOffset = -itemVerticalMargin * 0.25;\n                    } else if (dist === -1) {\n                        dragOffset = -itemVerticalMargin * 0.75;\n                    } else if (dist === 0) {\n                        dragOffset = itemVerticalMargin * 0.75;\n                    } else if (dist === 1) {\n                        dragOffset = itemVerticalMargin * 0.25;\n                    } else {\n                        dragOffset = 0;\n                    }\n                }\n\n                if (shouldOptimize) {\n                    child.translateX = null;\n                    child.translateY = null;\n                }\n\n                if (!child.markedForRemoval) {\n                    moveItem(child, 0, offsetY + dragOffset);\n                }\n\n                var itemHeight = child.rect.element.height + itemVerticalMargin;\n\n                var visualHeight = itemHeight * (child.markedForRemoval ? child.opacity : 1);\n\n                offsetY += visualHeight;\n            });\n        }\n        // grid\n        else {\n            var prevX = 0;\n            var prevY = 0;\n\n            children.forEach(function(child, index) {\n                if (index === dragIndex) {\n                    dragIndexOffset = 1;\n                }\n\n                if (index === addIndex) {\n                    addIndexOffset += 1;\n                }\n\n                if (child.markedForRemoval && child.opacity < 0.5) {\n                    removeIndexOffset -= 1;\n                }\n\n                var visualIndex = index + addIndexOffset + dragIndexOffset + removeIndexOffset;\n\n                var indexX = visualIndex % itemsPerRow;\n                var indexY = Math.floor(visualIndex / itemsPerRow);\n\n                var offsetX = indexX * itemWidth;\n                var offsetY = indexY * itemHeight;\n\n                var vectorX = Math.sign(offsetX - prevX);\n                var vectorY = Math.sign(offsetY - prevY);\n\n                prevX = offsetX;\n                prevY = offsetY;\n\n                if (child.markedForRemoval) return;\n\n                if (shouldOptimize) {\n                    child.translateX = null;\n                    child.translateY = null;\n                }\n\n                moveItem(child, offsetX, offsetY, vectorX, vectorY);\n            });\n        }\n    };\n\n    /**\n     * Filters actions that are meant specifically for a certain child of the list\n     * @param child\n     * @param actions\n     */\n    var filterSetItemActions = function filterSetItemActions(child, actions) {\n        return actions.filter(function(action) {\n            // if action has an id, filter out actions that don't have this child id\n            if (action.data && action.data.id) {\n                return child.id === action.data.id;\n            }\n\n            // allow all other actions\n            return true;\n        });\n    };\n\n    var list = createView({\n        create: create$8,\n        write: write$5,\n        tag: 'ul',\n        name: 'list',\n        didWriteView: function didWriteView(_ref6) {\n            var root = _ref6.root;\n            root.childViews\n                .filter(function(view) {\n                    return view.markedForRemoval && view.opacity === 0 && view.resting;\n                })\n                .forEach(function(view) {\n                    view._destroy();\n                    root.removeChildView(view);\n                });\n        },\n        filterFrameActionsForChild: filterSetItemActions,\n        mixins: {\n            apis: ['dragCoordinates'],\n        },\n    });\n\n    var create$9 = function create(_ref) {\n        var root = _ref.root,\n            props = _ref.props;\n        root.ref.list = root.appendChildView(root.createChildView(list));\n        props.dragCoordinates = null;\n        props.overflowing = false;\n    };\n\n    var storeDragCoordinates = function storeDragCoordinates(_ref2) {\n        var root = _ref2.root,\n            props = _ref2.props,\n            action = _ref2.action;\n        if (!root.query('GET_ITEM_INSERT_LOCATION_FREEDOM')) return;\n        props.dragCoordinates = {\n            left: action.position.scopeLeft - root.ref.list.rect.element.left,\n            top:\n                action.position.scopeTop -\n                (root.rect.outer.top + root.rect.element.marginTop + root.rect.element.scrollTop),\n        };\n    };\n\n    var clearDragCoordinates = function clearDragCoordinates(_ref3) {\n        var props = _ref3.props;\n        props.dragCoordinates = null;\n    };\n\n    var route$3 = createRoute({\n        DID_DRAG: storeDragCoordinates,\n        DID_END_DRAG: clearDragCoordinates,\n    });\n\n    var write$6 = function write(_ref4) {\n        var root = _ref4.root,\n            props = _ref4.props,\n            actions = _ref4.actions;\n\n        // route actions\n        route$3({ root: root, props: props, actions: actions });\n\n        // current drag position\n        root.ref.list.dragCoordinates = props.dragCoordinates;\n\n        // if currently overflowing but no longer received overflow\n        if (props.overflowing && !props.overflow) {\n            props.overflowing = false;\n\n            // reset overflow state\n            root.element.dataset.state = '';\n            root.height = null;\n        }\n\n        // if is not overflowing currently but does receive overflow value\n        if (props.overflow) {\n            var newHeight = Math.round(props.overflow);\n            if (newHeight !== root.height) {\n                props.overflowing = true;\n                root.element.dataset.state = 'overflow';\n                root.height = newHeight;\n            }\n        }\n    };\n\n    var listScroller = createView({\n        create: create$9,\n        write: write$6,\n        name: 'list-scroller',\n        mixins: {\n            apis: ['overflow', 'dragCoordinates'],\n            styles: ['height', 'translateY'],\n            animations: {\n                translateY: 'spring',\n            },\n        },\n    });\n\n    var attrToggle = function attrToggle(element, name, state) {\n        var enabledValue = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';\n        if (state) {\n            attr(element, name, enabledValue);\n        } else {\n            element.removeAttribute(name);\n        }\n    };\n\n    var resetFileInput = function resetFileInput(input) {\n        // no value, no need to reset\n        if (!input || input.value === '') {\n            return;\n        }\n\n        try {\n            // for modern browsers\n            input.value = '';\n        } catch (err) {}\n\n        // for IE10\n        if (input.value) {\n            // quickly append input to temp form and reset form\n            var form = createElement$1('form');\n            var parentNode = input.parentNode;\n            var ref = input.nextSibling;\n            form.appendChild(input);\n            form.reset();\n\n            // re-inject input where it originally was\n            if (ref) {\n                parentNode.insertBefore(input, ref);\n            } else {\n                parentNode.appendChild(input);\n            }\n        }\n    };\n\n    var create$a = function create(_ref) {\n        var root = _ref.root,\n            props = _ref.props;\n\n        // set id so can be referenced from outside labels\n        root.element.id = 'filepond--browser-' + props.id;\n\n        // set name of element (is removed when a value is set)\n        attr(root.element, 'name', root.query('GET_NAME'));\n\n        // we have to link this element to the status element\n        attr(root.element, 'aria-controls', 'filepond--assistant-' + props.id);\n\n        // set label, we use labelled by as otherwise the screenreader does not read the \"browse\" text in the label (as it has tabindex: 0)\n        attr(root.element, 'aria-labelledby', 'filepond--drop-label-' + props.id);\n\n        // set configurable props\n        setAcceptedFileTypes({\n            root: root,\n            action: { value: root.query('GET_ACCEPTED_FILE_TYPES') },\n        });\n        toggleAllowMultiple({ root: root, action: { value: root.query('GET_ALLOW_MULTIPLE') } });\n        toggleDirectoryFilter({\n            root: root,\n            action: { value: root.query('GET_ALLOW_DIRECTORIES_ONLY') },\n        });\n        toggleDisabled({ root: root });\n        toggleRequired({ root: root, action: { value: root.query('GET_REQUIRED') } });\n        setCaptureMethod({ root: root, action: { value: root.query('GET_CAPTURE_METHOD') } });\n\n        // handle changes to the input field\n        root.ref.handleChange = function(e) {\n            if (!root.element.value) {\n                return;\n            }\n\n            // extract files and move value of webkitRelativePath path to _relativePath\n            var files = Array.from(root.element.files).map(function(file) {\n                file._relativePath = file.webkitRelativePath;\n                return file;\n            });\n\n            // we add a little delay so the OS file select window can move out of the way before we add our file\n            setTimeout(function() {\n                // load files\n                props.onload(files);\n\n                // reset input, it's just for exposing a method to drop files, should not retain any state\n                resetFileInput(root.element);\n            }, 250);\n        };\n\n        root.element.addEventListener('change', root.ref.handleChange);\n    };\n\n    var setAcceptedFileTypes = function setAcceptedFileTypes(_ref2) {\n        var root = _ref2.root,\n            action = _ref2.action;\n        if (!root.query('GET_ALLOW_SYNC_ACCEPT_ATTRIBUTE')) return;\n        attrToggle(\n            root.element,\n            'accept',\n            !!action.value,\n            action.value ? action.value.join(',') : ''\n        );\n    };\n\n    var toggleAllowMultiple = function toggleAllowMultiple(_ref3) {\n        var root = _ref3.root,\n            action = _ref3.action;\n        attrToggle(root.element, 'multiple', action.value);\n    };\n\n    var toggleDirectoryFilter = function toggleDirectoryFilter(_ref4) {\n        var root = _ref4.root,\n            action = _ref4.action;\n        attrToggle(root.element, 'webkitdirectory', action.value);\n    };\n\n    var toggleDisabled = function toggleDisabled(_ref5) {\n        var root = _ref5.root;\n        var isDisabled = root.query('GET_DISABLED');\n        var doesAllowBrowse = root.query('GET_ALLOW_BROWSE');\n        var disableField = isDisabled || !doesAllowBrowse;\n        attrToggle(root.element, 'disabled', disableField);\n    };\n\n    var toggleRequired = function toggleRequired(_ref6) {\n        var root = _ref6.root,\n            action = _ref6.action;\n        // want to remove required, always possible\n        if (!action.value) {\n            attrToggle(root.element, 'required', false);\n        }\n        // if want to make required, only possible when zero items\n        else if (root.query('GET_TOTAL_ITEMS') === 0) {\n            attrToggle(root.element, 'required', true);\n        }\n    };\n\n    var setCaptureMethod = function setCaptureMethod(_ref7) {\n        var root = _ref7.root,\n            action = _ref7.action;\n        attrToggle(\n            root.element,\n            'capture',\n            !!action.value,\n            action.value === true ? '' : action.value\n        );\n    };\n\n    var updateRequiredStatus = function updateRequiredStatus(_ref8) {\n        var root = _ref8.root;\n        var element = root.element;\n        // always remove the required attribute when more than zero items\n        if (root.query('GET_TOTAL_ITEMS') > 0) {\n            attrToggle(element, 'required', false);\n            attrToggle(element, 'name', false);\n        } else {\n            // add name attribute\n            attrToggle(element, 'name', true, root.query('GET_NAME'));\n\n            // remove any validation messages\n            var shouldCheckValidity = root.query('GET_CHECK_VALIDITY');\n            if (shouldCheckValidity) {\n                element.setCustomValidity('');\n            }\n\n            // we only add required if the field has been deemed required\n            if (root.query('GET_REQUIRED')) {\n                attrToggle(element, 'required', true);\n            }\n        }\n    };\n\n    var updateFieldValidityStatus = function updateFieldValidityStatus(_ref9) {\n        var root = _ref9.root;\n        var shouldCheckValidity = root.query('GET_CHECK_VALIDITY');\n        if (!shouldCheckValidity) return;\n        root.element.setCustomValidity(root.query('GET_LABEL_INVALID_FIELD'));\n    };\n\n    var browser = createView({\n        tag: 'input',\n        name: 'browser',\n        ignoreRect: true,\n        ignoreRectUpdate: true,\n        attributes: {\n            type: 'file',\n        },\n\n        create: create$a,\n        destroy: function destroy(_ref10) {\n            var root = _ref10.root;\n            root.element.removeEventListener('change', root.ref.handleChange);\n        },\n        write: createRoute({\n            DID_LOAD_ITEM: updateRequiredStatus,\n            DID_REMOVE_ITEM: updateRequiredStatus,\n            DID_THROW_ITEM_INVALID: updateFieldValidityStatus,\n\n            DID_SET_DISABLED: toggleDisabled,\n            DID_SET_ALLOW_BROWSE: toggleDisabled,\n            DID_SET_ALLOW_DIRECTORIES_ONLY: toggleDirectoryFilter,\n            DID_SET_ALLOW_MULTIPLE: toggleAllowMultiple,\n            DID_SET_ACCEPTED_FILE_TYPES: setAcceptedFileTypes,\n            DID_SET_CAPTURE_METHOD: setCaptureMethod,\n            DID_SET_REQUIRED: toggleRequired,\n        }),\n    });\n\n    var Key = {\n        ENTER: 13,\n        SPACE: 32,\n    };\n\n    var create$b = function create(_ref) {\n        var root = _ref.root,\n            props = _ref.props;\n\n        // create the label and link it to the file browser\n        var label = createElement$1('label');\n        attr(label, 'for', 'filepond--browser-' + props.id);\n\n        // use for labeling file input (aria-labelledby on file input)\n        attr(label, 'id', 'filepond--drop-label-' + props.id);\n\n        // hide the label for screenreaders, the input element will read the contents of the label when it's focussed. If we don't set aria-hidden the screenreader will also navigate the contents of the label separately from the input.\n        attr(label, 'aria-hidden', 'true');\n\n        // handle keys\n        root.ref.handleKeyDown = function(e) {\n            var isActivationKey = e.keyCode === Key.ENTER || e.keyCode === Key.SPACE;\n            if (!isActivationKey) return;\n            // stops from triggering the element a second time\n            e.preventDefault();\n\n            // click link (will then in turn activate file input)\n            root.ref.label.click();\n        };\n\n        root.ref.handleClick = function(e) {\n            var isLabelClick = e.target === label || label.contains(e.target);\n\n            // don't want to click twice\n            if (isLabelClick) return;\n\n            // click link (will then in turn activate file input)\n            root.ref.label.click();\n        };\n\n        // attach events\n        label.addEventListener('keydown', root.ref.handleKeyDown);\n        root.element.addEventListener('click', root.ref.handleClick);\n\n        // update\n        updateLabelValue(label, props.caption);\n\n        // add!\n        root.appendChild(label);\n        root.ref.label = label;\n    };\n\n    var updateLabelValue = function updateLabelValue(label, value) {\n        label.innerHTML = value;\n        var clickable = label.querySelector('.filepond--label-action');\n        if (clickable) {\n            attr(clickable, 'tabindex', '0');\n        }\n        return value;\n    };\n\n    var dropLabel = createView({\n        name: 'drop-label',\n        ignoreRect: true,\n        create: create$b,\n        destroy: function destroy(_ref2) {\n            var root = _ref2.root;\n            root.ref.label.addEventListener('keydown', root.ref.handleKeyDown);\n            root.element.removeEventListener('click', root.ref.handleClick);\n        },\n        write: createRoute({\n            DID_SET_LABEL_IDLE: function DID_SET_LABEL_IDLE(_ref3) {\n                var root = _ref3.root,\n                    action = _ref3.action;\n                updateLabelValue(root.ref.label, action.value);\n            },\n        }),\n\n        mixins: {\n            styles: ['opacity', 'translateX', 'translateY'],\n            animations: {\n                opacity: { type: 'tween', duration: 150 },\n                translateX: 'spring',\n                translateY: 'spring',\n            },\n        },\n    });\n\n    var blob = createView({\n        name: 'drip-blob',\n        ignoreRect: true,\n        mixins: {\n            styles: ['translateX', 'translateY', 'scaleX', 'scaleY', 'opacity'],\n            animations: {\n                scaleX: 'spring',\n                scaleY: 'spring',\n                translateX: 'spring',\n                translateY: 'spring',\n                opacity: { type: 'tween', duration: 250 },\n            },\n        },\n    });\n\n    var addBlob = function addBlob(_ref) {\n        var root = _ref.root;\n        var centerX = root.rect.element.width * 0.5;\n        var centerY = root.rect.element.height * 0.5;\n\n        root.ref.blob = root.appendChildView(\n            root.createChildView(blob, {\n                opacity: 0,\n                scaleX: 2.5,\n                scaleY: 2.5,\n                translateX: centerX,\n                translateY: centerY,\n            })\n        );\n    };\n\n    var moveBlob = function moveBlob(_ref2) {\n        var root = _ref2.root,\n            action = _ref2.action;\n        if (!root.ref.blob) {\n            addBlob({ root: root });\n            return;\n        }\n\n        root.ref.blob.translateX = action.position.scopeLeft;\n        root.ref.blob.translateY = action.position.scopeTop;\n        root.ref.blob.scaleX = 1;\n        root.ref.blob.scaleY = 1;\n        root.ref.blob.opacity = 1;\n    };\n\n    var hideBlob = function hideBlob(_ref3) {\n        var root = _ref3.root;\n        if (!root.ref.blob) {\n            return;\n        }\n        root.ref.blob.opacity = 0;\n    };\n\n    var explodeBlob = function explodeBlob(_ref4) {\n        var root = _ref4.root;\n        if (!root.ref.blob) {\n            return;\n        }\n        root.ref.blob.scaleX = 2.5;\n        root.ref.blob.scaleY = 2.5;\n        root.ref.blob.opacity = 0;\n    };\n\n    var write$7 = function write(_ref5) {\n        var root = _ref5.root,\n            props = _ref5.props,\n            actions = _ref5.actions;\n        route$4({ root: root, props: props, actions: actions });\n        var blob = root.ref.blob;\n\n        if (actions.length === 0 && blob && blob.opacity === 0) {\n            root.removeChildView(blob);\n            root.ref.blob = null;\n        }\n    };\n\n    var route$4 = createRoute({\n        DID_DRAG: moveBlob,\n        DID_DROP: explodeBlob,\n        DID_END_DRAG: hideBlob,\n    });\n\n    var drip = createView({\n        ignoreRect: true,\n        ignoreRectUpdate: true,\n        name: 'drip',\n        write: write$7,\n    });\n\n    var setInputFiles = function setInputFiles(element, files) {\n        try {\n            // Create a DataTransfer instance and add a newly created file\n            var dataTransfer = new DataTransfer();\n            files.forEach(function(file) {\n                if (file instanceof File) {\n                    dataTransfer.items.add(file);\n                } else {\n                    dataTransfer.items.add(\n                        new File([file], file.name, {\n                            type: file.type,\n                        })\n                    );\n                }\n            });\n\n            // Assign the DataTransfer files list to the file input\n            element.files = dataTransfer.files;\n        } catch (err) {\n            return false;\n        }\n        return true;\n    };\n\n    var create$c = function create(_ref) {\n        var root = _ref.root;\n        return (root.ref.fields = {});\n    };\n\n    var getField = function getField(root, id) {\n        return root.ref.fields[id];\n    };\n\n    var syncFieldPositionsWithItems = function syncFieldPositionsWithItems(root) {\n        root.query('GET_ACTIVE_ITEMS').forEach(function(item) {\n            if (!root.ref.fields[item.id]) return;\n            root.element.appendChild(root.ref.fields[item.id]);\n        });\n    };\n\n    var didReorderItems = function didReorderItems(_ref2) {\n        var root = _ref2.root;\n        return syncFieldPositionsWithItems(root);\n    };\n\n    var didAddItem = function didAddItem(_ref3) {\n        var root = _ref3.root,\n            action = _ref3.action;\n        var fileItem = root.query('GET_ITEM', action.id);\n        var isLocalFile = fileItem.origin === FileOrigin.LOCAL;\n        var shouldUseFileInput = !isLocalFile && root.query('SHOULD_UPDATE_FILE_INPUT');\n        var dataContainer = createElement$1('input');\n        dataContainer.type = shouldUseFileInput ? 'file' : 'hidden';\n        dataContainer.name = root.query('GET_NAME');\n        dataContainer.disabled = root.query('GET_DISABLED');\n        root.ref.fields[action.id] = dataContainer;\n        syncFieldPositionsWithItems(root);\n    };\n\n    var didLoadItem$1 = function didLoadItem(_ref4) {\n        var root = _ref4.root,\n            action = _ref4.action;\n        var field = getField(root, action.id);\n        if (!field) return;\n\n        // store server ref in hidden input\n        if (action.serverFileReference !== null) field.value = action.serverFileReference;\n\n        // store file item in file input\n        if (!root.query('SHOULD_UPDATE_FILE_INPUT')) return;\n\n        var fileItem = root.query('GET_ITEM', action.id);\n        setInputFiles(field, [fileItem.file]);\n    };\n\n    var didPrepareOutput = function didPrepareOutput(_ref5) {\n        var root = _ref5.root,\n            action = _ref5.action;\n        // this timeout pushes the handler after 'load'\n        if (!root.query('SHOULD_UPDATE_FILE_INPUT')) return;\n        setTimeout(function() {\n            var field = getField(root, action.id);\n            if (!field) return;\n            setInputFiles(field, [action.file]);\n        }, 0);\n    };\n\n    var didSetDisabled = function didSetDisabled(_ref6) {\n        var root = _ref6.root;\n        root.element.disabled = root.query('GET_DISABLED');\n    };\n\n    var didRemoveItem = function didRemoveItem(_ref7) {\n        var root = _ref7.root,\n            action = _ref7.action;\n        var field = getField(root, action.id);\n        if (!field) return;\n        if (field.parentNode) field.parentNode.removeChild(field);\n        delete root.ref.fields[action.id];\n    };\n\n    // only runs for server files (so doesn't deal with file input)\n    var didDefineValue = function didDefineValue(_ref8) {\n        var root = _ref8.root,\n            action = _ref8.action;\n        var field = getField(root, action.id);\n        if (!field) return;\n        if (action.value === null) {\n            // clear field value\n            field.removeAttribute('value');\n        } else {\n            // set field value\n            field.value = action.value;\n        }\n        syncFieldPositionsWithItems(root);\n    };\n\n    var write$8 = createRoute({\n        DID_SET_DISABLED: didSetDisabled,\n        DID_ADD_ITEM: didAddItem,\n        DID_LOAD_ITEM: didLoadItem$1,\n        DID_REMOVE_ITEM: didRemoveItem,\n        DID_DEFINE_VALUE: didDefineValue,\n        DID_PREPARE_OUTPUT: didPrepareOutput,\n        DID_REORDER_ITEMS: didReorderItems,\n        DID_SORT_ITEMS: didReorderItems,\n    });\n\n    var data = createView({\n        tag: 'fieldset',\n        name: 'data',\n        create: create$c,\n        write: write$8,\n        ignoreRect: true,\n    });\n\n    var getRootNode = function getRootNode(element) {\n        return 'getRootNode' in element ? element.getRootNode() : document;\n    };\n\n    var images = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'svg', 'tiff'];\n    var text$1 = ['css', 'csv', 'html', 'txt'];\n    var map = {\n        zip: 'zip|compressed',\n        epub: 'application/epub+zip',\n    };\n\n    var guesstimateMimeType = function guesstimateMimeType() {\n        var extension = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n        extension = extension.toLowerCase();\n        if (images.includes(extension)) {\n            return (\n                'image/' +\n                (extension === 'jpg' ? 'jpeg' : extension === 'svg' ? 'svg+xml' : extension)\n            );\n        }\n        if (text$1.includes(extension)) {\n            return 'text/' + extension;\n        }\n\n        return map[extension] || '';\n    };\n\n    var requestDataTransferItems = function requestDataTransferItems(dataTransfer) {\n        return new Promise(function(resolve, reject) {\n            // try to get links from transfer, if found we'll exit immediately (unless a file is in the dataTransfer as well, this is because Firefox could represent the file as a URL and a file object at the same time)\n            var links = getLinks(dataTransfer);\n            if (links.length && !hasFiles(dataTransfer)) {\n                return resolve(links);\n            }\n            // try to get files from the transfer\n            getFiles(dataTransfer).then(resolve);\n        });\n    };\n\n    /**\n     * Test if datatransfer has files\n     */\n    var hasFiles = function hasFiles(dataTransfer) {\n        if (dataTransfer.files) return dataTransfer.files.length > 0;\n        return false;\n    };\n\n    /**\n     * Extracts files from a DataTransfer object\n     */\n    var getFiles = function getFiles(dataTransfer) {\n        return new Promise(function(resolve, reject) {\n            // get the transfer items as promises\n            var promisedFiles = (dataTransfer.items ? Array.from(dataTransfer.items) : [])\n                // only keep file system items (files and directories)\n                .filter(function(item) {\n                    return isFileSystemItem(item);\n                })\n\n                // map each item to promise\n                .map(function(item) {\n                    return getFilesFromItem(item);\n                });\n\n            // if is empty, see if we can extract some info from the files property as a fallback\n            if (!promisedFiles.length) {\n                // TODO: test for directories (should not be allowed)\n                // Use FileReader, problem is that the files property gets lost in the process\n                resolve(dataTransfer.files ? Array.from(dataTransfer.files) : []);\n                return;\n            }\n\n            // done!\n            Promise.all(promisedFiles)\n                .then(function(returnedFileGroups) {\n                    // flatten groups\n                    var files = [];\n                    returnedFileGroups.forEach(function(group) {\n                        files.push.apply(files, group);\n                    });\n\n                    // done (filter out empty files)!\n                    resolve(\n                        files\n                            .filter(function(file) {\n                                return file;\n                            })\n                            .map(function(file) {\n                                if (!file._relativePath)\n                                    file._relativePath = file.webkitRelativePath;\n                                return file;\n                            })\n                    );\n                })\n                .catch(console.error);\n        });\n    };\n\n    var isFileSystemItem = function isFileSystemItem(item) {\n        if (isEntry(item)) {\n            var entry = getAsEntry(item);\n            if (entry) {\n                return entry.isFile || entry.isDirectory;\n            }\n        }\n        return item.kind === 'file';\n    };\n\n    var getFilesFromItem = function getFilesFromItem(item) {\n        return new Promise(function(resolve, reject) {\n            if (isDirectoryEntry(item)) {\n                getFilesInDirectory(getAsEntry(item))\n                    .then(resolve)\n                    .catch(reject);\n                return;\n            }\n\n            resolve([item.getAsFile()]);\n        });\n    };\n\n    var getFilesInDirectory = function getFilesInDirectory(entry) {\n        return new Promise(function(resolve, reject) {\n            var files = [];\n\n            // the total entries to read\n            var dirCounter = 0;\n            var fileCounter = 0;\n\n            var resolveIfDone = function resolveIfDone() {\n                if (fileCounter === 0 && dirCounter === 0) {\n                    resolve(files);\n                }\n            };\n\n            // the recursive function\n            var readEntries = function readEntries(dirEntry) {\n                dirCounter++;\n\n                var directoryReader = dirEntry.createReader();\n\n                // directories are returned in batches, we need to process all batches before we're done\n                var readBatch = function readBatch() {\n                    directoryReader.readEntries(function(entries) {\n                        if (entries.length === 0) {\n                            dirCounter--;\n                            resolveIfDone();\n                            return;\n                        }\n\n                        entries.forEach(function(entry) {\n                            // recursively read more directories\n                            if (entry.isDirectory) {\n                                readEntries(entry);\n                            } else {\n                                // read as file\n                                fileCounter++;\n\n                                entry.file(function(file) {\n                                    var correctedFile = correctMissingFileType(file);\n                                    if (entry.fullPath)\n                                        correctedFile._relativePath = entry.fullPath;\n                                    files.push(correctedFile);\n                                    fileCounter--;\n                                    resolveIfDone();\n                                });\n                            }\n                        });\n\n                        // try to get next batch of files\n                        readBatch();\n                    }, reject);\n                };\n\n                // read first batch of files\n                readBatch();\n            };\n\n            // go!\n            readEntries(entry);\n        });\n    };\n\n    var correctMissingFileType = function correctMissingFileType(file) {\n        if (file.type.length) return file;\n        var date = file.lastModifiedDate;\n        var name = file.name;\n        var type = guesstimateMimeType(getExtensionFromFilename(file.name));\n        if (!type.length) return file;\n        file = file.slice(0, file.size, type);\n        file.name = name;\n        file.lastModifiedDate = date;\n        return file;\n    };\n\n    var isDirectoryEntry = function isDirectoryEntry(item) {\n        return isEntry(item) && (getAsEntry(item) || {}).isDirectory;\n    };\n\n    var isEntry = function isEntry(item) {\n        return 'webkitGetAsEntry' in item;\n    };\n\n    var getAsEntry = function getAsEntry(item) {\n        return item.webkitGetAsEntry();\n    };\n\n    /**\n     * Extracts links from a DataTransfer object\n     */\n    var getLinks = function getLinks(dataTransfer) {\n        var links = [];\n        try {\n            // look in meta data property\n            links = getLinksFromTransferMetaData(dataTransfer);\n            if (links.length) {\n                return links;\n            }\n            links = getLinksFromTransferURLData(dataTransfer);\n        } catch (e) {\n            // nope nope nope (probably IE trouble)\n        }\n        return links;\n    };\n\n    var getLinksFromTransferURLData = function getLinksFromTransferURLData(dataTransfer) {\n        var data = dataTransfer.getData('url');\n        if (typeof data === 'string' && data.length) {\n            return [data];\n        }\n        return [];\n    };\n\n    var getLinksFromTransferMetaData = function getLinksFromTransferMetaData(dataTransfer) {\n        var data = dataTransfer.getData('text/html');\n        if (typeof data === 'string' && data.length) {\n            var matches = data.match(/src\\s*=\\s*\"(.+?)\"/);\n            if (matches) {\n                return [matches[1]];\n            }\n        }\n        return [];\n    };\n\n    var dragNDropObservers = [];\n\n    var eventPosition = function eventPosition(e) {\n        return {\n            pageLeft: e.pageX,\n            pageTop: e.pageY,\n            scopeLeft: e.offsetX || e.layerX,\n            scopeTop: e.offsetY || e.layerY,\n        };\n    };\n\n    var createDragNDropClient = function createDragNDropClient(\n        element,\n        scopeToObserve,\n        filterElement\n    ) {\n        var observer = getDragNDropObserver(scopeToObserve);\n\n        var client = {\n            element: element,\n            filterElement: filterElement,\n            state: null,\n            ondrop: function ondrop() {},\n            onenter: function onenter() {},\n            ondrag: function ondrag() {},\n            onexit: function onexit() {},\n            onload: function onload() {},\n            allowdrop: function allowdrop() {},\n        };\n\n        client.destroy = observer.addListener(client);\n\n        return client;\n    };\n\n    var getDragNDropObserver = function getDragNDropObserver(element) {\n        // see if already exists, if so, return\n        var observer = dragNDropObservers.find(function(item) {\n            return item.element === element;\n        });\n        if (observer) {\n            return observer;\n        }\n\n        // create new observer, does not yet exist for this element\n        var newObserver = createDragNDropObserver(element);\n        dragNDropObservers.push(newObserver);\n        return newObserver;\n    };\n\n    var createDragNDropObserver = function createDragNDropObserver(element) {\n        var clients = [];\n\n        var routes = {\n            dragenter: dragenter,\n            dragover: dragover,\n            dragleave: dragleave,\n            drop: drop,\n        };\n\n        var handlers = {};\n\n        forin(routes, function(event, createHandler) {\n            handlers[event] = createHandler(element, clients);\n            element.addEventListener(event, handlers[event], false);\n        });\n\n        var observer = {\n            element: element,\n            addListener: function addListener(client) {\n                // add as client\n                clients.push(client);\n\n                // return removeListener function\n                return function() {\n                    // remove client\n                    clients.splice(clients.indexOf(client), 1);\n\n                    // if no more clients, clean up observer\n                    if (clients.length === 0) {\n                        dragNDropObservers.splice(dragNDropObservers.indexOf(observer), 1);\n\n                        forin(routes, function(event) {\n                            element.removeEventListener(event, handlers[event], false);\n                        });\n                    }\n                };\n            },\n        };\n\n        return observer;\n    };\n\n    var elementFromPoint = function elementFromPoint(root, point) {\n        if (!('elementFromPoint' in root)) {\n            root = document;\n        }\n        return root.elementFromPoint(point.x, point.y);\n    };\n\n    var isEventTarget = function isEventTarget(e, target) {\n        // get root\n        var root = getRootNode(target);\n\n        // get element at position\n        // if root is not actual shadow DOM and does not have elementFromPoint method, use the one on document\n        var elementAtPosition = elementFromPoint(root, {\n            x: e.pageX - window.pageXOffset,\n            y: e.pageY - window.pageYOffset,\n        });\n\n        // test if target is the element or if one of its children is\n        return elementAtPosition === target || target.contains(elementAtPosition);\n    };\n\n    var initialTarget = null;\n\n    var setDropEffect = function setDropEffect(dataTransfer, effect) {\n        // is in try catch as IE11 will throw error if not\n        try {\n            dataTransfer.dropEffect = effect;\n        } catch (e) {}\n    };\n\n    var dragenter = function dragenter(root, clients) {\n        return function(e) {\n            e.preventDefault();\n\n            initialTarget = e.target;\n\n            clients.forEach(function(client) {\n                var element = client.element,\n                    onenter = client.onenter;\n\n                if (isEventTarget(e, element)) {\n                    client.state = 'enter';\n\n                    // fire enter event\n                    onenter(eventPosition(e));\n                }\n            });\n        };\n    };\n\n    var dragover = function dragover(root, clients) {\n        return function(e) {\n            e.preventDefault();\n\n            var dataTransfer = e.dataTransfer;\n\n            requestDataTransferItems(dataTransfer).then(function(items) {\n                var overDropTarget = false;\n\n                clients.some(function(client) {\n                    var filterElement = client.filterElement,\n                        element = client.element,\n                        onenter = client.onenter,\n                        onexit = client.onexit,\n                        ondrag = client.ondrag,\n                        allowdrop = client.allowdrop;\n\n                    // by default we can drop\n                    setDropEffect(dataTransfer, 'copy');\n\n                    // allow transfer of these items\n                    var allowsTransfer = allowdrop(items);\n\n                    // only used when can be dropped on page\n                    if (!allowsTransfer) {\n                        setDropEffect(dataTransfer, 'none');\n                        return;\n                    }\n\n                    // targetting this client\n                    if (isEventTarget(e, element)) {\n                        overDropTarget = true;\n\n                        // had no previous state, means we are entering this client\n                        if (client.state === null) {\n                            client.state = 'enter';\n                            onenter(eventPosition(e));\n                            return;\n                        }\n\n                        // now over element (no matter if it allows the drop or not)\n                        client.state = 'over';\n\n                        // needs to allow transfer\n                        if (filterElement && !allowsTransfer) {\n                            setDropEffect(dataTransfer, 'none');\n                            return;\n                        }\n\n                        // dragging\n                        ondrag(eventPosition(e));\n                    } else {\n                        // should be over an element to drop\n                        if (filterElement && !overDropTarget) {\n                            setDropEffect(dataTransfer, 'none');\n                        }\n\n                        // might have just left this client?\n                        if (client.state) {\n                            client.state = null;\n                            onexit(eventPosition(e));\n                        }\n                    }\n                });\n            });\n        };\n    };\n\n    var drop = function drop(root, clients) {\n        return function(e) {\n            e.preventDefault();\n\n            var dataTransfer = e.dataTransfer;\n\n            requestDataTransferItems(dataTransfer).then(function(items) {\n                clients.forEach(function(client) {\n                    var filterElement = client.filterElement,\n                        element = client.element,\n                        ondrop = client.ondrop,\n                        onexit = client.onexit,\n                        allowdrop = client.allowdrop;\n\n                    client.state = null;\n\n                    // if we're filtering on element we need to be over the element to drop\n                    if (filterElement && !isEventTarget(e, element)) return;\n\n                    // no transfer for this client\n                    if (!allowdrop(items)) return onexit(eventPosition(e));\n\n                    // we can drop these items on this client\n                    ondrop(eventPosition(e), items);\n                });\n            });\n        };\n    };\n\n    var dragleave = function dragleave(root, clients) {\n        return function(e) {\n            if (initialTarget !== e.target) {\n                return;\n            }\n\n            clients.forEach(function(client) {\n                var onexit = client.onexit;\n\n                client.state = null;\n\n                onexit(eventPosition(e));\n            });\n        };\n    };\n\n    var createHopper = function createHopper(scope, validateItems, options) {\n        // is now hopper scope\n        scope.classList.add('filepond--hopper');\n\n        // shortcuts\n        var catchesDropsOnPage = options.catchesDropsOnPage,\n            requiresDropOnElement = options.requiresDropOnElement,\n            _options$filterItems = options.filterItems,\n            filterItems =\n                _options$filterItems === void 0\n                    ? function(items) {\n                          return items;\n                      }\n                    : _options$filterItems;\n\n        // create a dnd client\n        var client = createDragNDropClient(\n            scope,\n            catchesDropsOnPage ? document.documentElement : scope,\n            requiresDropOnElement\n        );\n\n        // current client state\n        var lastState = '';\n        var currentState = '';\n\n        // determines if a file may be dropped\n        client.allowdrop = function(items) {\n            // TODO: if we can, throw error to indicate the items cannot by dropped\n\n            return validateItems(filterItems(items));\n        };\n\n        client.ondrop = function(position, items) {\n            var filteredItems = filterItems(items);\n\n            if (!validateItems(filteredItems)) {\n                api.ondragend(position);\n                return;\n            }\n\n            currentState = 'drag-drop';\n\n            api.onload(filteredItems, position);\n        };\n\n        client.ondrag = function(position) {\n            api.ondrag(position);\n        };\n\n        client.onenter = function(position) {\n            currentState = 'drag-over';\n\n            api.ondragstart(position);\n        };\n\n        client.onexit = function(position) {\n            currentState = 'drag-exit';\n\n            api.ondragend(position);\n        };\n\n        var api = {\n            updateHopperState: function updateHopperState() {\n                if (lastState !== currentState) {\n                    scope.dataset.hopperState = currentState;\n                    lastState = currentState;\n                }\n            },\n            onload: function onload() {},\n            ondragstart: function ondragstart() {},\n            ondrag: function ondrag() {},\n            ondragend: function ondragend() {},\n            destroy: function destroy() {\n                // destroy client\n                client.destroy();\n            },\n        };\n\n        return api;\n    };\n\n    var listening = false;\n    var listeners$1 = [];\n\n    var handlePaste = function handlePaste(e) {\n        // if is pasting in input or textarea and the target is outside of a filepond scope, ignore\n        var activeEl = document.activeElement;\n        if (activeEl && /textarea|input/i.test(activeEl.nodeName)) {\n            // test textarea or input is contained in filepond root\n            var inScope = false;\n            var element = activeEl;\n            while (element !== document.body) {\n                if (element.classList.contains('filepond--root')) {\n                    inScope = true;\n                    break;\n                }\n                element = element.parentNode;\n            }\n\n            if (!inScope) return;\n        }\n\n        requestDataTransferItems(e.clipboardData).then(function(files) {\n            // no files received\n            if (!files.length) {\n                return;\n            }\n\n            // notify listeners of received files\n            listeners$1.forEach(function(listener) {\n                return listener(files);\n            });\n        });\n    };\n\n    var listen = function listen(cb) {\n        // can't add twice\n        if (listeners$1.includes(cb)) {\n            return;\n        }\n\n        // add initial listener\n        listeners$1.push(cb);\n\n        // setup paste listener for entire page\n        if (listening) {\n            return;\n        }\n\n        listening = true;\n        document.addEventListener('paste', handlePaste);\n    };\n\n    var unlisten = function unlisten(listener) {\n        arrayRemove(listeners$1, listeners$1.indexOf(listener));\n\n        // clean up\n        if (listeners$1.length === 0) {\n            document.removeEventListener('paste', handlePaste);\n            listening = false;\n        }\n    };\n\n    var createPaster = function createPaster() {\n        var cb = function cb(files) {\n            api.onload(files);\n        };\n\n        var api = {\n            destroy: function destroy() {\n                unlisten(cb);\n            },\n            onload: function onload() {},\n        };\n\n        listen(cb);\n\n        return api;\n    };\n\n    /**\n     * Creates the file view\n     */\n    var create$d = function create(_ref) {\n        var root = _ref.root,\n            props = _ref.props;\n        root.element.id = 'filepond--assistant-' + props.id;\n        attr(root.element, 'role', 'status');\n        attr(root.element, 'aria-live', 'polite');\n        attr(root.element, 'aria-relevant', 'additions');\n    };\n\n    var addFilesNotificationTimeout = null;\n    var notificationClearTimeout = null;\n\n    var filenames = [];\n\n    var assist = function assist(root, message) {\n        root.element.textContent = message;\n    };\n\n    var clear$1 = function clear(root) {\n        root.element.textContent = '';\n    };\n\n    var listModified = function listModified(root, filename, label) {\n        var total = root.query('GET_TOTAL_ITEMS');\n        assist(\n            root,\n            label +\n                ' ' +\n                filename +\n                ', ' +\n                total +\n                ' ' +\n                (total === 1\n                    ? root.query('GET_LABEL_FILE_COUNT_SINGULAR')\n                    : root.query('GET_LABEL_FILE_COUNT_PLURAL'))\n        );\n\n        // clear group after set amount of time so the status is not read twice\n        clearTimeout(notificationClearTimeout);\n        notificationClearTimeout = setTimeout(function() {\n            clear$1(root);\n        }, 1500);\n    };\n\n    var isUsingFilePond = function isUsingFilePond(root) {\n        return root.element.parentNode.contains(document.activeElement);\n    };\n\n    var itemAdded = function itemAdded(_ref2) {\n        var root = _ref2.root,\n            action = _ref2.action;\n        if (!isUsingFilePond(root)) {\n            return;\n        }\n\n        root.element.textContent = '';\n        var item = root.query('GET_ITEM', action.id);\n        filenames.push(item.filename);\n\n        clearTimeout(addFilesNotificationTimeout);\n        addFilesNotificationTimeout = setTimeout(function() {\n            listModified(root, filenames.join(', '), root.query('GET_LABEL_FILE_ADDED'));\n\n            filenames.length = 0;\n        }, 750);\n    };\n\n    var itemRemoved = function itemRemoved(_ref3) {\n        var root = _ref3.root,\n            action = _ref3.action;\n        if (!isUsingFilePond(root)) {\n            return;\n        }\n\n        var item = action.item;\n        listModified(root, item.filename, root.query('GET_LABEL_FILE_REMOVED'));\n    };\n\n    var itemProcessed = function itemProcessed(_ref4) {\n        var root = _ref4.root,\n            action = _ref4.action;\n        // will also notify the user when FilePond is not being used, as the user might be occupied with other activities while uploading a file\n\n        var item = root.query('GET_ITEM', action.id);\n        var filename = item.filename;\n        var label = root.query('GET_LABEL_FILE_PROCESSING_COMPLETE');\n\n        assist(root, filename + ' ' + label);\n    };\n\n    var itemProcessedUndo = function itemProcessedUndo(_ref5) {\n        var root = _ref5.root,\n            action = _ref5.action;\n        var item = root.query('GET_ITEM', action.id);\n        var filename = item.filename;\n        var label = root.query('GET_LABEL_FILE_PROCESSING_ABORTED');\n\n        assist(root, filename + ' ' + label);\n    };\n\n    var itemError = function itemError(_ref6) {\n        var root = _ref6.root,\n            action = _ref6.action;\n        var item = root.query('GET_ITEM', action.id);\n        var filename = item.filename;\n\n        // will also notify the user when FilePond is not being used, as the user might be occupied with other activities while uploading a file\n\n        assist(root, action.status.main + ' ' + filename + ' ' + action.status.sub);\n    };\n\n    var assistant = createView({\n        create: create$d,\n        ignoreRect: true,\n        ignoreRectUpdate: true,\n        write: createRoute({\n            DID_LOAD_ITEM: itemAdded,\n            DID_REMOVE_ITEM: itemRemoved,\n            DID_COMPLETE_ITEM_PROCESSING: itemProcessed,\n\n            DID_ABORT_ITEM_PROCESSING: itemProcessedUndo,\n            DID_REVERT_ITEM_PROCESSING: itemProcessedUndo,\n\n            DID_THROW_ITEM_REMOVE_ERROR: itemError,\n            DID_THROW_ITEM_LOAD_ERROR: itemError,\n            DID_THROW_ITEM_INVALID: itemError,\n            DID_THROW_ITEM_PROCESSING_ERROR: itemError,\n        }),\n\n        tag: 'span',\n        name: 'assistant',\n    });\n\n    var toCamels = function toCamels(string) {\n        var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '-';\n        return string.replace(new RegExp(separator + '.', 'g'), function(sub) {\n            return sub.charAt(1).toUpperCase();\n        });\n    };\n\n    var debounce = function debounce(func) {\n        var interval = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 16;\n        var immidiateOnly =\n            arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n        var last = Date.now();\n        var timeout = null;\n\n        return function() {\n            for (\n                var _len = arguments.length, args = new Array(_len), _key = 0;\n                _key < _len;\n                _key++\n            ) {\n                args[_key] = arguments[_key];\n            }\n            clearTimeout(timeout);\n\n            var dist = Date.now() - last;\n\n            var fn = function fn() {\n                last = Date.now();\n                func.apply(void 0, args);\n            };\n\n            if (dist < interval) {\n                // we need to delay by the difference between interval and dist\n                // for example: if distance is 10 ms and interval is 16 ms,\n                // we need to wait an additional 6ms before calling the function)\n                if (!immidiateOnly) {\n                    timeout = setTimeout(fn, interval - dist);\n                }\n            } else {\n                // go!\n                fn();\n            }\n        };\n    };\n\n    var MAX_FILES_LIMIT = 1000000;\n\n    var prevent = function prevent(e) {\n        return e.preventDefault();\n    };\n\n    var create$e = function create(_ref) {\n        var root = _ref.root,\n            props = _ref.props;\n        // Add id\n        var id = root.query('GET_ID');\n        if (id) {\n            root.element.id = id;\n        }\n\n        // Add className\n        var className = root.query('GET_CLASS_NAME');\n        if (className) {\n            className\n                .split(' ')\n                .filter(function(name) {\n                    return name.length;\n                })\n                .forEach(function(name) {\n                    root.element.classList.add(name);\n                });\n        }\n\n        // Field label\n        root.ref.label = root.appendChildView(\n            root.createChildView(\n                dropLabel,\n                Object.assign({}, props, {\n                    translateY: null,\n                    caption: root.query('GET_LABEL_IDLE'),\n                })\n            )\n        );\n\n        // List of items\n        root.ref.list = root.appendChildView(\n            root.createChildView(listScroller, { translateY: null })\n        );\n\n        // Background panel\n        root.ref.panel = root.appendChildView(root.createChildView(panel, { name: 'panel-root' }));\n\n        // Assistant notifies assistive tech when content changes\n        root.ref.assistant = root.appendChildView(\n            root.createChildView(assistant, Object.assign({}, props))\n        );\n\n        // Data\n        root.ref.data = root.appendChildView(root.createChildView(data, Object.assign({}, props)));\n\n        // Measure (tests if fixed height was set)\n        // DOCTYPE needs to be set for this to work\n        root.ref.measure = createElement$1('div');\n        root.ref.measure.style.height = '100%';\n        root.element.appendChild(root.ref.measure);\n\n        // information on the root height or fixed height status\n        root.ref.bounds = null;\n\n        // apply initial style properties\n        root.query('GET_STYLES')\n            .filter(function(style) {\n                return !isEmpty(style.value);\n            })\n            .map(function(_ref2) {\n                var name = _ref2.name,\n                    value = _ref2.value;\n                root.element.dataset[name] = value;\n            });\n\n        // determine if width changed\n        root.ref.widthPrevious = null;\n        root.ref.widthUpdated = debounce(function() {\n            root.ref.updateHistory = [];\n            root.dispatch('DID_RESIZE_ROOT');\n        }, 250);\n\n        // history of updates\n        root.ref.previousAspectRatio = null;\n        root.ref.updateHistory = [];\n\n        // prevent scrolling and zooming on iOS (only if supports pointer events, for then we can enable reorder)\n        var canHover = window.matchMedia('(pointer: fine) and (hover: hover)').matches;\n        var hasPointerEvents = 'PointerEvent' in window;\n        if (root.query('GET_ALLOW_REORDER') && hasPointerEvents && !canHover) {\n            root.element.addEventListener('touchmove', prevent, { passive: false });\n            root.element.addEventListener('gesturestart', prevent);\n        }\n\n        // add credits\n        var credits = root.query('GET_CREDITS');\n        var hasCredits = credits.length === 2;\n        if (hasCredits) {\n            var frag = document.createElement('a');\n            frag.className = 'filepond--credits';\n            frag.setAttribute('aria-hidden', 'true');\n            frag.href = credits[0];\n            frag.tabindex = -1;\n            frag.target = '_blank';\n            frag.rel = 'noopener noreferrer';\n            frag.textContent = credits[1];\n            root.element.appendChild(frag);\n            root.ref.credits = frag;\n        }\n    };\n\n    var write$9 = function write(_ref3) {\n        var root = _ref3.root,\n            props = _ref3.props,\n            actions = _ref3.actions;\n        // route actions\n        route$5({ root: root, props: props, actions: actions });\n\n        // apply style properties\n        actions\n            .filter(function(action) {\n                return /^DID_SET_STYLE_/.test(action.type);\n            })\n            .filter(function(action) {\n                return !isEmpty(action.data.value);\n            })\n            .map(function(_ref4) {\n                var type = _ref4.type,\n                    data = _ref4.data;\n                var name = toCamels(type.substring(8).toLowerCase(), '_');\n                root.element.dataset[name] = data.value;\n                root.invalidateLayout();\n            });\n\n        if (root.rect.element.hidden) return;\n\n        if (root.rect.element.width !== root.ref.widthPrevious) {\n            root.ref.widthPrevious = root.rect.element.width;\n            root.ref.widthUpdated();\n        }\n\n        // get box bounds, we do this only once\n        var bounds = root.ref.bounds;\n        if (!bounds) {\n            bounds = root.ref.bounds = calculateRootBoundingBoxHeight(root);\n\n            // destroy measure element\n            root.element.removeChild(root.ref.measure);\n            root.ref.measure = null;\n        }\n\n        // get quick references to various high level parts of the upload tool\n        var _root$ref = root.ref,\n            hopper = _root$ref.hopper,\n            label = _root$ref.label,\n            list = _root$ref.list,\n            panel = _root$ref.panel;\n\n        // sets correct state to hopper scope\n        if (hopper) {\n            hopper.updateHopperState();\n        }\n\n        // bool to indicate if we're full or not\n        var aspectRatio = root.query('GET_PANEL_ASPECT_RATIO');\n        var isMultiItem = root.query('GET_ALLOW_MULTIPLE');\n        var totalItems = root.query('GET_TOTAL_ITEMS');\n        var maxItems = isMultiItem ? root.query('GET_MAX_FILES') || MAX_FILES_LIMIT : 1;\n        var atMaxCapacity = totalItems === maxItems;\n\n        // action used to add item\n        var addAction = actions.find(function(action) {\n            return action.type === 'DID_ADD_ITEM';\n        });\n\n        // if reached max capacity and we've just reached it\n        if (atMaxCapacity && addAction) {\n            // get interaction type\n            var interactionMethod = addAction.data.interactionMethod;\n\n            // hide label\n            label.opacity = 0;\n\n            if (isMultiItem) {\n                label.translateY = -40;\n            } else {\n                if (interactionMethod === InteractionMethod.API) {\n                    label.translateX = 40;\n                } else if (interactionMethod === InteractionMethod.BROWSE) {\n                    label.translateY = 40;\n                } else {\n                    label.translateY = 30;\n                }\n            }\n        } else if (!atMaxCapacity) {\n            label.opacity = 1;\n            label.translateX = 0;\n            label.translateY = 0;\n        }\n\n        var listItemMargin = calculateListItemMargin(root);\n\n        var listHeight = calculateListHeight(root);\n\n        var labelHeight = label.rect.element.height;\n        var currentLabelHeight = !isMultiItem || atMaxCapacity ? 0 : labelHeight;\n\n        var listMarginTop = atMaxCapacity ? list.rect.element.marginTop : 0;\n        var listMarginBottom = totalItems === 0 ? 0 : list.rect.element.marginBottom;\n\n        var visualHeight =\n            currentLabelHeight + listMarginTop + listHeight.visual + listMarginBottom;\n        var boundsHeight =\n            currentLabelHeight + listMarginTop + listHeight.bounds + listMarginBottom;\n\n        // link list to label bottom position\n        list.translateY =\n            Math.max(0, currentLabelHeight - list.rect.element.marginTop) - listItemMargin.top;\n\n        if (aspectRatio) {\n            // fixed aspect ratio\n\n            // calculate height based on width\n            var width = root.rect.element.width;\n            var height = width * aspectRatio;\n\n            // clear history if aspect ratio has changed\n            if (aspectRatio !== root.ref.previousAspectRatio) {\n                root.ref.previousAspectRatio = aspectRatio;\n                root.ref.updateHistory = [];\n            }\n\n            // remember this width\n            var history = root.ref.updateHistory;\n            history.push(width);\n\n            var MAX_BOUNCES = 2;\n            if (history.length > MAX_BOUNCES * 2) {\n                var l = history.length;\n                var bottom = l - 10;\n                var bounces = 0;\n                for (var i = l; i >= bottom; i--) {\n                    if (history[i] === history[i - 2]) {\n                        bounces++;\n                    }\n\n                    if (bounces >= MAX_BOUNCES) {\n                        // dont adjust height\n                        return;\n                    }\n                }\n            }\n\n            // fix height of panel so it adheres to aspect ratio\n            panel.scalable = false;\n            panel.height = height;\n\n            // available height for list\n            var listAvailableHeight =\n                // the height of the panel minus the label height\n                height -\n                currentLabelHeight -\n                // the room we leave open between the end of the list and the panel bottom\n                (listMarginBottom - listItemMargin.bottom) -\n                // if we're full we need to leave some room between the top of the panel and the list\n                (atMaxCapacity ? listMarginTop : 0);\n\n            if (listHeight.visual > listAvailableHeight) {\n                list.overflow = listAvailableHeight;\n            } else {\n                list.overflow = null;\n            }\n\n            // set container bounds (so pushes siblings downwards)\n            root.height = height;\n        } else if (bounds.fixedHeight) {\n            // fixed height\n\n            // fix height of panel\n            panel.scalable = false;\n\n            // available height for list\n            var _listAvailableHeight =\n                // the height of the panel minus the label height\n                bounds.fixedHeight -\n                currentLabelHeight -\n                // the room we leave open between the end of the list and the panel bottom\n                (listMarginBottom - listItemMargin.bottom) -\n                // if we're full we need to leave some room between the top of the panel and the list\n                (atMaxCapacity ? listMarginTop : 0);\n\n            // set list height\n            if (listHeight.visual > _listAvailableHeight) {\n                list.overflow = _listAvailableHeight;\n            } else {\n                list.overflow = null;\n            }\n\n            // no need to set container bounds as these are handles by CSS fixed height\n        } else if (bounds.cappedHeight) {\n            // max-height\n\n            // not a fixed height panel\n            var isCappedHeight = visualHeight >= bounds.cappedHeight;\n            var panelHeight = Math.min(bounds.cappedHeight, visualHeight);\n            panel.scalable = true;\n            panel.height = isCappedHeight\n                ? panelHeight\n                : panelHeight - listItemMargin.top - listItemMargin.bottom;\n\n            // available height for list\n            var _listAvailableHeight2 =\n                // the height of the panel minus the label height\n                panelHeight -\n                currentLabelHeight -\n                // the room we leave open between the end of the list and the panel bottom\n                (listMarginBottom - listItemMargin.bottom) -\n                // if we're full we need to leave some room between the top of the panel and the list\n                (atMaxCapacity ? listMarginTop : 0);\n\n            // set list height (if is overflowing)\n            if (visualHeight > bounds.cappedHeight && listHeight.visual > _listAvailableHeight2) {\n                list.overflow = _listAvailableHeight2;\n            } else {\n                list.overflow = null;\n            }\n\n            // set container bounds (so pushes siblings downwards)\n            root.height = Math.min(\n                bounds.cappedHeight,\n                boundsHeight - listItemMargin.top - listItemMargin.bottom\n            );\n        } else {\n            // flexible height\n\n            // not a fixed height panel\n            var itemMargin = totalItems > 0 ? listItemMargin.top + listItemMargin.bottom : 0;\n            panel.scalable = true;\n            panel.height = Math.max(labelHeight, visualHeight - itemMargin);\n\n            // set container bounds (so pushes siblings downwards)\n            root.height = Math.max(labelHeight, boundsHeight - itemMargin);\n        }\n\n        // move credits to bottom\n        if (root.ref.credits && panel.heightCurrent)\n            root.ref.credits.style.transform = 'translateY(' + panel.heightCurrent + 'px)';\n    };\n\n    var calculateListItemMargin = function calculateListItemMargin(root) {\n        var item = root.ref.list.childViews[0].childViews[0];\n        return item\n            ? {\n                  top: item.rect.element.marginTop,\n                  bottom: item.rect.element.marginBottom,\n              }\n            : {\n                  top: 0,\n                  bottom: 0,\n              };\n    };\n\n    var calculateListHeight = function calculateListHeight(root) {\n        var visual = 0;\n        var bounds = 0;\n\n        // get file list reference\n        var scrollList = root.ref.list;\n        var itemList = scrollList.childViews[0];\n        var visibleChildren = itemList.childViews.filter(function(child) {\n            return child.rect.element.height;\n        });\n        var children = root\n            .query('GET_ACTIVE_ITEMS')\n            .map(function(item) {\n                return visibleChildren.find(function(child) {\n                    return child.id === item.id;\n                });\n            })\n            .filter(function(item) {\n                return item;\n            });\n\n        // no children, done!\n        if (children.length === 0) return { visual: visual, bounds: bounds };\n\n        var horizontalSpace = itemList.rect.element.width;\n        var dragIndex = getItemIndexByPosition(itemList, children, scrollList.dragCoordinates);\n\n        var childRect = children[0].rect.element;\n\n        var itemVerticalMargin = childRect.marginTop + childRect.marginBottom;\n        var itemHorizontalMargin = childRect.marginLeft + childRect.marginRight;\n\n        var itemWidth = childRect.width + itemHorizontalMargin;\n        var itemHeight = childRect.height + itemVerticalMargin;\n\n        var newItem = typeof dragIndex !== 'undefined' && dragIndex >= 0 ? 1 : 0;\n        var removedItem = children.find(function(child) {\n            return child.markedForRemoval && child.opacity < 0.45;\n        })\n            ? -1\n            : 0;\n        var verticalItemCount = children.length + newItem + removedItem;\n        var itemsPerRow = getItemsPerRow(horizontalSpace, itemWidth);\n\n        // stack\n        if (itemsPerRow === 1) {\n            children.forEach(function(item) {\n                var height = item.rect.element.height + itemVerticalMargin;\n                bounds += height;\n                visual += height * item.opacity;\n            });\n        }\n        // grid\n        else {\n            bounds = Math.ceil(verticalItemCount / itemsPerRow) * itemHeight;\n            visual = bounds;\n        }\n\n        return { visual: visual, bounds: bounds };\n    };\n\n    var calculateRootBoundingBoxHeight = function calculateRootBoundingBoxHeight(root) {\n        var height = root.ref.measureHeight || null;\n        var cappedHeight = parseInt(root.style.maxHeight, 10) || null;\n        var fixedHeight = height === 0 ? null : height;\n\n        return {\n            cappedHeight: cappedHeight,\n            fixedHeight: fixedHeight,\n        };\n    };\n\n    var exceedsMaxFiles = function exceedsMaxFiles(root, items) {\n        var allowReplace = root.query('GET_ALLOW_REPLACE');\n        var allowMultiple = root.query('GET_ALLOW_MULTIPLE');\n        var totalItems = root.query('GET_TOTAL_ITEMS');\n        var maxItems = root.query('GET_MAX_FILES');\n\n        // total amount of items being dragged\n        var totalBrowseItems = items.length;\n\n        // if does not allow multiple items and dragging more than one item\n        if (!allowMultiple && totalBrowseItems > 1) {\n            root.dispatch('DID_THROW_MAX_FILES', {\n                source: items,\n                error: createResponse('warning', 0, 'Max files'),\n            });\n\n            return true;\n        }\n\n        // limit max items to one if not allowed to drop multiple items\n        maxItems = allowMultiple ? maxItems : 1;\n\n        if (!allowMultiple && allowReplace) {\n            // There is only one item, so there is room to replace or add an item\n            return false;\n        }\n\n        // no more room?\n        var hasMaxItems = isInt(maxItems);\n        if (hasMaxItems && totalItems + totalBrowseItems > maxItems) {\n            root.dispatch('DID_THROW_MAX_FILES', {\n                source: items,\n                error: createResponse('warning', 0, 'Max files'),\n            });\n\n            return true;\n        }\n\n        return false;\n    };\n\n    var getDragIndex = function getDragIndex(list, children, position) {\n        var itemList = list.childViews[0];\n        return getItemIndexByPosition(itemList, children, {\n            left: position.scopeLeft - itemList.rect.element.left,\n            top:\n                position.scopeTop -\n                (list.rect.outer.top + list.rect.element.marginTop + list.rect.element.scrollTop),\n        });\n    };\n\n    /**\n     * Enable or disable file drop functionality\n     */\n    var toggleDrop = function toggleDrop(root) {\n        var isAllowed = root.query('GET_ALLOW_DROP');\n        var isDisabled = root.query('GET_DISABLED');\n        var enabled = isAllowed && !isDisabled;\n        if (enabled && !root.ref.hopper) {\n            var hopper = createHopper(\n                root.element,\n                function(items) {\n                    // allow quick validation of dropped items\n                    var beforeDropFile =\n                        root.query('GET_BEFORE_DROP_FILE') ||\n                        function() {\n                            return true;\n                        };\n\n                    // all items should be validated by all filters as valid\n                    var dropValidation = root.query('GET_DROP_VALIDATION');\n                    return dropValidation\n                        ? items.every(function(item) {\n                              return (\n                                  applyFilters('ALLOW_HOPPER_ITEM', item, {\n                                      query: root.query,\n                                  }).every(function(result) {\n                                      return result === true;\n                                  }) && beforeDropFile(item)\n                              );\n                          })\n                        : true;\n                },\n                {\n                    filterItems: function filterItems(items) {\n                        var ignoredFiles = root.query('GET_IGNORED_FILES');\n                        return items.filter(function(item) {\n                            if (isFile(item)) {\n                                return !ignoredFiles.includes(item.name.toLowerCase());\n                            }\n                            return true;\n                        });\n                    },\n                    catchesDropsOnPage: root.query('GET_DROP_ON_PAGE'),\n                    requiresDropOnElement: root.query('GET_DROP_ON_ELEMENT'),\n                }\n            );\n\n            hopper.onload = function(items, position) {\n                // get item children elements and sort based on list sort\n                var list = root.ref.list.childViews[0];\n                var visibleChildren = list.childViews.filter(function(child) {\n                    return child.rect.element.height;\n                });\n                var children = root\n                    .query('GET_ACTIVE_ITEMS')\n                    .map(function(item) {\n                        return visibleChildren.find(function(child) {\n                            return child.id === item.id;\n                        });\n                    })\n                    .filter(function(item) {\n                        return item;\n                    });\n\n                applyFilterChain('ADD_ITEMS', items, { dispatch: root.dispatch }).then(function(\n                    queue\n                ) {\n                    // these files don't fit so stop here\n                    if (exceedsMaxFiles(root, queue)) return false;\n\n                    // go\n                    root.dispatch('ADD_ITEMS', {\n                        items: queue,\n                        index: getDragIndex(root.ref.list, children, position),\n                        interactionMethod: InteractionMethod.DROP,\n                    });\n                });\n\n                root.dispatch('DID_DROP', { position: position });\n\n                root.dispatch('DID_END_DRAG', { position: position });\n            };\n\n            hopper.ondragstart = function(position) {\n                root.dispatch('DID_START_DRAG', { position: position });\n            };\n\n            hopper.ondrag = debounce(function(position) {\n                root.dispatch('DID_DRAG', { position: position });\n            });\n\n            hopper.ondragend = function(position) {\n                root.dispatch('DID_END_DRAG', { position: position });\n            };\n\n            root.ref.hopper = hopper;\n\n            root.ref.drip = root.appendChildView(root.createChildView(drip));\n        } else if (!enabled && root.ref.hopper) {\n            root.ref.hopper.destroy();\n            root.ref.hopper = null;\n            root.removeChildView(root.ref.drip);\n        }\n    };\n\n    /**\n     * Enable or disable browse functionality\n     */\n    var toggleBrowse = function toggleBrowse(root, props) {\n        var isAllowed = root.query('GET_ALLOW_BROWSE');\n        var isDisabled = root.query('GET_DISABLED');\n        var enabled = isAllowed && !isDisabled;\n        if (enabled && !root.ref.browser) {\n            root.ref.browser = root.appendChildView(\n                root.createChildView(\n                    browser,\n                    Object.assign({}, props, {\n                        onload: function onload(items) {\n                            applyFilterChain('ADD_ITEMS', items, {\n                                dispatch: root.dispatch,\n                            }).then(function(queue) {\n                                // these files don't fit so stop here\n                                if (exceedsMaxFiles(root, queue)) return false;\n\n                                // add items!\n                                root.dispatch('ADD_ITEMS', {\n                                    items: queue,\n                                    index: -1,\n                                    interactionMethod: InteractionMethod.BROWSE,\n                                });\n                            });\n                        },\n                    })\n                ),\n\n                0\n            );\n        } else if (!enabled && root.ref.browser) {\n            root.removeChildView(root.ref.browser);\n            root.ref.browser = null;\n        }\n    };\n\n    /**\n     * Enable or disable paste functionality\n     */\n    var togglePaste = function togglePaste(root) {\n        var isAllowed = root.query('GET_ALLOW_PASTE');\n        var isDisabled = root.query('GET_DISABLED');\n        var enabled = isAllowed && !isDisabled;\n        if (enabled && !root.ref.paster) {\n            root.ref.paster = createPaster();\n            root.ref.paster.onload = function(items) {\n                applyFilterChain('ADD_ITEMS', items, { dispatch: root.dispatch }).then(function(\n                    queue\n                ) {\n                    // these files don't fit so stop here\n                    if (exceedsMaxFiles(root, queue)) return false;\n\n                    // add items!\n                    root.dispatch('ADD_ITEMS', {\n                        items: queue,\n                        index: -1,\n                        interactionMethod: InteractionMethod.PASTE,\n                    });\n                });\n            };\n        } else if (!enabled && root.ref.paster) {\n            root.ref.paster.destroy();\n            root.ref.paster = null;\n        }\n    };\n\n    /**\n     * Route actions\n     */\n    var route$5 = createRoute({\n        DID_SET_ALLOW_BROWSE: function DID_SET_ALLOW_BROWSE(_ref5) {\n            var root = _ref5.root,\n                props = _ref5.props;\n            toggleBrowse(root, props);\n        },\n        DID_SET_ALLOW_DROP: function DID_SET_ALLOW_DROP(_ref6) {\n            var root = _ref6.root;\n            toggleDrop(root);\n        },\n        DID_SET_ALLOW_PASTE: function DID_SET_ALLOW_PASTE(_ref7) {\n            var root = _ref7.root;\n            togglePaste(root);\n        },\n        DID_SET_DISABLED: function DID_SET_DISABLED(_ref8) {\n            var root = _ref8.root,\n                props = _ref8.props;\n            toggleDrop(root);\n            togglePaste(root);\n            toggleBrowse(root, props);\n            var isDisabled = root.query('GET_DISABLED');\n            if (isDisabled) {\n                root.element.dataset.disabled = 'disabled';\n            } else {\n                // delete root.element.dataset.disabled; <= this does not work on iOS 10\n                root.element.removeAttribute('data-disabled');\n            }\n        },\n    });\n\n    var root = createView({\n        name: 'root',\n        read: function read(_ref9) {\n            var root = _ref9.root;\n            if (root.ref.measure) {\n                root.ref.measureHeight = root.ref.measure.offsetHeight;\n            }\n        },\n        create: create$e,\n        write: write$9,\n        destroy: function destroy(_ref10) {\n            var root = _ref10.root;\n            if (root.ref.paster) {\n                root.ref.paster.destroy();\n            }\n            if (root.ref.hopper) {\n                root.ref.hopper.destroy();\n            }\n            root.element.removeEventListener('touchmove', prevent);\n            root.element.removeEventListener('gesturestart', prevent);\n        },\n        mixins: {\n            styles: ['height'],\n        },\n    });\n\n    // creates the app\n    var createApp = function createApp() {\n        var initialOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n        // let element\n        var originalElement = null;\n\n        // get default options\n        var defaultOptions = getOptions();\n\n        // create the data store, this will contain all our app info\n        var store = createStore(\n            // initial state (should be serializable)\n            createInitialState(defaultOptions),\n\n            // queries\n            [queries, createOptionQueries(defaultOptions)],\n\n            // action handlers\n            [actions, createOptionActions(defaultOptions)]\n        );\n\n        // set initial options\n        store.dispatch('SET_OPTIONS', { options: initialOptions });\n\n        // kick thread if visibility changes\n        var visibilityHandler = function visibilityHandler() {\n            if (document.hidden) return;\n            store.dispatch('KICK');\n        };\n        document.addEventListener('visibilitychange', visibilityHandler);\n\n        // re-render on window resize start and finish\n        var resizeDoneTimer = null;\n        var isResizing = false;\n        var isResizingHorizontally = false;\n        var initialWindowWidth = null;\n        var currentWindowWidth = null;\n        var resizeHandler = function resizeHandler() {\n            if (!isResizing) {\n                isResizing = true;\n            }\n            clearTimeout(resizeDoneTimer);\n            resizeDoneTimer = setTimeout(function() {\n                isResizing = false;\n                initialWindowWidth = null;\n                currentWindowWidth = null;\n                if (isResizingHorizontally) {\n                    isResizingHorizontally = false;\n                    store.dispatch('DID_STOP_RESIZE');\n                }\n            }, 500);\n        };\n        window.addEventListener('resize', resizeHandler);\n\n        // render initial view\n        var view = root(store, { id: getUniqueId() });\n\n        //\n        // PRIVATE API -------------------------------------------------------------------------------------\n        //\n        var isResting = false;\n        var isHidden = false;\n\n        var readWriteApi = {\n            // necessary for update loop\n\n            /**\n             * Reads from dom (never call manually)\n             * @private\n             */\n            _read: function _read() {\n                // test if we're resizing horizontally\n                // TODO: see if we can optimize this by measuring root rect\n                if (isResizing) {\n                    currentWindowWidth = window.innerWidth;\n                    if (!initialWindowWidth) {\n                        initialWindowWidth = currentWindowWidth;\n                    }\n\n                    if (!isResizingHorizontally && currentWindowWidth !== initialWindowWidth) {\n                        store.dispatch('DID_START_RESIZE');\n                        isResizingHorizontally = true;\n                    }\n                }\n\n                if (isHidden && isResting) {\n                    // test if is no longer hidden\n                    isResting = view.element.offsetParent === null;\n                }\n\n                // if resting, no need to read as numbers will still all be correct\n                if (isResting) return;\n\n                // read view data\n                view._read();\n\n                // if is hidden we need to know so we exit rest mode when revealed\n                isHidden = view.rect.element.hidden;\n            },\n\n            /**\n             * Writes to dom (never call manually)\n             * @private\n             */\n            _write: function _write(ts) {\n                // get all actions from store\n                var actions = store\n                    .processActionQueue()\n\n                    // filter out set actions (these will automatically trigger DID_SET)\n                    .filter(function(action) {\n                        return !/^SET_/.test(action.type);\n                    });\n\n                // if was idling and no actions stop here\n                if (isResting && !actions.length) return;\n\n                // some actions might trigger events\n                routeActionsToEvents(actions);\n\n                // update the view\n                isResting = view._write(ts, actions, isResizingHorizontally);\n\n                // will clean up all archived items\n                removeReleasedItems(store.query('GET_ITEMS'));\n\n                // now idling\n                if (isResting) {\n                    store.processDispatchQueue();\n                }\n            },\n        };\n\n        //\n        // EXPOSE EVENTS -------------------------------------------------------------------------------------\n        //\n        var createEvent = function createEvent(name) {\n            return function(data) {\n                // create default event\n                var event = {\n                    type: name,\n                };\n\n                // no data to add\n                if (!data) {\n                    return event;\n                }\n\n                // copy relevant props\n                if (data.hasOwnProperty('error')) {\n                    event.error = data.error ? Object.assign({}, data.error) : null;\n                }\n\n                if (data.status) {\n                    event.status = Object.assign({}, data.status);\n                }\n\n                if (data.file) {\n                    event.output = data.file;\n                }\n\n                // only source is available, else add item if possible\n                if (data.source) {\n                    event.file = data.source;\n                } else if (data.item || data.id) {\n                    var item = data.item ? data.item : store.query('GET_ITEM', data.id);\n                    event.file = item ? createItemAPI(item) : null;\n                }\n\n                // map all items in a possible items array\n                if (data.items) {\n                    event.items = data.items.map(createItemAPI);\n                }\n\n                // if this is a progress event add the progress amount\n                if (/progress/.test(name)) {\n                    event.progress = data.progress;\n                }\n\n                // copy relevant props\n                if (data.hasOwnProperty('origin') && data.hasOwnProperty('target')) {\n                    event.origin = data.origin;\n                    event.target = data.target;\n                }\n\n                return event;\n            };\n        };\n\n        var eventRoutes = {\n            DID_DESTROY: createEvent('destroy'),\n\n            DID_INIT: createEvent('init'),\n\n            DID_THROW_MAX_FILES: createEvent('warning'),\n\n            DID_INIT_ITEM: createEvent('initfile'),\n            DID_START_ITEM_LOAD: createEvent('addfilestart'),\n            DID_UPDATE_ITEM_LOAD_PROGRESS: createEvent('addfileprogress'),\n            DID_LOAD_ITEM: createEvent('addfile'),\n\n            DID_THROW_ITEM_INVALID: [createEvent('error'), createEvent('addfile')],\n\n            DID_THROW_ITEM_LOAD_ERROR: [createEvent('error'), createEvent('addfile')],\n\n            DID_THROW_ITEM_REMOVE_ERROR: [createEvent('error'), createEvent('removefile')],\n\n            DID_PREPARE_OUTPUT: createEvent('preparefile'),\n\n            DID_START_ITEM_PROCESSING: createEvent('processfilestart'),\n            DID_UPDATE_ITEM_PROCESS_PROGRESS: createEvent('processfileprogress'),\n            DID_ABORT_ITEM_PROCESSING: createEvent('processfileabort'),\n            DID_COMPLETE_ITEM_PROCESSING: createEvent('processfile'),\n            DID_COMPLETE_ITEM_PROCESSING_ALL: createEvent('processfiles'),\n            DID_REVERT_ITEM_PROCESSING: createEvent('processfilerevert'),\n\n            DID_THROW_ITEM_PROCESSING_ERROR: [createEvent('error'), createEvent('processfile')],\n\n            DID_REMOVE_ITEM: createEvent('removefile'),\n\n            DID_UPDATE_ITEMS: createEvent('updatefiles'),\n\n            DID_ACTIVATE_ITEM: createEvent('activatefile'),\n\n            DID_REORDER_ITEMS: createEvent('reorderfiles'),\n        };\n\n        var exposeEvent = function exposeEvent(event) {\n            // create event object to be dispatched\n            var detail = Object.assign({ pond: exports }, event);\n            delete detail.type;\n            view.element.dispatchEvent(\n                new CustomEvent('FilePond:' + event.type, {\n                    // event info\n                    detail: detail,\n\n                    // event behaviour\n                    bubbles: true,\n                    cancelable: true,\n                    composed: true, // triggers listeners outside of shadow root\n                })\n            );\n\n            // event object to params used for `on()` event handlers and callbacks `oninit()`\n            var params = [];\n\n            // if is possible error event, make it the first param\n            if (event.hasOwnProperty('error')) {\n                params.push(event.error);\n            }\n\n            // file is always section\n            if (event.hasOwnProperty('file')) {\n                params.push(event.file);\n            }\n\n            // append other props\n            var filtered = ['type', 'error', 'file'];\n            Object.keys(event)\n                .filter(function(key) {\n                    return !filtered.includes(key);\n                })\n                .forEach(function(key) {\n                    return params.push(event[key]);\n                });\n\n            // on(type, () => { })\n            exports.fire.apply(exports, [event.type].concat(params));\n\n            // oninit = () => {}\n            var handler = store.query('GET_ON' + event.type.toUpperCase());\n            if (handler) {\n                handler.apply(void 0, params);\n            }\n        };\n\n        var routeActionsToEvents = function routeActionsToEvents(actions) {\n            if (!actions.length) return;\n            actions\n                .filter(function(action) {\n                    return eventRoutes[action.type];\n                })\n                .forEach(function(action) {\n                    var routes = eventRoutes[action.type];\n                    (Array.isArray(routes) ? routes : [routes]).forEach(function(route) {\n                        // this isn't fantastic, but because of the stacking of settimeouts plugins can handle the did_load before the did_init\n                        if (action.type === 'DID_INIT_ITEM') {\n                            exposeEvent(route(action.data));\n                        } else {\n                            setTimeout(function() {\n                                exposeEvent(route(action.data));\n                            }, 0);\n                        }\n                    });\n                });\n        };\n\n        //\n        // PUBLIC API -------------------------------------------------------------------------------------\n        //\n        var setOptions = function setOptions(options) {\n            return store.dispatch('SET_OPTIONS', { options: options });\n        };\n\n        var getFile = function getFile(query) {\n            return store.query('GET_ACTIVE_ITEM', query);\n        };\n\n        var prepareFile = function prepareFile(query) {\n            return new Promise(function(resolve, reject) {\n                store.dispatch('REQUEST_ITEM_PREPARE', {\n                    query: query,\n                    success: function success(item) {\n                        resolve(item);\n                    },\n                    failure: function failure(error) {\n                        reject(error);\n                    },\n                });\n            });\n        };\n\n        var addFile = function addFile(source) {\n            var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n            return new Promise(function(resolve, reject) {\n                addFiles([{ source: source, options: options }], { index: options.index })\n                    .then(function(items) {\n                        return resolve(items && items[0]);\n                    })\n                    .catch(reject);\n            });\n        };\n\n        var isFilePondFile = function isFilePondFile(obj) {\n            return obj.file && obj.id;\n        };\n\n        var removeFile = function removeFile(query, options) {\n            // if only passed options\n            if (typeof query === 'object' && !isFilePondFile(query) && !options) {\n                options = query;\n                query = undefined;\n            }\n\n            // request item removal\n            store.dispatch('REMOVE_ITEM', Object.assign({}, options, { query: query }));\n\n            // see if item has been removed\n            return store.query('GET_ACTIVE_ITEM', query) === null;\n        };\n\n        var addFiles = function addFiles() {\n            for (\n                var _len = arguments.length, args = new Array(_len), _key = 0;\n                _key < _len;\n                _key++\n            ) {\n                args[_key] = arguments[_key];\n            }\n            return new Promise(function(resolve, reject) {\n                var sources = [];\n                var options = {};\n\n                // user passed a sources array\n                if (isArray(args[0])) {\n                    sources.push.apply(sources, args[0]);\n                    Object.assign(options, args[1] || {});\n                } else {\n                    // user passed sources as arguments, last one might be options object\n                    var lastArgument = args[args.length - 1];\n                    if (typeof lastArgument === 'object' && !(lastArgument instanceof Blob)) {\n                        Object.assign(options, args.pop());\n                    }\n\n                    // add rest to sources\n                    sources.push.apply(sources, args);\n                }\n\n                store.dispatch('ADD_ITEMS', {\n                    items: sources,\n                    index: options.index,\n                    interactionMethod: InteractionMethod.API,\n                    success: resolve,\n                    failure: reject,\n                });\n            });\n        };\n\n        var getFiles = function getFiles() {\n            return store.query('GET_ACTIVE_ITEMS');\n        };\n\n        var processFile = function processFile(query) {\n            return new Promise(function(resolve, reject) {\n                store.dispatch('REQUEST_ITEM_PROCESSING', {\n                    query: query,\n                    success: function success(item) {\n                        resolve(item);\n                    },\n                    failure: function failure(error) {\n                        reject(error);\n                    },\n                });\n            });\n        };\n\n        var prepareFiles = function prepareFiles() {\n            for (\n                var _len2 = arguments.length, args = new Array(_len2), _key2 = 0;\n                _key2 < _len2;\n                _key2++\n            ) {\n                args[_key2] = arguments[_key2];\n            }\n            var queries = Array.isArray(args[0]) ? args[0] : args;\n            var items = queries.length ? queries : getFiles();\n            return Promise.all(items.map(prepareFile));\n        };\n\n        var processFiles = function processFiles() {\n            for (\n                var _len3 = arguments.length, args = new Array(_len3), _key3 = 0;\n                _key3 < _len3;\n                _key3++\n            ) {\n                args[_key3] = arguments[_key3];\n            }\n            var queries = Array.isArray(args[0]) ? args[0] : args;\n            if (!queries.length) {\n                var files = getFiles().filter(function(item) {\n                    return (\n                        !(item.status === ItemStatus.IDLE && item.origin === FileOrigin.LOCAL) &&\n                        item.status !== ItemStatus.PROCESSING &&\n                        item.status !== ItemStatus.PROCESSING_COMPLETE &&\n                        item.status !== ItemStatus.PROCESSING_REVERT_ERROR\n                    );\n                });\n\n                return Promise.all(files.map(processFile));\n            }\n            return Promise.all(queries.map(processFile));\n        };\n\n        var removeFiles = function removeFiles() {\n            for (\n                var _len4 = arguments.length, args = new Array(_len4), _key4 = 0;\n                _key4 < _len4;\n                _key4++\n            ) {\n                args[_key4] = arguments[_key4];\n            }\n\n            var queries = Array.isArray(args[0]) ? args[0] : args;\n\n            var options;\n            if (typeof queries[queries.length - 1] === 'object') {\n                options = queries.pop();\n            } else if (Array.isArray(args[0])) {\n                options = args[1];\n            }\n\n            var files = getFiles();\n\n            if (!queries.length)\n                return Promise.all(\n                    files.map(function(file) {\n                        return removeFile(file, options);\n                    })\n                );\n\n            // when removing by index the indexes shift after each file removal so we need to convert indexes to ids\n            var mappedQueries = queries\n                .map(function(query) {\n                    return isNumber(query) ? (files[query] ? files[query].id : null) : query;\n                })\n                .filter(function(query) {\n                    return query;\n                });\n\n            return mappedQueries.map(function(q) {\n                return removeFile(q, options);\n            });\n        };\n\n        var exports = Object.assign(\n            {},\n\n            on(),\n            {},\n\n            readWriteApi,\n            {},\n\n            createOptionAPI(store, defaultOptions),\n            {\n                /**\n                 * Override options defined in options object\n                 * @param options\n                 */\n                setOptions: setOptions,\n\n                /**\n                 * Load the given file\n                 * @param source - the source of the file (either a File, base64 data uri or url)\n                 * @param options - object, { index: 0 }\n                 */\n                addFile: addFile,\n\n                /**\n                 * Load the given files\n                 * @param sources - the sources of the files to load\n                 * @param options - object, { index: 0 }\n                 */\n                addFiles: addFiles,\n\n                /**\n                 * Returns the file objects matching the given query\n                 * @param query { string, number, null }\n                 */\n                getFile: getFile,\n\n                /**\n                 * Upload file with given name\n                 * @param query { string, number, null  }\n                 */\n                processFile: processFile,\n\n                /**\n                 * Request prepare output for file with given name\n                 * @param query { string, number, null  }\n                 */\n                prepareFile: prepareFile,\n\n                /**\n                 * Removes a file by its name\n                 * @param query { string, number, null  }\n                 */\n                removeFile: removeFile,\n\n                /**\n                 * Moves a file to a new location in the files list\n                 */\n                moveFile: function moveFile(query, index) {\n                    return store.dispatch('MOVE_ITEM', { query: query, index: index });\n                },\n\n                /**\n                 * Returns all files (wrapped in public api)\n                 */\n                getFiles: getFiles,\n\n                /**\n                 * Starts uploading all files\n                 */\n                processFiles: processFiles,\n\n                /**\n                 * Clears all files from the files list\n                 */\n                removeFiles: removeFiles,\n\n                /**\n                 * Starts preparing output of all files\n                 */\n                prepareFiles: prepareFiles,\n\n                /**\n                 * Sort list of files\n                 */\n                sort: function sort(compare) {\n                    return store.dispatch('SORT', { compare: compare });\n                },\n\n                /**\n                 * Browse the file system for a file\n                 */\n                browse: function browse() {\n                    // needs to be trigger directly as user action needs to be traceable (is not traceable in requestAnimationFrame)\n                    var input = view.element.querySelector('input[type=file]');\n                    if (input) {\n                        input.click();\n                    }\n                },\n\n                /**\n                 * Destroys the app\n                 */\n                destroy: function destroy() {\n                    // request destruction\n                    exports.fire('destroy', view.element);\n\n                    // stop active processes (file uploads, fetches, stuff like that)\n                    // loop over items and depending on states call abort for ongoing processes\n                    store.dispatch('ABORT_ALL');\n\n                    // destroy view\n                    view._destroy();\n\n                    // stop listening to resize\n                    window.removeEventListener('resize', resizeHandler);\n\n                    // stop listening to the visiblitychange event\n                    document.removeEventListener('visibilitychange', visibilityHandler);\n\n                    // dispatch destroy\n                    store.dispatch('DID_DESTROY');\n                },\n\n                /**\n                 * Inserts the plugin before the target element\n                 */\n                insertBefore: function insertBefore$1(element) {\n                    return insertBefore(view.element, element);\n                },\n\n                /**\n                 * Inserts the plugin after the target element\n                 */\n                insertAfter: function insertAfter$1(element) {\n                    return insertAfter(view.element, element);\n                },\n\n                /**\n                 * Appends the plugin to the target element\n                 */\n                appendTo: function appendTo(element) {\n                    return element.appendChild(view.element);\n                },\n\n                /**\n                 * Replaces an element with the app\n                 */\n                replaceElement: function replaceElement(element) {\n                    // insert the app before the element\n                    insertBefore(view.element, element);\n\n                    // remove the original element\n                    element.parentNode.removeChild(element);\n\n                    // remember original element\n                    originalElement = element;\n                },\n\n                /**\n                 * Restores the original element\n                 */\n                restoreElement: function restoreElement() {\n                    if (!originalElement) {\n                        return; // no element to restore\n                    }\n\n                    // restore original element\n                    insertAfter(originalElement, view.element);\n\n                    // remove our element\n                    view.element.parentNode.removeChild(view.element);\n\n                    // remove reference\n                    originalElement = null;\n                },\n\n                /**\n                 * Returns true if the app root is attached to given element\n                 * @param element\n                 */\n                isAttachedTo: function isAttachedTo(element) {\n                    return view.element === element || originalElement === element;\n                },\n\n                /**\n                 * Returns the root element\n                 */\n                element: {\n                    get: function get() {\n                        return view.element;\n                    },\n                },\n\n                /**\n                 * Returns the current pond status\n                 */\n                status: {\n                    get: function get() {\n                        return store.query('GET_STATUS');\n                    },\n                },\n            }\n        );\n\n        // Done!\n        store.dispatch('DID_INIT');\n\n        // create actual api object\n        return createObject(exports);\n    };\n\n    var createAppObject = function createAppObject() {\n        var customOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n        // default options\n        var defaultOptions = {};\n        forin(getOptions(), function(key, value) {\n            defaultOptions[key] = value[0];\n        });\n\n        // set app options\n        var app = createApp(\n            Object.assign(\n                {},\n\n                defaultOptions,\n                {},\n\n                customOptions\n            )\n        );\n\n        // return the plugin instance\n        return app;\n    };\n\n    var lowerCaseFirstLetter = function lowerCaseFirstLetter(string) {\n        return string.charAt(0).toLowerCase() + string.slice(1);\n    };\n\n    var attributeNameToPropertyName = function attributeNameToPropertyName(attributeName) {\n        return toCamels(attributeName.replace(/^data-/, ''));\n    };\n\n    var mapObject = function mapObject(object, propertyMap) {\n        // remove unwanted\n        forin(propertyMap, function(selector, mapping) {\n            forin(object, function(property, value) {\n                // create regexp shortcut\n                var selectorRegExp = new RegExp(selector);\n\n                // tests if\n                var matches = selectorRegExp.test(property);\n\n                // no match, skip\n                if (!matches) {\n                    return;\n                }\n\n                // if there's a mapping, the original property is always removed\n                delete object[property];\n\n                // should only remove, we done!\n                if (mapping === false) {\n                    return;\n                }\n\n                // move value to new property\n                if (isString(mapping)) {\n                    object[mapping] = value;\n                    return;\n                }\n\n                // move to group\n                var group = mapping.group;\n                if (isObject(mapping) && !object[group]) {\n                    object[group] = {};\n                }\n\n                object[group][lowerCaseFirstLetter(property.replace(selectorRegExp, ''))] = value;\n            });\n\n            // do submapping\n            if (mapping.mapping) {\n                mapObject(object[mapping.group], mapping.mapping);\n            }\n        });\n    };\n\n    var getAttributesAsObject = function getAttributesAsObject(node) {\n        var attributeMapping =\n            arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n        // turn attributes into object\n        var attributes = [];\n        forin(node.attributes, function(index) {\n            attributes.push(node.attributes[index]);\n        });\n\n        var output = attributes\n            .filter(function(attribute) {\n                return attribute.name;\n            })\n            .reduce(function(obj, attribute) {\n                var value = attr(node, attribute.name);\n\n                obj[attributeNameToPropertyName(attribute.name)] =\n                    value === attribute.name ? true : value;\n                return obj;\n            }, {});\n\n        // do mapping of object properties\n        mapObject(output, attributeMapping);\n\n        return output;\n    };\n\n    var createAppAtElement = function createAppAtElement(element) {\n        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        // how attributes of the input element are mapped to the options for the plugin\n        var attributeMapping = {\n            // translate to other name\n            '^class$': 'className',\n            '^multiple$': 'allowMultiple',\n            '^capture$': 'captureMethod',\n            '^webkitdirectory$': 'allowDirectoriesOnly',\n\n            // group under single property\n            '^server': {\n                group: 'server',\n                mapping: {\n                    '^process': {\n                        group: 'process',\n                    },\n\n                    '^revert': {\n                        group: 'revert',\n                    },\n\n                    '^fetch': {\n                        group: 'fetch',\n                    },\n\n                    '^restore': {\n                        group: 'restore',\n                    },\n\n                    '^load': {\n                        group: 'load',\n                    },\n                },\n            },\n\n            // don't include in object\n            '^type$': false,\n            '^files$': false,\n        };\n\n        // add additional option translators\n        applyFilters('SET_ATTRIBUTE_TO_OPTION_MAP', attributeMapping);\n\n        // create final options object by setting options object and then overriding options supplied on element\n        var mergedOptions = Object.assign({}, options);\n\n        var attributeOptions = getAttributesAsObject(\n            element.nodeName === 'FIELDSET' ? element.querySelector('input[type=file]') : element,\n            attributeMapping\n        );\n\n        // merge with options object\n        Object.keys(attributeOptions).forEach(function(key) {\n            if (isObject(attributeOptions[key])) {\n                if (!isObject(mergedOptions[key])) {\n                    mergedOptions[key] = {};\n                }\n                Object.assign(mergedOptions[key], attributeOptions[key]);\n            } else {\n                mergedOptions[key] = attributeOptions[key];\n            }\n        });\n\n        // if parent is a fieldset, get files from parent by selecting all input fields that are not file upload fields\n        // these will then be automatically set to the initial files\n        mergedOptions.files = (options.files || []).concat(\n            Array.from(element.querySelectorAll('input:not([type=file])')).map(function(input) {\n                return {\n                    source: input.value,\n                    options: {\n                        type: input.dataset.type,\n                    },\n                };\n            })\n        );\n\n        // build plugin\n        var app = createAppObject(mergedOptions);\n\n        // add already selected files\n        if (element.files) {\n            Array.from(element.files).forEach(function(file) {\n                app.addFile(file);\n            });\n        }\n\n        // replace the target element\n        app.replaceElement(element);\n\n        // expose\n        return app;\n    };\n\n    // if an element is passed, we create the instance at that element, if not, we just create an up object\n    var createApp$1 = function createApp() {\n        return isNode(arguments.length <= 0 ? undefined : arguments[0])\n            ? createAppAtElement.apply(void 0, arguments)\n            : createAppObject.apply(void 0, arguments);\n    };\n\n    var PRIVATE_METHODS = ['fire', '_read', '_write'];\n\n    var createAppAPI = function createAppAPI(app) {\n        var api = {};\n\n        copyObjectPropertiesToObject(app, api, PRIVATE_METHODS);\n\n        return api;\n    };\n\n    /**\n     * Replaces placeholders in given string with replacements\n     * @param string - \"Foo {bar}\"\"\n     * @param replacements - { \"bar\": 10 }\n     */\n    var replaceInString = function replaceInString(string, replacements) {\n        return string.replace(/(?:{([a-zA-Z]+)})/g, function(match, group) {\n            return replacements[group];\n        });\n    };\n\n    var createWorker = function createWorker(fn) {\n        var workerBlob = new Blob(['(', fn.toString(), ')()'], {\n            type: 'application/javascript',\n        });\n\n        var workerURL = URL.createObjectURL(workerBlob);\n        var worker = new Worker(workerURL);\n\n        return {\n            transfer: function transfer(message, cb) {},\n            post: function post(message, cb, transferList) {\n                var id = getUniqueId();\n\n                worker.onmessage = function(e) {\n                    if (e.data.id === id) {\n                        cb(e.data.message);\n                    }\n                };\n\n                worker.postMessage(\n                    {\n                        id: id,\n                        message: message,\n                    },\n\n                    transferList\n                );\n            },\n            terminate: function terminate() {\n                worker.terminate();\n                URL.revokeObjectURL(workerURL);\n            },\n        };\n    };\n\n    var loadImage = function loadImage(url) {\n        return new Promise(function(resolve, reject) {\n            var img = new Image();\n            img.onload = function() {\n                resolve(img);\n            };\n            img.onerror = function(e) {\n                reject(e);\n            };\n            img.src = url;\n        });\n    };\n\n    var renameFile = function renameFile(file, name) {\n        var renamedFile = file.slice(0, file.size, file.type);\n        renamedFile.lastModifiedDate = file.lastModifiedDate;\n        renamedFile.name = name;\n        return renamedFile;\n    };\n\n    var copyFile = function copyFile(file) {\n        return renameFile(file, file.name);\n    };\n\n    // already registered plugins (can't register twice)\n    var registeredPlugins = [];\n\n    // pass utils to plugin\n    var createAppPlugin = function createAppPlugin(plugin) {\n        // already registered\n        if (registeredPlugins.includes(plugin)) {\n            return;\n        }\n\n        // remember this plugin\n        registeredPlugins.push(plugin);\n\n        // setup!\n        var pluginOutline = plugin({\n            addFilter: addFilter,\n            utils: {\n                Type: Type,\n                forin: forin,\n                isString: isString,\n                isFile: isFile,\n                toNaturalFileSize: toNaturalFileSize,\n                replaceInString: replaceInString,\n                getExtensionFromFilename: getExtensionFromFilename,\n                getFilenameWithoutExtension: getFilenameWithoutExtension,\n                guesstimateMimeType: guesstimateMimeType,\n                getFileFromBlob: getFileFromBlob,\n                getFilenameFromURL: getFilenameFromURL,\n                createRoute: createRoute,\n                createWorker: createWorker,\n                createView: createView,\n                createItemAPI: createItemAPI,\n                loadImage: loadImage,\n                copyFile: copyFile,\n                renameFile: renameFile,\n                createBlob: createBlob,\n                applyFilterChain: applyFilterChain,\n                text: text,\n                getNumericAspectRatioFromString: getNumericAspectRatioFromString,\n            },\n\n            views: {\n                fileActionButton: fileActionButton,\n            },\n        });\n\n        // add plugin options to default options\n        extendDefaultOptions(pluginOutline.options);\n    };\n\n    // feature detection used by supported() method\n    var isOperaMini = function isOperaMini() {\n        return Object.prototype.toString.call(window.operamini) === '[object OperaMini]';\n    };\n    var hasPromises = function hasPromises() {\n        return 'Promise' in window;\n    };\n    var hasBlobSlice = function hasBlobSlice() {\n        return 'slice' in Blob.prototype;\n    };\n    var hasCreateObjectURL = function hasCreateObjectURL() {\n        return 'URL' in window && 'createObjectURL' in window.URL;\n    };\n    var hasVisibility = function hasVisibility() {\n        return 'visibilityState' in document;\n    };\n    var hasTiming = function hasTiming() {\n        return 'performance' in window;\n    }; // iOS 8.x\n    var hasCSSSupports = function hasCSSSupports() {\n        return 'supports' in (window.CSS || {});\n    }; // use to detect Safari 9+\n    var isIE11 = function isIE11() {\n        return /MSIE|Trident/.test(window.navigator.userAgent);\n    };\n\n    var supported = (function() {\n        // Runs immediately and then remembers result for subsequent calls\n        var isSupported =\n            // Has to be a browser\n            isBrowser() &&\n            // Can't run on Opera Mini due to lack of everything\n            !isOperaMini() &&\n            // Require these APIs to feature detect a modern browser\n            hasVisibility() &&\n            hasPromises() &&\n            hasBlobSlice() &&\n            hasCreateObjectURL() &&\n            hasTiming() &&\n            // doesn't need CSSSupports but is a good way to detect Safari 9+ (we do want to support IE11 though)\n            (hasCSSSupports() || isIE11());\n\n        return function() {\n            return isSupported;\n        };\n    })();\n\n    /**\n     * Plugin internal state (over all instances)\n     */\n    var state = {\n        // active app instances, used to redraw the apps and to find the later\n        apps: [],\n    };\n\n    // plugin name\n    var name = 'filepond';\n\n    /**\n     * Public Plugin methods\n     */\n    var fn = function fn() {};\n    exports.Status = {};\n    exports.FileStatus = {};\n    exports.FileOrigin = {};\n    exports.OptionTypes = {};\n    exports.create = fn;\n    exports.destroy = fn;\n    exports.parse = fn;\n    exports.find = fn;\n    exports.registerPlugin = fn;\n    exports.getOptions = fn;\n    exports.setOptions = fn;\n\n    // if not supported, no API\n    if (supported()) {\n        // start painter and fire load event\n        createPainter(\n            function() {\n                state.apps.forEach(function(app) {\n                    return app._read();\n                });\n            },\n            function(ts) {\n                state.apps.forEach(function(app) {\n                    return app._write(ts);\n                });\n            }\n        );\n\n        // fire loaded event so we know when FilePond is available\n        var dispatch = function dispatch() {\n            // let others know we have area ready\n            document.dispatchEvent(\n                new CustomEvent('FilePond:loaded', {\n                    detail: {\n                        supported: supported,\n                        create: exports.create,\n                        destroy: exports.destroy,\n                        parse: exports.parse,\n                        find: exports.find,\n                        registerPlugin: exports.registerPlugin,\n                        setOptions: exports.setOptions,\n                    },\n                })\n            );\n\n            // clean up event\n            document.removeEventListener('DOMContentLoaded', dispatch);\n        };\n\n        if (document.readyState !== 'loading') {\n            // move to back of execution queue, FilePond should have been exported by then\n            setTimeout(function() {\n                return dispatch();\n            }, 0);\n        } else {\n            document.addEventListener('DOMContentLoaded', dispatch);\n        }\n\n        // updates the OptionTypes object based on the current options\n        var updateOptionTypes = function updateOptionTypes() {\n            return forin(getOptions(), function(key, value) {\n                exports.OptionTypes[key] = value[1];\n            });\n        };\n\n        exports.Status = Object.assign({}, Status);\n        exports.FileOrigin = Object.assign({}, FileOrigin);\n        exports.FileStatus = Object.assign({}, ItemStatus);\n\n        exports.OptionTypes = {};\n        updateOptionTypes();\n\n        // create method, creates apps and adds them to the app array\n        exports.create = function create() {\n            var app = createApp$1.apply(void 0, arguments);\n            app.on('destroy', exports.destroy);\n            state.apps.push(app);\n            return createAppAPI(app);\n        };\n\n        // destroys apps and removes them from the app array\n        exports.destroy = function destroy(hook) {\n            // returns true if the app was destroyed successfully\n            var indexToRemove = state.apps.findIndex(function(app) {\n                return app.isAttachedTo(hook);\n            });\n            if (indexToRemove >= 0) {\n                // remove from apps\n                var app = state.apps.splice(indexToRemove, 1)[0];\n\n                // restore original dom element\n                app.restoreElement();\n\n                return true;\n            }\n\n            return false;\n        };\n\n        // parses the given context for plugins (does not include the context element itself)\n        exports.parse = function parse(context) {\n            // get all possible hooks\n            var matchedHooks = Array.from(context.querySelectorAll('.' + name));\n\n            // filter out already active hooks\n            var newHooks = matchedHooks.filter(function(newHook) {\n                return !state.apps.find(function(app) {\n                    return app.isAttachedTo(newHook);\n                });\n            });\n\n            // create new instance for each hook\n            return newHooks.map(function(hook) {\n                return exports.create(hook);\n            });\n        };\n\n        // returns an app based on the given element hook\n        exports.find = function find(hook) {\n            var app = state.apps.find(function(app) {\n                return app.isAttachedTo(hook);\n            });\n            if (!app) {\n                return null;\n            }\n            return createAppAPI(app);\n        };\n\n        // adds a plugin extension\n        exports.registerPlugin = function registerPlugin() {\n            for (\n                var _len = arguments.length, plugins = new Array(_len), _key = 0;\n                _key < _len;\n                _key++\n            ) {\n                plugins[_key] = arguments[_key];\n            }\n\n            // register plugins\n            plugins.forEach(createAppPlugin);\n\n            // update OptionTypes, each plugin might have extended the default options\n            updateOptionTypes();\n        };\n\n        exports.getOptions = function getOptions$1() {\n            var opts = {};\n            forin(getOptions(), function(key, value) {\n                opts[key] = value[0];\n            });\n            return opts;\n        };\n\n        exports.setOptions = function setOptions$1(opts) {\n            if (isObject(opts)) {\n                // update existing plugins\n                state.apps.forEach(function(app) {\n                    app.setOptions(opts);\n                });\n\n                // override defaults\n                setOptions(opts);\n            }\n\n            // return new options\n            return exports.getOptions();\n        };\n    }\n\n    exports.supported = supported;\n\n    Object.defineProperty(exports, '__esModule', { value: true });\n});\n","/*!\n * jQuery JavaScript Library v3.6.0\n * https://jquery.com/\n *\n * Includes Sizzle.js\n * https://sizzlejs.com/\n *\n * Copyright OpenJS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2021-03-02T17:08Z\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 getProto = Object.getPrototypeOf;\n\nvar slice = arr.slice;\n\nvar flat = arr.flat ? function( array ) {\n\treturn arr.flat.call( array );\n} : function( array ) {\n\treturn arr.concat.apply( [], array );\n};\n\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\nvar isFunction = function isFunction( obj ) {\n\n\t\t// Support: Chrome <=57, Firefox <=52\n\t\t// In some browsers, typeof returns \"function\" for HTML <object> elements\n\t\t// (i.e., `typeof document.createElement( \"object\" ) === \"function\"`).\n\t\t// We don't want to classify *any* DOM node as a function.\n\t\t// Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5\n\t\t// Plus for old WebKit, typeof returns \"function\" for HTML collections\n\t\t// (e.g., `typeof document.getElementsByTagName(\"div\") === \"function\"`). (gh-4756)\n\t\treturn typeof obj === \"function\" && typeof obj.nodeType !== \"number\" &&\n\t\t\ttypeof obj.item !== \"function\";\n\t};\n\n\nvar isWindow = function isWindow( obj ) {\n\t\treturn obj != null && obj === obj.window;\n\t};\n\n\nvar document = window.document;\n\n\n\n\tvar preservedScriptAttributes = {\n\t\ttype: true,\n\t\tsrc: true,\n\t\tnonce: true,\n\t\tnoModule: true\n\t};\n\n\tfunction DOMEval( code, node, doc ) {\n\t\tdoc = doc || document;\n\n\t\tvar i, val,\n\t\t\tscript = doc.createElement( \"script\" );\n\n\t\tscript.text = code;\n\t\tif ( node ) {\n\t\t\tfor ( i in preservedScriptAttributes ) {\n\n\t\t\t\t// Support: Firefox 64+, Edge 18+\n\t\t\t\t// Some browsers don't support the \"nonce\" property on scripts.\n\t\t\t\t// On the other hand, just using `getAttribute` is not enough as\n\t\t\t\t// the `nonce` attribute is reset to an empty string whenever it\n\t\t\t\t// becomes browsing-context connected.\n\t\t\t\t// See https://github.com/whatwg/html/issues/2369\n\t\t\t\t// See https://html.spec.whatwg.org/#nonce-attributes\n\t\t\t\t// The `node.getAttribute` check was added for the sake of\n\t\t\t\t// `jQuery.globalEval` so that it can fake a nonce-containing node\n\t\t\t\t// via an object.\n\t\t\t\tval = node[ i ] || node.getAttribute && node.getAttribute( i );\n\t\t\t\tif ( val ) {\n\t\t\t\t\tscript.setAttribute( i, val );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tdoc.head.appendChild( script ).parentNode.removeChild( script );\n\t}\n\n\nfunction toType( obj ) {\n\tif ( obj == null ) {\n\t\treturn obj + \"\";\n\t}\n\n\t// Support: Android <=2.3 only (functionish RegExp)\n\treturn typeof obj === \"object\" || typeof obj === \"function\" ?\n\t\tclass2type[ toString.call( obj ) ] || \"object\" :\n\t\ttypeof obj;\n}\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.6.0\",\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\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\teven: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn ( i + 1 ) % 2;\n\t\t} ) );\n\t},\n\n\todd: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn i % 2;\n\t\t} ) );\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\" && !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\tcopy = options[ name ];\n\n\t\t\t\t// Prevent Object.prototype pollution\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif ( name === \"__proto__\" || 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\t\t\t\t\tsrc = target[ name ];\n\n\t\t\t\t\t// Ensure proper type for the source value\n\t\t\t\t\tif ( copyIsArray && !Array.isArray( src ) ) {\n\t\t\t\t\t\tclone = [];\n\t\t\t\t\t} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {\n\t\t\t\t\t\tclone = {};\n\t\t\t\t\t} else {\n\t\t\t\t\t\tclone = src;\n\t\t\t\t\t}\n\t\t\t\t\tcopyIsArray = false;\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\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\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\t// Evaluates a script in a provided context; falls back to the global one\n\t// if not specified.\n\tglobalEval: function( code, options, doc ) {\n\t\tDOMEval( code, { nonce: options && options.nonce }, doc );\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// 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\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 flat( ret );\n\t},\n\n\t// A global GUID counter for objects\n\tguid: 1,\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( \" \" ),\n\tfunction( _i, name ) {\n\t\tclass2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\n\t} );\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 = toType( obj );\n\n\tif ( isFunction( obj ) || 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.6\n * https://sizzlejs.com/\n *\n * Copyright JS Foundation and other contributors\n * Released under the MIT license\n * https://js.foundation/\n *\n * Date: 2021-02-16\n */\n( function( window ) {\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\tnonnativeSelectorCache = 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\tpushNative = arr.push,\n\tpush = arr.push,\n\tslice = arr.slice,\n\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|\" +\n\t\t\"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// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram\n\tidentifier = \"(?:\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\t\"?|\\\\\\\\[^\\\\r\\\\n\\\\f]|[\\\\w-]|[^\\0-\\\\x7f])+\",\n\n\t// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors\n\tattributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\n\n\t\t// Operator (capture 2)\n\t\t\"*([*^$|!~]?=)\" + whitespace +\n\n\t\t// \"Attribute values must be CSS identifiers [capture 5]\n\t\t// or strings [capture 3 or capture 4]\"\n\t\t\"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" +\n\t\twhitespace + \"*\\\\]\",\n\n\tpseudos = \":(\" + identifier + \")(?:\\\\((\" +\n\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\n\t\t// 2. simple (capture 6)\n\t\t\"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\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 + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" +\n\t\twhitespace + \"+$\", \"g\" ),\n\n\trcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" ),\n\trcombinators = new RegExp( \"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" + whitespace +\n\t\t\"*\" ),\n\trdescend = new RegExp( whitespace + \"|>\" ),\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)(?:\\\\(\" +\n\t\t\twhitespace + \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" +\n\t\t\twhitespace + \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" ),\n\t\t\"bool\": new RegExp( \"^(?:\" + booleans + \")$\", \"i\" ),\n\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 +\n\t\t\t\"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" + whitespace +\n\t\t\t\"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\n\t},\n\n\trhtml = /HTML$/i,\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-fA-F]{1,6}\" + whitespace + \"?|\\\\\\\\([^\\\\r\\\\n\\\\f])\", \"g\" ),\n\tfunescape = function( escape, nonHex ) {\n\t\tvar high = \"0x\" + escape.slice( 1 ) - 0x10000;\n\n\t\treturn nonHex ?\n\n\t\t\t// Strip the backslash prefix from a non-hex escape sequence\n\t\t\tnonHex :\n\n\t\t\t// Replace a hexadecimal escape sequence with the encoded Unicode code point\n\t\t\t// Support: IE <=11+\n\t\t\t// For values outside the Basic Multilingual Plane (BMP), manually construct a\n\t\t\t// surrogate pair\n\t\t\thigh < 0 ?\n\t\t\t\tString.fromCharCode( high + 0x10000 ) :\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 ) + \"\\\\\" +\n\t\t\t\tch.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\tinDisabledFieldset = addCombinator(\n\t\tfunction( elem ) {\n\t\t\treturn elem.disabled === true && elem.nodeName.toLowerCase() === \"fieldset\";\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\n\t// Support: Android<4.0\n\t// Detect silently failing push.apply\n\t// eslint-disable-next-line no-unused-expressions\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\tpushNative.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\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\t\tsetDocument( context );\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!nonnativeSelectorCache[ selector + \" \" ] &&\n\t\t\t\t( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&\n\n\t\t\t\t// Support: IE 8 only\n\t\t\t\t// Exclude object elements\n\t\t\t\t( nodeType !== 1 || context.nodeName.toLowerCase() !== \"object\" ) ) {\n\n\t\t\t\tnewSelector = selector;\n\t\t\t\tnewContext = context;\n\n\t\t\t\t// qSA considers elements outside a scoping root when evaluating child or\n\t\t\t\t// descendant combinators, which is not what we want.\n\t\t\t\t// In such cases, we work around the behavior by prefixing every selector in the\n\t\t\t\t// list with an ID selector referencing the scope context.\n\t\t\t\t// The technique has to be used as well when a leading combinator is used\n\t\t\t\t// as such selectors are not recognized by querySelectorAll.\n\t\t\t\t// Thanks to Andrew Dupont for this technique.\n\t\t\t\tif ( nodeType === 1 &&\n\t\t\t\t\t( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {\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\n\t\t\t\t\t// We can use :scope instead of the ID hack if the browser\n\t\t\t\t\t// supports it & if we're not changing the context.\n\t\t\t\t\tif ( newContext !== context || !support.scope ) {\n\n\t\t\t\t\t\t// Capture the context ID, setting it first if necessary\n\t\t\t\t\t\tif ( ( nid = context.getAttribute( \"id\" ) ) ) {\n\t\t\t\t\t\t\tnid = nid.replace( rcssescape, fcssescape );\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tcontext.setAttribute( \"id\", ( nid = expando ) );\n\t\t\t\t\t\t}\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 ? \"#\" + nid : \":scope\" ) + \" \" +\n\t\t\t\t\t\t\ttoSelector( groups[ i ] );\n\t\t\t\t\t}\n\t\t\t\t\tnewSelector = groups.join( \",\" );\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tpush.apply( results,\n\t\t\t\t\t\tnewContext.querySelectorAll( newSelector )\n\t\t\t\t\t);\n\t\t\t\t\treturn results;\n\t\t\t\t} catch ( qsaError ) {\n\t\t\t\t\tnonnativeSelectorCache( selector, true );\n\t\t\t\t} finally {\n\t\t\t\t\tif ( nid === expando ) {\n\t\t\t\t\t\tcontext.removeAttribute( \"id\" );\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\n\t\t// Use (key + \" \") to avoid collision with native prototype properties (see Issue #157)\n\t\tif ( keys.push( key + \" \" ) > Expr.cacheLength ) {\n\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\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\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\tinDisabledFieldset( 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\tvar namespace = elem && elem.namespaceURI,\n\t\tdocElem = elem && ( elem.ownerDocument || elem ).documentElement;\n\n\t// Support: IE <=8\n\t// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes\n\t// https://bugs.jquery.com/ticket/4833\n\treturn !rhtml.test( namespace || docElem && docElem.nodeName || \"HTML\" );\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\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\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 12 - 18+\n\t// Accessing iframe documents after unload throws \"permission denied\" errors (jQuery #13936)\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\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// Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,\n\t// Safari 4 - 5 only, Opera <=11.6 - 12.x only\n\t// IE/Edge & older browsers don't support the :scope pseudo-class.\n\t// Support: Safari 6.0 only\n\t// Safari 6.0 supports :scope but it's an alias of :root there.\n\tsupport.scope = assert( function( el ) {\n\t\tdocElem.appendChild( el ).appendChild( document.createElement( \"div\" ) );\n\t\treturn typeof el.querySelectorAll !== \"undefined\" &&\n\t\t\t!el.querySelectorAll( \":scope fieldset div\" ).length;\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\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\n\t\t// Build QSA regex\n\t\t// Regex strategy adopted from Diego Perini\n\t\tassert( function( el ) {\n\n\t\t\tvar input;\n\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// Support: IE 11+, Edge 15 - 18+\n\t\t\t// IE 11/Edge don't find elements on a `[name='']` query in some cases.\n\t\t\t// Adding a temporary attribute to the document before the selection works\n\t\t\t// around the issue.\n\t\t\t// Interestingly, IE 10 & older don't seem to have the issue.\n\t\t\tinput = document.createElement( \"input\" );\n\t\t\tinput.setAttribute( \"name\", \"\" );\n\t\t\tel.appendChild( input );\n\t\t\tif ( !el.querySelectorAll( \"[name='']\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*name\" + whitespace + \"*=\" +\n\t\t\t\t\twhitespace + \"*(?:''|\\\"\\\")\" );\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\n\t\t\t// Support: Firefox <=3.6 - 5 only\n\t\t\t// Old Firefox doesn't throw on a badly-escaped identifier.\n\t\t\tel.querySelectorAll( \"\\\\\\f\" );\n\t\t\trbuggyQSA.push( \"[\\\\r\\\\n\\\\f]\" );\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// Support: Opera 10 - 11 only\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\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\t// Support: IE 11+, Edge 17 - 18+\n\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t// two documents; shallow comparisons work.\n\t\t// eslint-disable-next-line eqeqeq\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\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tif ( a == document || a.ownerDocument == preferredDoc &&\n\t\t\t\tcontains( preferredDoc, a ) ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tif ( b == document || b.ownerDocument == preferredDoc &&\n\t\t\t\tcontains( 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\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\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t/* eslint-disable eqeqeq */\n\t\t\treturn a == document ? -1 :\n\t\t\t\tb == document ? 1 :\n\t\t\t\t/* eslint-enable eqeqeq */\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\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\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t/* eslint-disable eqeqeq */\n\t\t\tap[ i ] == preferredDoc ? -1 :\n\t\t\tbp[ i ] == preferredDoc ? 1 :\n\t\t\t/* eslint-enable eqeqeq */\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\tsetDocument( elem );\n\n\tif ( support.matchesSelector && documentIsHTML &&\n\t\t!nonnativeSelectorCache[ 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\n\t\t\t\t// As well, disconnected nodes are said to be in a document\n\t\t\t\t// fragment in IE 9\n\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\t\tnonnativeSelectorCache( expr, true );\n\t\t}\n\t}\n\n\treturn Sizzle( expr, document, null, [ elem ] ).length > 0;\n};\n\nSizzle.contains = function( context, elem ) {\n\n\t// Set document vars if needed\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\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\n\t// Set document vars if needed\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( ( elem.ownerDocument || elem ) != document ) {\n\t\tsetDocument( elem );\n\t}\n\n\tvar fn = Expr.attrHandle[ name.toLowerCase() ],\n\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\n\t\t// If no nodeType, this is expected to be an array\n\t\twhile ( ( node = elem[ i++ ] ) ) {\n\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\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\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\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 ] ||\n\t\t\t\tmatch[ 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\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\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 ] ?\n\t\t\t\t\tmatch[ 5 ] + ( match[ 6 ] || 1 ) :\n\t\t\t\t\t2 * ( match[ 3 ] === \"even\" || match[ 3 ] === \"odd\" ) );\n\t\t\t\tmatch[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === \"odd\" );\n\n\t\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\n\t\t\t\t// Get excess from tokenize (recursively)\n\t\t\t\t( excess = tokenize( unquoted, true ) ) &&\n\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() {\n\t\t\t\t\treturn true;\n\t\t\t\t} :\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 +\n\t\t\t\t\t\")\" + className + \"(\" + whitespace + \"|$)\" ) ) && classCache(\n\t\t\t\t\t\tclassName, function( elem ) {\n\t\t\t\t\t\t\treturn pattern.test(\n\t\t\t\t\t\t\t\ttypeof elem.className === \"string\" && elem.className ||\n\t\t\t\t\t\t\t\ttypeof elem.getAttribute !== \"undefined\" &&\n\t\t\t\t\t\t\t\t\telem.getAttribute( \"class\" ) ||\n\t\t\t\t\t\t\t\t\"\"\n\t\t\t\t\t\t\t);\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\t/* eslint-disable max-len */\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\t/* eslint-enable max-len */\n\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\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\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\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\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 ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t( 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\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\n\t\t// Potentially complex pseudos\n\t\t\"not\": markFunction( function( selector ) {\n\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\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 || 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\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 &&\n\t\t\t\t( !document.hasFocus || document.hasFocus() ) &&\n\t\t\t\t!!( 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\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 ) ||\n\t\t\t\t( nodeName === \"option\" && !!elem.selected );\n\t\t},\n\n\t\t\"selected\": function( elem ) {\n\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\t// eslint-disable-next-line no-unused-expressions\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\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 ||\n\t\t\t\t\tattr.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 ?\n\t\t\t\targument + length :\n\t\t\t\targument > length ?\n\t\t\t\t\tlength :\n\t\t\t\t\targument;\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\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\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\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\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 ] ||\n\t\t\t\t\t\t\t( 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\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(\n\t\t\t\tselector || \"*\",\n\t\t\t\tcontext.nodeType ? [ context ] : context,\n\t\t\t\t[]\n\t\t\t),\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\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\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\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\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\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\n\t\t\t\t\t// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\t\t\t\t\ttokens\n\t\t\t\t\t\t.slice( 0, i - 1 )\n\t\t\t\t\t\t.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\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\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\n\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t// eslint-disable-next-line eqeqeq\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\n\t\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\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\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\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\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(\n\t\t\tselector,\n\t\t\tmatcherFromGroupMatchers( elementMatchers, setMatchers )\n\t\t);\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\tcontext.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {\n\n\t\t\tcontext = ( Expr.find[ \"ID\" ]( token.matches[ 0 ]\n\t\t\t\t.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\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 ) ||\n\t\t\t\t\t\tcontext\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\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( val = elem.getAttributeNode( name ) ) && val.specified ?\n\t\t\t\t\tval.value :\n\t\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\treturn 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\n// Implement the identical functionality for filter and not\nfunction winnow( elements, qualifier, not ) {\n\tif ( 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// Filtered directly for both simple and complex selectors\n\treturn jQuery.filter( qualifier, elements, not );\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 ( 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 ( 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\t\tif ( elem.contentDocument != null &&\n\n\t\t\t// Support: IE 11+\n\t\t\t// <object> elements with no `data` attribute has an object\n\t\t\t// `contentDocument` with a `null` prototype.\n\t\t\tgetProto( elem.contentDocument ) ) {\n\n\t\t\treturn elem.contentDocument;\n\t\t}\n\n\t\t// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only\n\t\t// Treat the template element as a regular one in browsers that\n\t\t// don't support it.\n\t\tif ( nodeName( elem, \"template\" ) ) {\n\t\t\telem = elem.content || elem;\n\t\t}\n\n\t\treturn 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 ( 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 && toType( 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 && 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 && 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 = 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 && 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 ( 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\tisFunction( 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\tisFunction( 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\tisFunction( 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// rejected_handlers.disable\n\t\t\t\t\t// fulfilled_handlers.disable\n\t\t\t\t\ttuples[ 3 - i ][ 3 ].disable,\n\n\t\t\t\t\t// progress_callbacks.lock\n\t\t\t\t\ttuples[ 0 ][ 2 ].lock,\n\n\t\t\t\t\t// progress_handlers.lock\n\t\t\t\t\ttuples[ 0 ][ 3 ].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 primary Deferred\n\t\t\tprimary = 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\tprimary.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, primary.done( updateFunc( i ) ).resolve, primary.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 ( primary.state() === \"pending\" ||\n\t\t\t\tisFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {\n\n\t\t\t\treturn primary.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 ), primary.reject );\n\t\t}\n\n\t\treturn primary.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 ( toType( 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 ( !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\t\tvalue :\n\t\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};\n\n\n// Matches dashed string for camelizing\nvar rmsPrefix = /^-ms-/,\n\trdashAlpha = /-([a-z])/g;\n\n// Used by camelCase as callback to replace()\nfunction fcamelCase( _all, letter ) {\n\treturn letter.toUpperCase();\n}\n\n// Convert dashed to camelCase; used by the css and data modules\n// Support: IE <=9 - 11, Edge 12 - 15\n// Microsoft forgot to hump their vendor prefix (#9572)\nfunction camelCase( string ) {\n\treturn string.replace( rmsPrefix, \"ms-\" ).replace( rdashAlpha, fcamelCase );\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[ 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[ 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 ][ 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( camelCase );\n\t\t\t} else {\n\t\t\t\tkey = 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 = 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 documentElement = document.documentElement;\n\n\n\n\tvar isAttached = function( elem ) {\n\t\t\treturn jQuery.contains( elem.ownerDocument, elem );\n\t\t},\n\t\tcomposed = { composed: true };\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only\n\t// Check attachment across shadow DOM boundaries when possible (gh-3504)\n\t// Support: iOS 10.0-10.2 only\n\t// Early iOS 10 versions support `attachShadow` but not `getRootNode`,\n\t// leading to errors. We need to check for `getRootNode`.\n\tif ( documentElement.getRootNode ) {\n\t\tisAttached = function( elem ) {\n\t\t\treturn jQuery.contains( elem.ownerDocument, elem ) ||\n\t\t\t\telem.getRootNode( composed ) === elem.ownerDocument;\n\t\t};\n\t}\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\tisAttached( elem ) &&\n\n\t\t\tjQuery.css( elem, \"display\" ) === \"none\";\n\t};\n\n\n\nfunction adjustCSS( elem, prop, valueParts, tween ) {\n\tvar adjusted, scale,\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 = elem.nodeType &&\n\t\t\t( 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// Support: Firefox <=54\n\t\t// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)\n\t\tinitial = initial / 2;\n\n\t\t// Trust units reported by jQuery.css\n\t\tunit = unit || initialInUnit[ 3 ];\n\n\t\t// Iteratively approximate from a nonzero starting point\n\t\tinitialInUnit = +initial || 1;\n\n\t\twhile ( maxIterations-- ) {\n\n\t\t\t// Evaluate and update our best guess (doubling guesses that zero out).\n\t\t\t// Finish if the scale equals or crosses 1 (making the old*new product non-positive).\n\t\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\t\t\tif ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {\n\t\t\t\tmaxIterations = 0;\n\t\t\t}\n\t\t\tinitialInUnit = initialInUnit / scale;\n\n\t\t}\n\n\t\tinitialInUnit = initialInUnit * 2;\n\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\n\t\t// Make sure we update the tween properties later on\n\t\tvalueParts = valueParts || [];\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 = ( /^$|^module$|\\/(?:java|ecma)script/i );\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\n\t// Support: IE <=9 only\n\t// IE <=9 replaces <option> tags with their contents when inserted outside of\n\t// the select element.\n\tdiv.innerHTML = \"<option></option>\";\n\tsupport.option = !!div.lastChild;\n} )();\n\n\n// We have to close these tags to support XHTML (#13200)\nvar wrapMap = {\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\nwrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\nwrapMap.th = wrapMap.td;\n\n// Support: IE <=9 only\nif ( !support.option ) {\n\twrapMap.optgroup = wrapMap.option = [ 1, \"<select multiple='multiple'>\", \"</select>\" ];\n}\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, attached, 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 ( toType( 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\tattached = isAttached( 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 ( attached ) {\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\nvar rtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\nfunction returnTrue() {\n\treturn true;\n}\n\nfunction returnFalse() {\n\treturn false;\n}\n\n// Support: IE <=9 - 11+\n// focus() and blur() are asynchronous, except when they are no-op.\n// So expect focus to be synchronous when the element is already active,\n// and blur to be synchronous when the element is not already active.\n// (focus and blur are always synchronous in other supported browsers,\n// this just defines when we can count on it).\nfunction expectSync( elem, type ) {\n\treturn ( elem === safeActiveElement() ) === ( type === \"focus\" );\n}\n\n// Support: IE <=9 only\n// Accessing document.activeElement can throw unexpectedly\n// https://bugs.jquery.com/ticket/13393\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// Only attach events to objects that accept data\n\t\tif ( !acceptData( elem ) ) {\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 = Object.create( null );\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\tvar i, j, ret, matched, handleObj, handlerQueue,\n\t\t\targs = new Array( arguments.length ),\n\n\t\t\t// Make a writable jQuery.Event from the native event object\n\t\t\tevent = jQuery.event.fix( nativeEvent ),\n\n\t\t\thandlers = (\n\t\t\t\tdataPriv.get( this, \"events\" ) || Object.create( null )\n\t\t\t)[ 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// If the event is namespaced, then each handler is only invoked if it is\n\t\t\t\t// specially universal or its namespaces are a superset of the event's.\n\t\t\t\tif ( !event.rnamespace || handleObj.namespace === false ||\n\t\t\t\t\tevent.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: isFunction( hook ) ?\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\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\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\tclick: {\n\n\t\t\t// Utilize native event to ensure correct state for checkable inputs\n\t\t\tsetup: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Claim the first handler\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\t// dataPriv.set( el, \"click\", ... )\n\t\t\t\t\tleverageNative( el, \"click\", returnTrue );\n\t\t\t\t}\n\n\t\t\t\t// Return false to allow normal processing in the caller\n\t\t\t\treturn false;\n\t\t\t},\n\t\t\ttrigger: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Force setup before triggering a click\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\tleverageNative( el, \"click\" );\n\t\t\t\t}\n\n\t\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\t\treturn true;\n\t\t\t},\n\n\t\t\t// For cross-browser consistency, suppress native .click() on links\n\t\t\t// Also prevent it if we're currently inside a leveraged native-event stack\n\t\t\t_default: function( event ) {\n\t\t\t\tvar target = event.target;\n\t\t\t\treturn rcheckableType.test( target.type ) &&\n\t\t\t\t\ttarget.click && nodeName( target, \"input\" ) &&\n\t\t\t\t\tdataPriv.get( target, \"click\" ) ||\n\t\t\t\t\tnodeName( 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\n// Ensure the presence of an event listener that handles manually-triggered\n// synthetic events by interrupting progress until reinvoked in response to\n// *native* events that it fires directly, ensuring that state changes have\n// already occurred before other listeners are invoked.\nfunction leverageNative( el, type, expectSync ) {\n\n\t// Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add\n\tif ( !expectSync ) {\n\t\tif ( dataPriv.get( el, type ) === undefined ) {\n\t\t\tjQuery.event.add( el, type, returnTrue );\n\t\t}\n\t\treturn;\n\t}\n\n\t// Register the controller as a special universal handler for all event namespaces\n\tdataPriv.set( el, type, false );\n\tjQuery.event.add( el, type, {\n\t\tnamespace: false,\n\t\thandler: function( event ) {\n\t\t\tvar notAsync, result,\n\t\t\t\tsaved = dataPriv.get( this, type );\n\n\t\t\tif ( ( event.isTrigger & 1 ) && this[ type ] ) {\n\n\t\t\t\t// Interrupt processing of the outer synthetic .trigger()ed event\n\t\t\t\t// Saved data should be false in such cases, but might be a leftover capture object\n\t\t\t\t// from an async native handler (gh-4350)\n\t\t\t\tif ( !saved.length ) {\n\n\t\t\t\t\t// Store arguments for use when handling the inner native event\n\t\t\t\t\t// There will always be at least one argument (an event object), so this array\n\t\t\t\t\t// will not be confused with a leftover capture object.\n\t\t\t\t\tsaved = slice.call( arguments );\n\t\t\t\t\tdataPriv.set( this, type, saved );\n\n\t\t\t\t\t// Trigger the native event and capture its result\n\t\t\t\t\t// Support: IE <=9 - 11+\n\t\t\t\t\t// focus() and blur() are asynchronous\n\t\t\t\t\tnotAsync = expectSync( this, type );\n\t\t\t\t\tthis[ type ]();\n\t\t\t\t\tresult = dataPriv.get( this, type );\n\t\t\t\t\tif ( saved !== result || notAsync ) {\n\t\t\t\t\t\tdataPriv.set( this, type, false );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tresult = {};\n\t\t\t\t\t}\n\t\t\t\t\tif ( saved !== result ) {\n\n\t\t\t\t\t\t// Cancel the outer synthetic event\n\t\t\t\t\t\tevent.stopImmediatePropagation();\n\t\t\t\t\t\tevent.preventDefault();\n\n\t\t\t\t\t\t// Support: Chrome 86+\n\t\t\t\t\t\t// In Chrome, if an element having a focusout handler is blurred by\n\t\t\t\t\t\t// clicking outside of it, it invokes the handler synchronously. If\n\t\t\t\t\t\t// that handler calls `.remove()` on the element, the data is cleared,\n\t\t\t\t\t\t// leaving `result` undefined. We need to guard against this.\n\t\t\t\t\t\treturn result && result.value;\n\t\t\t\t\t}\n\n\t\t\t\t// If this is an inner synthetic event for an event with a bubbling surrogate\n\t\t\t\t// (focus or blur), assume that the surrogate already propagated from triggering the\n\t\t\t\t// native event and prevent that from happening again here.\n\t\t\t\t// This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the\n\t\t\t\t// bubbling surrogate propagates *after* the non-bubbling base), but that seems\n\t\t\t\t// less bad than duplication.\n\t\t\t\t} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\n\t\t\t// If this is a native event triggered above, everything is now in order\n\t\t\t// Fire an inner synthetic event with the original arguments\n\t\t\t} else if ( saved.length ) {\n\n\t\t\t\t// ...and capture the result\n\t\t\t\tdataPriv.set( this, type, {\n\t\t\t\t\tvalue: jQuery.event.trigger(\n\n\t\t\t\t\t\t// Support: IE <=9 - 11+\n\t\t\t\t\t\t// Extend with the prototype to reset the above stopImmediatePropagation()\n\t\t\t\t\t\tjQuery.extend( saved[ 0 ], jQuery.Event.prototype ),\n\t\t\t\t\t\tsaved.slice( 1 ),\n\t\t\t\t\t\tthis\n\t\t\t\t\t)\n\t\t\t\t} );\n\n\t\t\t\t// Abort handling of the native event\n\t\t\t\tevent.stopImmediatePropagation();\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 || Date.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\tcode: 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\twhich: true\n}, jQuery.event.addProp );\n\njQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( type, delegateType ) {\n\tjQuery.event.special[ type ] = {\n\n\t\t// Utilize native event if possible so blur/focus sequence is correct\n\t\tsetup: function() {\n\n\t\t\t// Claim the first handler\n\t\t\t// dataPriv.set( this, \"focus\", ... )\n\t\t\t// dataPriv.set( this, \"blur\", ... )\n\t\t\tleverageNative( this, type, expectSync );\n\n\t\t\t// Return false to allow normal processing in the caller\n\t\t\treturn false;\n\t\t},\n\t\ttrigger: function() {\n\n\t\t\t// Force setup before trigger\n\t\t\tleverageNative( this, type );\n\n\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\treturn true;\n\t\t},\n\n\t\t// Suppress native focus or blur as it's already being fired\n\t\t// in leverageNative.\n\t\t_default: function() {\n\t\t\treturn true;\n\t\t},\n\n\t\tdelegateType: delegateType\n\t};\n} );\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// Support: IE <=10 - 11, Edge 12 - 13 only\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\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( elem ).children( \"tbody\" )[ 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\tif ( ( elem.type || \"\" ).slice( 0, 5 ) === \"true/\" ) {\n\t\telem.type = elem.type.slice( 5 );\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, 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.get( src );\n\t\tevents = pdataOld.events;\n\n\t\tif ( events ) {\n\t\t\tdataPriv.remove( dest, \"handle 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 = flat( 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\tvalueIsFunction = isFunction( value );\n\n\t// We can't cloneNode fragments that contain checked, in WebKit\n\tif ( valueIsFunction ||\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 ( valueIsFunction ) {\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 && ( node.type || \"\" ).toLowerCase()  !== \"module\" ) {\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 && !node.noModule ) {\n\t\t\t\t\t\t\t\tjQuery._evalUrl( node.src, {\n\t\t\t\t\t\t\t\t\tnonce: node.nonce || node.getAttribute( \"nonce\" )\n\t\t\t\t\t\t\t\t}, doc );\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, \"\" ), node, 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 && isAttached( 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;\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 = isAttached( 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 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\nvar swap = function( elem, options, callback ) {\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.call( elem );\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\nvar rboxStyle = new RegExp( cssExpand.join( \"|\" ), \"i\" );\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\tcontainer.style.cssText = \"position:absolute;left:-11111px;width:60px;\" +\n\t\t\t\"margin-top:1px;padding:0;border:0\";\n\t\tdiv.style.cssText =\n\t\t\t\"position:relative;display:block;box-sizing:border-box;overflow:scroll;\" +\n\t\t\t\"margin:auto;border:1px;padding:1px;\" +\n\t\t\t\"width:60%;top:1%\";\n\t\tdocumentElement.appendChild( container ).appendChild( div );\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 = roundPixelMeasures( divStyle.marginLeft ) === 12;\n\n\t\t// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3\n\t\t// Some styles come back with percentage values, even though they shouldn't\n\t\tdiv.style.right = \"60%\";\n\t\tpixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;\n\n\t\t// Support: IE 9 - 11 only\n\t\t// Detect misreporting of content dimensions for box-sizing:border-box elements\n\t\tboxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;\n\n\t\t// Support: IE 9 only\n\t\t// Detect overflow:scroll screwiness (gh-3699)\n\t\t// Support: Chrome <=64\n\t\t// Don't get tricked when zoom affects offsetWidth (gh-4029)\n\t\tdiv.style.position = \"absolute\";\n\t\tscrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;\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\tfunction roundPixelMeasures( measure ) {\n\t\treturn Math.round( parseFloat( measure ) );\n\t}\n\n\tvar pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,\n\t\treliableTrDimensionsVal, 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\tjQuery.extend( support, {\n\t\tboxSizingReliable: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn boxSizingReliableVal;\n\t\t},\n\t\tpixelBoxStyles: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelBoxStylesVal;\n\t\t},\n\t\tpixelPosition: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelPositionVal;\n\t\t},\n\t\treliableMarginLeft: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn reliableMarginLeftVal;\n\t\t},\n\t\tscrollboxSize: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn scrollboxSizeVal;\n\t\t},\n\n\t\t// Support: IE 9 - 11+, Edge 15 - 18+\n\t\t// IE/Edge misreport `getComputedStyle` of table rows with width/height\n\t\t// set in CSS while `offset*` properties report correct values.\n\t\t// Behavior in IE 9 is more subtle than in newer versions & it passes\n\t\t// some versions of this test; make sure not to make it pass there!\n\t\t//\n\t\t// Support: Firefox 70+\n\t\t// Only Firefox includes border widths\n\t\t// in computed dimensions. (gh-4529)\n\t\treliableTrDimensions: function() {\n\t\t\tvar table, tr, trChild, trStyle;\n\t\t\tif ( reliableTrDimensionsVal == null ) {\n\t\t\t\ttable = document.createElement( \"table\" );\n\t\t\t\ttr = document.createElement( \"tr\" );\n\t\t\t\ttrChild = document.createElement( \"div\" );\n\n\t\t\t\ttable.style.cssText = \"position:absolute;left:-11111px;border-collapse:separate\";\n\t\t\t\ttr.style.cssText = \"border:1px solid\";\n\n\t\t\t\t// Support: Chrome 86+\n\t\t\t\t// Height set through cssText does not get applied.\n\t\t\t\t// Computed height then comes back as 0.\n\t\t\t\ttr.style.height = \"1px\";\n\t\t\t\ttrChild.style.height = \"9px\";\n\n\t\t\t\t// Support: Android 8 Chrome 86+\n\t\t\t\t// In our bodyBackground.html iframe,\n\t\t\t\t// display for all div elements is set to \"inline\",\n\t\t\t\t// which causes a problem only in Android 8 Chrome 86.\n\t\t\t\t// Ensuring the div is display: block\n\t\t\t\t// gets around this issue.\n\t\t\t\ttrChild.style.display = \"block\";\n\n\t\t\t\tdocumentElement\n\t\t\t\t\t.appendChild( table )\n\t\t\t\t\t.appendChild( tr )\n\t\t\t\t\t.appendChild( trChild );\n\n\t\t\t\ttrStyle = window.getComputedStyle( tr );\n\t\t\t\treliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +\n\t\t\t\t\tparseInt( trStyle.borderTopWidth, 10 ) +\n\t\t\t\t\tparseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;\n\n\t\t\t\tdocumentElement.removeChild( table );\n\t\t\t}\n\t\t\treturn reliableTrDimensionsVal;\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 === \"\" && !isAttached( 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.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.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 cssPrefixes = [ \"Webkit\", \"Moz\", \"ms\" ],\n\temptyStyle = document.createElement( \"div\" ).style,\n\tvendorProps = {};\n\n// Return a vendor-prefixed property or undefined\nfunction vendorPropName( name ) {\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 potentially-mapped jQuery.cssProps or vendor prefixed property\nfunction finalPropName( name ) {\n\tvar final = jQuery.cssProps[ name ] || vendorProps[ name ];\n\n\tif ( final ) {\n\t\treturn final;\n\t}\n\tif ( name in emptyStyle ) {\n\t\treturn name;\n\t}\n\treturn vendorProps[ name ] = vendorPropName( name ) || name;\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\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 boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {\n\tvar i = dimension === \"width\" ? 1 : 0,\n\t\textra = 0,\n\t\tdelta = 0;\n\n\t// Adjustment may not be necessary\n\tif ( box === ( isBorderBox ? \"border\" : \"content\" ) ) {\n\t\treturn 0;\n\t}\n\n\tfor ( ; i < 4; i += 2 ) {\n\n\t\t// Both box models exclude margin\n\t\tif ( box === \"margin\" ) {\n\t\t\tdelta += jQuery.css( elem, box + cssExpand[ i ], true, styles );\n\t\t}\n\n\t\t// If we get here with a content-box, we're seeking \"padding\" or \"border\" or \"margin\"\n\t\tif ( !isBorderBox ) {\n\n\t\t\t// Add padding\n\t\t\tdelta += jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\n\t\t\t// For \"border\" or \"margin\", add border\n\t\t\tif ( box !== \"padding\" ) {\n\t\t\t\tdelta += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\n\t\t\t// But still keep track of it otherwise\n\t\t\t} else {\n\t\t\t\textra += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\n\t\t// If we get here with a border-box (content + padding + border), we're seeking \"content\" or\n\t\t// \"padding\" or \"margin\"\n\t\t} else {\n\n\t\t\t// For \"content\", subtract padding\n\t\t\tif ( box === \"content\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\t\t\t}\n\n\t\t\t// For \"content\" or \"padding\", subtract border\n\t\t\tif ( box !== \"margin\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Account for positive content-box scroll gutter when requested by providing computedVal\n\tif ( !isBorderBox && computedVal >= 0 ) {\n\n\t\t// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border\n\t\t// Assuming integer scroll gutter, subtract the rest and round down\n\t\tdelta += Math.max( 0, Math.ceil(\n\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\tcomputedVal -\n\t\t\tdelta -\n\t\t\textra -\n\t\t\t0.5\n\n\t\t// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter\n\t\t// Use an explicit zero to avoid NaN (gh-3964)\n\t\t) ) || 0;\n\t}\n\n\treturn delta;\n}\n\nfunction getWidthOrHeight( elem, dimension, extra ) {\n\n\t// Start with computed style\n\tvar styles = getStyles( elem ),\n\n\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).\n\t\t// Fake content-box until we know it's needed to know the true value.\n\t\tboxSizingNeeded = !support.boxSizingReliable() || extra,\n\t\tisBorderBox = boxSizingNeeded &&\n\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\tvalueIsBorderBox = isBorderBox,\n\n\t\tval = curCSS( elem, dimension, styles ),\n\t\toffsetProp = \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );\n\n\t// Support: Firefox <=54\n\t// Return a confounding non-pixel value or feign ignorance, as appropriate.\n\tif ( rnumnonpx.test( val ) ) {\n\t\tif ( !extra ) {\n\t\t\treturn val;\n\t\t}\n\t\tval = \"auto\";\n\t}\n\n\n\t// Support: IE 9 - 11 only\n\t// Use offsetWidth/offsetHeight for when box sizing is unreliable.\n\t// In those cases, the computed value can be trusted to be border-box.\n\tif ( ( !support.boxSizingReliable() && isBorderBox ||\n\n\t\t// Support: IE 10 - 11+, Edge 15 - 18+\n\t\t// IE/Edge misreport `getComputedStyle` of table rows with width/height\n\t\t// set in CSS while `offset*` properties report correct values.\n\t\t// Interestingly, in some cases IE 9 doesn't suffer from this issue.\n\t\t!support.reliableTrDimensions() && nodeName( elem, \"tr\" ) ||\n\n\t\t// Fall back to offsetWidth/offsetHeight when value is \"auto\"\n\t\t// This happens for inline elements with no explicit setting (gh-3571)\n\t\tval === \"auto\" ||\n\n\t\t// Support: Android <=4.1 - 4.3 only\n\t\t// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)\n\t\t!parseFloat( val ) && jQuery.css( elem, \"display\", false, styles ) === \"inline\" ) &&\n\n\t\t// Make sure the element is visible & connected\n\t\telem.getClientRects().length ) {\n\n\t\tisBorderBox = jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\";\n\n\t\t// Where available, offsetWidth/offsetHeight approximate border box dimensions.\n\t\t// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the\n\t\t// retrieved value as a content box dimension.\n\t\tvalueIsBorderBox = offsetProp in elem;\n\t\tif ( valueIsBorderBox ) {\n\t\t\tval = elem[ offsetProp ];\n\t\t}\n\t}\n\n\t// Normalize \"\" and auto\n\tval = parseFloat( val ) || 0;\n\n\t// Adjust for the element's box model\n\treturn ( val +\n\t\tboxModelAdjustment(\n\t\t\telem,\n\t\t\tdimension,\n\t\t\textra || ( isBorderBox ? \"border\" : \"content\" ),\n\t\t\tvalueIsBorderBox,\n\t\t\tstyles,\n\n\t\t\t// Provide the current computed size to request scroll gutter calculation (gh-3589)\n\t\t\tval\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\"gridArea\": true,\n\t\t\"gridColumn\": true,\n\t\t\"gridColumnEnd\": true,\n\t\t\"gridColumnStart\": true,\n\t\t\"gridRow\": true,\n\t\t\"gridRowEnd\": true,\n\t\t\"gridRowStart\": 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\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 = 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\t// The isCustomProp check can be removed in jQuery 4.0 when we only auto-append\n\t\t\t// \"px\" to a few hardcoded values.\n\t\t\tif ( type === \"number\" && !isCustomProp ) {\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 = 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, dimension ) {\n\tjQuery.cssHooks[ dimension ] = {\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\tswap( elem, cssShow, function() {\n\t\t\t\t\t\treturn getWidthOrHeight( elem, dimension, extra );\n\t\t\t\t\t} ) :\n\t\t\t\t\tgetWidthOrHeight( elem, dimension, 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 = getStyles( elem ),\n\n\t\t\t\t// Only read styles.position if the test has a chance to fail\n\t\t\t\t// to avoid forcing a reflow.\n\t\t\t\tscrollboxSizeBuggy = !support.scrollboxSize() &&\n\t\t\t\t\tstyles.position === \"absolute\",\n\n\t\t\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)\n\t\t\t\tboxSizingNeeded = scrollboxSizeBuggy || extra,\n\t\t\t\tisBorderBox = boxSizingNeeded &&\n\t\t\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\t\t\tsubtract = extra ?\n\t\t\t\t\tboxModelAdjustment(\n\t\t\t\t\t\telem,\n\t\t\t\t\t\tdimension,\n\t\t\t\t\t\textra,\n\t\t\t\t\t\tisBorderBox,\n\t\t\t\t\t\tstyles\n\t\t\t\t\t) :\n\t\t\t\t\t0;\n\n\t\t\t// Account for unreliable border-box dimensions by comparing offset* to computed and\n\t\t\t// faking a content-box to get border and padding (gh-3699)\n\t\t\tif ( isBorderBox && scrollboxSizeBuggy ) {\n\t\t\t\tsubtract -= Math.ceil(\n\t\t\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\t\t\tparseFloat( styles[ dimension ] ) -\n\t\t\t\t\tboxModelAdjustment( elem, dimension, \"border\", false, styles ) -\n\t\t\t\t\t0.5\n\t\t\t\t);\n\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[ dimension ] = value;\n\t\t\t\tvalue = jQuery.css( elem, dimension );\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) + \"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 ( prefix !== \"margin\" ) {\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\tjQuery.cssHooks[ tween.prop ] ||\n\t\t\t\t\ttween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {\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 = Date.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 - 15\n\t\t// Record all 3 overflow attributes because IE does not infer the shorthand\n\t\t// from identically-valued overflowX and overflowY and Edge just mirrors\n\t\t// the overflowX value there.\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\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 = 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\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 ( isFunction( result.stop ) ) {\n\t\t\t\tjQuery._queueHooks( animation.elem, animation.opts.queue ).stop =\n\t\t\t\t\tresult.stop.bind( 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 ( 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 ( 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\tisFunction( speed ) && speed,\n\t\tduration: speed,\n\t\teasing: fn && easing || easing && !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 ( 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\n\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 ) {\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 = Date.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://infra.spec.whatwg.org/#strip-and-collapse-ascii-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\nfunction classesToArray( value ) {\n\tif ( Array.isArray( value ) ) {\n\t\treturn value;\n\t}\n\tif ( typeof value === \"string\" ) {\n\t\treturn value.match( rnothtmlwhite ) || [];\n\t}\n\treturn [];\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 ( 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\tclasses = classesToArray( value );\n\n\t\tif ( classes.length ) {\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 ( 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\tclasses = classesToArray( value );\n\n\t\tif ( classes.length ) {\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\t\t\tisValidValue = type === \"string\" || Array.isArray( value );\n\n\t\tif ( typeof stateVal === \"boolean\" && isValidValue ) {\n\t\t\treturn stateVal ? this.addClass( value ) : this.removeClass( value );\n\t\t}\n\n\t\tif ( 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 ( isValidValue ) {\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 = classesToArray( value );\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\t\"\" :\n\t\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\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, valueIsFunction,\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\tvalueIsFunction = 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 ( valueIsFunction ) {\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\nsupport.focusin = \"onfocusin\" in window;\n\n\nvar rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\n\tstopPropagationCallback = function( e ) {\n\t\te.stopPropagation();\n\t};\n\njQuery.extend( jQuery.event, {\n\n\ttrigger: function( event, data, elem, onlyHandlers ) {\n\n\t\tvar i, cur, tmp, bubbleType, ontype, handle, special, lastElement,\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 = lastElement = 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 && !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\t\t\tlastElement = cur;\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\" ) || Object.create( null ) )[ 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 && isFunction( elem[ type ] ) && !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\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.addEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\telem[ type ]();\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.removeEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\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\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\n\t\t\t\t// Handle: regular nodes (via `this.ownerDocument`), window\n\t\t\t\t// (via `this.document`) & document (via `this`).\n\t\t\t\tvar doc = this.ownerDocument || this.document || 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.document || 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 = { guid: Date.now() };\n\nvar rquery = ( /\\?/ );\n\n\n\n// Cross-browser xml parsing\njQuery.parseXML = function( data ) {\n\tvar xml, parserErrorElem;\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\n\tparserErrorElem = xml && xml.getElementsByTagName( \"parsererror\" )[ 0 ];\n\tif ( !xml || parserErrorElem ) {\n\t\tjQuery.error( \"Invalid XML: \" + (\n\t\t\tparserErrorElem ?\n\t\t\t\tjQuery.map( parserErrorElem.childNodes, function( el ) {\n\t\t\t\t\treturn el.textContent;\n\t\t\t\t} ).join( \"\\n\" ) :\n\t\t\t\tdata\n\t\t) );\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 && toType( 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 = 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\tif ( a == null ) {\n\t\treturn \"\";\n\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} ).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} ).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\noriginAnchor.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 ( 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\tjQuery( callbackContext ) :\n\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() + \" \" ] =\n\t\t\t\t\t\t\t\t\t( responseHeaders[ match[ 1 ].toLowerCase() + \" \" ] || [] )\n\t\t\t\t\t\t\t\t\t\t.concat( 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.join( \", \" );\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 - 15\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 and should be processed, append data to url\n\t\t\tif ( s.data && ( s.processData || typeof s.data === \"string\" ) ) {\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.guid++ ) +\n\t\t\t\t\tuncached;\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// Use a noop converter for missing script but not if jsonp\n\t\t\tif ( !isSuccess &&\n\t\t\t\tjQuery.inArray( \"script\", s.dataTypes ) > -1 &&\n\t\t\t\tjQuery.inArray( \"json\", s.dataTypes ) < 0 ) {\n\t\t\t\ts.converters[ \"text script\" ] = function() {};\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 ( 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\njQuery.ajaxPrefilter( function( s ) {\n\tvar i;\n\tfor ( i in s.headers ) {\n\t\tif ( i.toLowerCase() === \"content-type\" ) {\n\t\t\ts.contentType = s.headers[ i ] || \"\";\n\t\t}\n\t}\n} );\n\n\njQuery._evalUrl = function( url, options, doc ) {\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\n\t\t// Only evaluate the response if it is successful (gh-4126)\n\t\t// dataFilter is not invoked for failure responses, so using it instead\n\t\t// of the default converter is kludgy but it works.\n\t\tconverters: {\n\t\t\t\"text script\": function() {}\n\t\t},\n\t\tdataFilter: function( response ) {\n\t\t\tjQuery.globalEval( response, options, doc );\n\t\t}\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 ( 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 ( 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 htmlIsFunction = isFunction( html );\n\n\t\treturn this.each( function( i ) {\n\t\t\tjQuery( this ).wrapAll( htmlIsFunction ? 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.ontimeout =\n\t\t\t\t\t\t\t\t\txhr.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 = xhr.ontimeout = 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 or forced-by-attrs requests\n\tif ( s.crossDomain || s.scriptAttrs ) {\n\t\tvar script, callback;\n\t\treturn {\n\t\t\tsend: function( _, complete ) {\n\t\t\t\tscript = jQuery( \"<script>\" )\n\t\t\t\t\t.attr( s.scriptAttrs || {} )\n\t\t\t\t\t.prop( { charset: s.scriptCharset, src: s.url } )\n\t\t\t\t\t.on( \"load error\", callback = 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\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.guid++ ) );\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 = 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 && 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 ( 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\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 ( 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\n\t// offset() relates an element's border box to the document origin\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 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\t// Get document-relative position by adding viewport scroll to viewport-relative gBCR\n\t\trect = elem.getBoundingClientRect();\n\t\twin = elem.ownerDocument.defaultView;\n\t\treturn {\n\t\t\ttop: rect.top + win.pageYOffset,\n\t\t\tleft: rect.left + win.pageXOffset\n\t\t};\n\t},\n\n\t// position() relates an element's margin box to its offset parent's padding box\n\t// This corresponds to the behavior of CSS absolute positioning\n\tposition: function() {\n\t\tif ( !this[ 0 ] ) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar offsetParent, offset, doc,\n\t\t\telem = this[ 0 ],\n\t\t\tparentOffset = { top: 0, left: 0 };\n\n\t\t// position:fixed elements are offset from the viewport, which itself always has zero offset\n\t\tif ( jQuery.css( elem, \"position\" ) === \"fixed\" ) {\n\n\t\t\t// Assume position:fixed implies availability of getBoundingClientRect\n\t\t\toffset = elem.getBoundingClientRect();\n\n\t\t} else {\n\t\t\toffset = this.offset();\n\n\t\t\t// Account for the *real* offset parent, which can be the document or its root element\n\t\t\t// when a statically positioned element is identified\n\t\t\tdoc = elem.ownerDocument;\n\t\t\toffsetParent = elem.offsetParent || doc.documentElement;\n\t\t\twhile ( offsetParent &&\n\t\t\t\t( offsetParent === doc.body || offsetParent === doc.documentElement ) &&\n\t\t\t\tjQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\n\t\t\t\toffsetParent = offsetParent.parentNode;\n\t\t\t}\n\t\t\tif ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {\n\n\t\t\t\t// Incorporate borders into its offset, since they are outside its content origin\n\t\t\t\tparentOffset = jQuery( offsetParent ).offset();\n\t\t\t\tparentOffset.top += jQuery.css( offsetParent, \"borderTopWidth\", true );\n\t\t\t\tparentOffset.left += jQuery.css( offsetParent, \"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 ( 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( {\n\t\tpadding: \"inner\" + name,\n\t\tcontent: type,\n\t\t\"\": \"outer\" + name\n\t}, function( 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 ( 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.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.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\thover: function( fnOver, fnOut ) {\n\t\treturn this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );\n\t}\n} );\n\njQuery.each(\n\t( \"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\t// Handle event binding\n\t\tjQuery.fn[ name ] = function( data, fn ) {\n\t\t\treturn arguments.length > 0 ?\n\t\t\t\tthis.on( name, null, data, fn ) :\n\t\t\t\tthis.trigger( name );\n\t\t};\n\t}\n);\n\n\n\n\n// Support: Android <=4.0 only\n// Make sure we trim BOM and NBSP\nvar rtrim = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g;\n\n// Bind a function to a context, optionally partially applying any\n// arguments.\n// jQuery.proxy is deprecated to promote standards (specifically Function#bind)\n// However, it is not slated for removal any time soon\njQuery.proxy = function( fn, context ) {\n\tvar tmp, args, proxy;\n\n\tif ( typeof context === \"string\" ) {\n\t\ttmp = fn[ context ];\n\t\tcontext = fn;\n\t\tfn = tmp;\n\t}\n\n\t// Quick check to determine if target is callable, in the spec\n\t// this throws a TypeError, but we will just return undefined.\n\tif ( !isFunction( fn ) ) {\n\t\treturn undefined;\n\t}\n\n\t// Simulated bind\n\targs = slice.call( arguments, 2 );\n\tproxy = function() {\n\t\treturn fn.apply( context || this, args.concat( slice.call( arguments ) ) );\n\t};\n\n\t// Set the guid of unique handler to the same of original handler, so it can be removed\n\tproxy.guid = fn.guid = fn.guid || jQuery.guid++;\n\n\treturn proxy;\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;\njQuery.isFunction = isFunction;\njQuery.isWindow = isWindow;\njQuery.camelCase = camelCase;\njQuery.type = toType;\n\njQuery.now = Date.now;\n\njQuery.isNumeric = function( obj ) {\n\n\t// As of jQuery 3.0, isNumeric is limited to\n\t// strings and numbers (primitives or objects)\n\t// that can be coerced to finite numbers (gh-2662)\n\tvar type = jQuery.type( obj );\n\treturn ( type === \"number\" || type === \"string\" ) &&\n\n\t\t// parseFloat NaNs numeric-cast false positives (\"\")\n\t\t// ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n\t\t// subtraction forces infinities to NaN\n\t\t!isNaN( obj - parseFloat( obj ) );\n};\n\njQuery.trim = function( text ) {\n\treturn text == null ?\n\t\t\"\" :\n\t\t( text + \"\" ).replace( rtrim, \"\" );\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 ( typeof noGlobal === \"undefined\" ) {\n\twindow.jQuery = window.$ = jQuery;\n}\n\n\n\n\nreturn jQuery;\n} );\n","/**\n * @license\n * Lodash <https://lodash.com/>\n * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\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.21';\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      INVALID_TEMPL_VAR_ERROR_TEXT = 'Invalid `variable` option passed into `_.template`';\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      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 whitespace. */\n  var reTrimStart = /^\\s+/;\n\n  /** Used to match a single whitespace character. */\n  var reWhitespace = /\\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  /**\n   * Used to validate the `validate` option in `_.template` variable.\n   *\n   * Forbids characters which could potentially change the meaning of the function argument definition:\n   * - \"(),\" (modification of function parameters)\n   * - \"=\" (default value)\n   * - \"[]{}\" (destructuring of function parameters)\n   * - \"/\" (beginning of a comment)\n   * - whitespace\n   */\n  var reForbiddenIdentifierChars = /[()=,{}\\[\\]\\/\\s]/;\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|[A-Z_])',\n      rsOrdUpper = '\\\\d*(?:1ST|2ND|3RD|(?![123])\\\\dTH)(?=\\\\b|[a-z_])',\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      // Use `util.types` for Node.js 10+.\n      var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n      if (types) {\n        return types;\n      }\n\n      // Legacy `process.binding('util')` for Node.js < 10.\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   * 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 `_.trim`.\n   *\n   * @private\n   * @param {string} string The string to trim.\n   * @returns {string} Returns the trimmed string.\n   */\n  function baseTrim(string) {\n    return string\n      ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n      : string;\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 `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n   * character of `string`.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {number} Returns the index of the last non-whitespace character.\n   */\n  function trimmedEndIndex(string) {\n    var index = string.length;\n\n    while (index-- && reWhitespace.test(string.charAt(index))) {}\n    return index;\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, 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      if (isSet(value)) {\n        value.forEach(function(subValue) {\n          result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n        });\n      } else if (isMap(value)) {\n        value.forEach(function(subValue, key) {\n          result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n        });\n      }\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        stack || (stack = new Stack);\n        if (isObject(srcValue)) {\n          baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n        }\n        else {\n          var newValue = customizer\n            ? customizer(safeGet(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 = safeGet(object, key),\n          srcValue = safeGet(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) || 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      if (iteratees.length) {\n        iteratees = arrayMap(iteratees, function(iteratee) {\n          if (isArray(iteratee)) {\n            return function(value) {\n              return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);\n            }\n          }\n          return iteratee;\n        });\n      } else {\n        iteratees = [identity];\n      }\n\n      var index = -1;\n      iteratees = arrayMap(iteratees, 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 (key === '__proto__' || key === 'constructor' || key === 'prototype') {\n          return object;\n        }\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      var low = 0,\n          high = array == null ? 0 : array.length;\n      if (high === 0) {\n        return 0;\n      }\n\n      value = iteratee(value);\n      var 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 `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 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 && nativeIsFinite(number)) {\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      // Check that cyclic values are equal.\n      var arrStacked = stack.get(array);\n      var othStacked = stack.get(other);\n      if (arrStacked && othStacked) {\n        return arrStacked == other && othStacked == array;\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      // Check that cyclic values are equal.\n      var objStacked = stack.get(object);\n      var othStacked = stack.get(other);\n      if (objStacked && othStacked) {\n        return objStacked == other && othStacked == object;\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 = new 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`, `Map`, `Number`, `RegExp`, `Set`, 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 {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneByTag(object, tag, 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 new Ctor;\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 new Ctor;\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      var type = typeof value;\n      length = length == null ? MAX_SAFE_INTEGER : length;\n\n      return !!length &&\n        (type == 'number' ||\n          (type != 'symbol' && 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     * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\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 safeGet(object, key) {\n      if (key === 'constructor' && typeof object[key] === 'function') {\n        return;\n      }\n\n      if (key == '__proto__') {\n        return;\n      }\n\n      return object[key];\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 (string.charCodeAt(0) === 46 /* . */) {\n        result.push('');\n      }\n      string.replace(rePropName, function(match, number, quote, subString) {\n        result.push(quote ? subString.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     * // Combining several predicates using `_.overEvery` or `_.overSome`.\n     * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]]));\n     * // => objects for ['fred', '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': 30 },\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', 30]]\n     *\n     * _.sortBy(users, ['user', 'age']);\n     * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['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            timeWaiting = wait - timeSinceLastCall;\n\n        return maxing\n          ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n          : timeWaiting;\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            clearTimeout(timerId);\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 = baseTrim(value);\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(object, sources) {\n      object = Object(object);\n\n      var index = -1;\n      var length = sources.length;\n      var guard = length > 2 ? sources[2] : undefined;\n\n      if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n        length = 1;\n      }\n\n      while (++index < length) {\n        var source = sources[index];\n        var props = keysIn(source);\n        var propsIndex = -1;\n        var propsLength = props.length;\n\n        while (++propsIndex < propsLength) {\n          var key = props[propsIndex];\n          var value = object[key];\n\n          if (value === undefined ||\n              (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n            object[key] = source[key];\n          }\n        }\n      }\n\n      return object;\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      if (value != null &&\n          typeof value.toString != 'function') {\n        value = nativeObjectToString.call(value);\n      }\n\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 (value != null &&\n          typeof value.toString != 'function') {\n        value = nativeObjectToString.call(value);\n      }\n\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      // The sourceURL gets injected into the source that's eval-ed, so be careful\n      // to normalize all kinds of whitespace, so e.g. newlines (and unicode versions of it) can't sneak in\n      // and escape the comment, thus injecting code that gets evaled.\n      var sourceURL = '//# sourceURL=' +\n        (hasOwnProperty.call(options, 'sourceURL')\n          ? (options.sourceURL + '').replace(/\\s/g, ' ')\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 = hasOwnProperty.call(options, 'variable') && options.variable;\n      if (!variable) {\n        source = 'with (obj) {\\n' + source + '\\n}\\n';\n      }\n      // Throw an error if a forbidden character was found in `variable`, to prevent\n      // potential command injection attacks.\n      else if (reForbiddenIdentifierChars.test(variable)) {\n        throw new Error(INVALID_TEMPL_VAR_ERROR_TEXT);\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 baseTrim(string);\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.slice(0, trimmedEndIndex(string) + 1);\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     * **Note:** Multiple values can be checked by combining several matchers\n     * using `_.overSome`\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     * // Checking for several possible values\n     * _.filter(objects, _.overSome([_.matches({ 'a': 1 }), _.matches({ 'a': 4 })]));\n     * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { '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     * **Note:** Multiple values can be checked by combining several matchers\n     * using `_.overSome`\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     * // Checking for several possible values\n     * _.filter(objects, _.overSome([_.matchesProperty('a', 1), _.matchesProperty('a', 4)]));\n     * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { '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     * Following shorthands are possible for providing predicates.\n     * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.\n     * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.\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     * Following shorthands are possible for providing predicates.\n     * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.\n     * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.\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 matchesFunc = _.overSome([{ 'a': 1 }, { 'a': 2 }])\n     * var matchesPropertyFunc = _.overSome([['a', 1], ['a', 2]])\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        if (!hasOwnProperty.call(realNames, key)) {\n          realNames[key] = [];\n        }\n        realNames[key].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","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\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// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\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};","// no baseURI\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t773: 0,\n\t170: 0\n};\n\n// no chunk on demand loading\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n__webpack_require__.O.j = (chunkId) => (installedChunks[chunkId] === 0);\n\n// install a JSONP callback for chunk loading\nvar webpackJsonpCallback = (parentChunkLoadingFunction, data) => {\n\tvar [chunkIds, moreModules, runtime] = data;\n\t// add \"moreModules\" to the modules object,\n\t// then flag all \"chunkIds\" as loaded and fire callback\n\tvar moduleId, chunkId, i = 0;\n\tif(chunkIds.some((id) => (installedChunks[id] !== 0))) {\n\t\tfor(moduleId in moreModules) {\n\t\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t\t}\n\t\t}\n\t\tif(runtime) var result = runtime(__webpack_require__);\n\t}\n\tif(parentChunkLoadingFunction) parentChunkLoadingFunction(data);\n\tfor(;i < chunkIds.length; i++) {\n\t\tchunkId = chunkIds[i];\n\t\tif(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {\n\t\t\tinstalledChunks[chunkId][0]();\n\t\t}\n\t\tinstalledChunks[chunkId] = 0;\n\t}\n\treturn __webpack_require__.O(result);\n}\n\nvar chunkLoadingGlobal = self[\"webpackChunk\"] = self[\"webpackChunk\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));","// startup\n// Load entry module and return exports\n// This entry module depends on other loaded chunks and execution need to be delayed\n__webpack_require__.O(undefined, [170], () => (__webpack_require__(80)))\nvar __webpack_exports__ = __webpack_require__.O(undefined, [170], () => (__webpack_require__(425)))\n__webpack_exports__ = __webpack_require__.O(__webpack_exports__);\n"],"names":["deferred","module","exports","utils","settle","cookies","buildURL","buildFullPath","parseHeaders","isURLSameOrigin","createError","defaults","Cancel","config","Promise","resolve","reject","onCanceled","requestData","data","requestHeaders","headers","responseType","done","cancelToken","unsubscribe","signal","removeEventListener","isFormData","request","XMLHttpRequest","auth","username","password","unescape","encodeURIComponent","Authorization","btoa","fullPath","baseURL","url","onloadend","responseHeaders","getAllResponseHeaders","response","responseText","status","statusText","value","err","open","method","toUpperCase","params","paramsSerializer","timeout","onreadystatechange","readyState","responseURL","indexOf","setTimeout","onabort","onerror","ontimeout","timeoutErrorMessage","transitional","clarifyTimeoutError","isStandardBrowserEnv","xsrfValue","withCredentials","xsrfCookieName","read","undefined","xsrfHeaderName","forEach","val","key","toLowerCase","setRequestHeader","isUndefined","onDownloadProgress","addEventListener","onUploadProgress","upload","cancel","type","abort","subscribe","aborted","send","bind","Axios","mergeConfig","axios","createInstance","defaultConfig","context","instance","prototype","extend","create","instanceConfig","CancelToken","isCancel","VERSION","all","promises","spread","isAxiosError","message","this","toString","__CANCEL__","executor","TypeError","resolvePromise","promise","token","then","_listeners","i","l","length","onfulfilled","_resolve","reason","throwIfRequested","listener","push","index","splice","source","c","InterceptorManager","dispatchRequest","validator","validators","interceptors","configOrUrl","Error","assertOptions","silentJSONParsing","boolean","forcedJSONParsing","requestInterceptorChain","synchronousRequestInterceptors","interceptor","runWhen","synchronous","unshift","fulfilled","rejected","responseInterceptorChain","chain","Array","apply","concat","shift","newConfig","onFulfilled","onRejected","error","getUri","replace","handlers","use","options","eject","id","fn","h","isAbsoluteURL","combineURLs","requestedURL","enhanceError","code","transformData","throwIfCancellationRequested","call","transformRequest","merge","common","adapter","transformResponse","toJSON","name","description","number","fileName","lineNumber","columnNumber","stack","config1","config2","getMergedValue","target","isPlainObject","isArray","slice","mergeDeepProperties","prop","valueFromConfig2","defaultToConfig2","mergeDirectKeys","mergeMap","Object","keys","configValue","validateStatus","fns","normalizeHeaderName","DEFAULT_CONTENT_TYPE","setContentTypeIfUnset","process","isArrayBuffer","isBuffer","isStream","isFile","isBlob","isArrayBufferView","buffer","isURLSearchParams","isObject","rawValue","parser","encoder","isString","JSON","parse","trim","e","stringify","stringifySafely","strictJSONParsing","maxContentLength","maxBodyLength","thisArg","args","arguments","encode","serializedParams","parts","v","isDate","toISOString","join","hashmarkIndex","relativeURL","write","expires","path","domain","secure","cookie","isNumber","Date","toGMTString","document","match","RegExp","decodeURIComponent","remove","now","test","payload","originURL","msie","navigator","userAgent","urlParsingNode","createElement","resolveURL","href","setAttribute","protocol","host","search","hash","hostname","port","pathname","charAt","window","location","requestURL","parsed","normalizedName","ignoreDuplicateOf","split","line","substr","callback","arr","thing","deprecatedWarnings","version","formatMessage","opt","desc","opts","console","warn","schema","allowUnknown","result","getPrototypeOf","isFunction","obj","hasOwnProperty","constructor","ArrayBuffer","isView","pipe","product","assignValue","a","b","str","stripBOM","content","charCodeAt","require","FilePond","FilePondPluginFileRename","$","jQuery","log","modal_ui_triggers","init","bindEvents","cacheDom","on","openModal","closeModal","attr","removeClass","addClass","toggle_ui_triggers","$triggers","$targets","toggleTarget","closeAll","$target","toggleClass","hasClass","ready","top_nav_handler","dropdownHandler","element","getElementsByTagName","classList","toggle","MenuHandler","el","MainList","parentElement","closeIcon","getElementsByClassName","showIcon","add","activeFolderID","queryString","urlParams","URLSearchParams","has","parseInt","get","Livewire","folderId","not","each","$this","html","_","plugin","_ref","addFilter","Type","renameFile","getExtensionFromFilename","getFilenameWithoutExtension","file","_ref2","query","allowFileRename","renameFunction","newFilename","basename","extension","rename","BOOLEAN","fileRenameFunction","FUNCTION","dispatchEvent","CustomEvent","detail","factory","isNode","HTMLElement","createStore","initialState","queries","actions","state","assign","actionQueue","dispatchQueue","processDispatchQueue","queue","dispatch","isBlocking","hidden","actionHandlers","_queryHandles","_len","_key","queryHandles","api","getState","processActionQueue","action","defineProperty","property","definition","forin","cb","createObject","node","getAttribute","hasAttribute","ns","svgElements","isSVGElement","tag","includes","className","attributes","createElementNS","appendChild","parent","child","children","insertBefore","appendChildView","childViews","view","removeChildView","parentNode","removeChild","IS_BROWSER","isBrowser","getChildCount","childNodes","getViewRect","elementRect","offset","scale","left","top","right","width","bottom","height","rect","inner","outer","filter","childView","isRectIgnored","map","childViewRect","expandRect","calculateRectSize","marginBottom","marginRight","thereYet","position","destination","velocity","errorMargin","Math","abs","spring","_ref$stiffness","stiffness","_ref$damping","damping","_ref$mass","mass","resting","interpolate","ts","skipToEndState","onupdate","oncomplete","set","easeInOutQuad","t","tween","p","_ref$duration","duration","_ref$easing","easing","_ref$delay","delay","start","reverse","animator","createAnimator","category","def","props","addGetSet","overwrite","o","getter","setter","animations","mixinConfig","viewProps","viewInternalAPI","viewExternalAPI","initialProps","animation","destroy","addEvent","removeEvent","listeners","viewState","events","off","findIndex","event","isDefined","opacity","scaleX","scaleY","translateX","translateY","rotateX","rotateY","rotateZ","originX","originY","styles","currentProps","getOffset","getScale","getRect","propsHaveChanged","applyStyles","newProps","perspective","transforms","elementCurrentStyle","style","cssText","Mixins","apis","updateRect","layoutCalculated","paddingTop","marginTop","marginLeft","offsetLeft","offsetTop","offsetWidth","offsetHeight","scrollTop","offsetParent","createView","_ref$tag","_ref$name","_ref$attributes","_ref$read","_ref$write","_ref$create","_ref$destroy","_ref$filterFrameActio","filterFrameActionsForChild","_ref$didCreateView","didCreateView","_ref$didWriteView","didWriteView","_ref$ignoreRect","ignoreRect","_ref$ignoreRectUpdate","ignoreRectUpdate","_ref$mixins","mixins","store","getComputedStyle","frameRect","isResting","activeMixins","ref","writers","readers","destroyers","getElement","getChildViews","getReference","createChildView","_read","root","internalAPI","reader","_write","frameActions","shouldOptimize","writer","timestamp","mixin","_destroy","destroyer","sharedAPIDefinition","internalAPIDefinition","is","needle","linkView","unlinkView","registerWriter","registerReader","registerDestroyer","invalidateLayout","externalAPIDefinition","mixinAPIDefinition","sort","mixinAPI","childCount","createPainter","fps","painter","interval","last","requestTick","cancelTick","setTimerType","tick","performance","clearTimeout","requestAnimationFrame","cancelAnimationFrame","delta","pause","createRoute","routes","_ref$actions","newNode","referenceNode","insertAfter","nextSibling","isEmpty","toArray","splitter","isBoolean","toBoolean","toNumber","toInt","toFloat","parseFloat","isInt","isFinite","floor","toBytes","base","naturalFileSize","toFunctionReference","string","self","levels","level","methods","patch","revert","fetch","restore","load","createServerAPI","outline","createAction","onload","ondata","header","isNull","isAPI","getType","replaceSingleQuotes","conversionTable","array","int","float","bytes","function","serverapi","object","convertTo","getValueByType","newValue","defaultValue","valueType","newValueType","convertedValue","option","createOption","currentValue","enumerable","createOptions","optionDefinition","createInitialState","items","listUpdateTimeout","itemUpdateTimeout","processingQueue","fromCamels","separator","part","createOptionAPI","createOptionActions","createOptionQueries","InteractionMethod","API","DROP","BROWSE","PASTE","NONE","getUniqueId","random","substring","_AwaitValue","wrapped","_AsyncGenerator","gen","front","back","arg","next","resume","wrappedAwait","_invoke","return","_objectWithoutPropertiesLoose","excluded","sourceKeys","_objectWithoutProperties","getOwnPropertySymbols","sourceSymbolKeys","propertyIsEnumerable","_toConsumableArray","_arrayWithoutHoles","_iterableToArray","_nonIterableSpread","arr2","iter","Symbol","iterator","from","asyncIterator","throw","arrayRemove","run","sync","_fire","fireSync","fire","_len2","_key2","onOnce","_cb","copyObjectPropertiesToObject","src","getOwnPropertyNames","getOwnPropertyDescriptor","PRIVATE","createItemAPI","item","removeReleasedItems","released","ItemStatus","INIT","IDLE","PROCESSING_QUEUED","PROCESSING","PROCESSING_COMPLETE","PROCESSING_ERROR","PROCESSING_REVERT_ERROR","LOADING","LOAD_ERROR","FileOrigin","INPUT","LIMBO","LOCAL","getNonNumeric","exec","getDecimalSeparator","toLocaleString","getThousandsSeparator","decimalSeparator","thousandsStringWithSeparator","INT","NUMBER","STRING","ARRAY","OBJECT","ACTION","SERVER_API","REGEX","filters","applyFilterChain","matchingFilters","f","initialFilter","reduce","current","catch","applyFilters","extendDefaultOptions","additionalOptions","defaultOptions","getOptions","setOptions","disabled","required","captureMethod","allowSyncAcceptAttribute","allowDrop","allowBrowse","allowPaste","allowMultiple","allowReplace","allowRevert","allowRemove","allowProcess","allowReorder","allowDirectoriesOnly","storeAsFile","forceRevert","maxFiles","checkValidity","itemInsertLocationFreedom","itemInsertLocation","itemInsertInterval","dropOnPage","dropOnElement","dropValidation","ignoredFiles","instantUpload","maxParallelUploads","allowMinimumUploadDuration","chunkUploads","chunkForce","chunkSize","chunkRetryDelays","server","fileSizeBase","labelFileSizeBytes","labelFileSizeKilobytes","labelFileSizeMegabytes","labelFileSizeGigabytes","labelDecimalSeparator","labelThousandsSeparator","labelIdle","labelInvalidField","labelFileWaitingForSize","labelFileSizeNotAvailable","labelFileCountSingular","labelFileCountPlural","labelFileLoading","labelFileAdded","labelFileLoadError","labelFileRemoved","labelFileRemoveError","labelFileProcessing","labelFileProcessingComplete","labelFileProcessingAborted","labelFileProcessingError","labelFileProcessingRevertError","labelTapToCancel","labelTapToRetry","labelTapToUndo","labelButtonRemoveItem","labelButtonAbortItemLoad","labelButtonRetryItemLoad","labelButtonAbortItemProcessing","labelButtonUndoItemProcessing","labelButtonRetryItemProcessing","labelButtonProcessItem","iconRemove","iconProcess","iconRetry","iconUndo","iconDone","oninit","onwarning","onactivatefile","oninitfile","onaddfilestart","onaddfileprogress","onaddfile","onprocessfilestart","onprocessfileprogress","onprocessfileabort","onprocessfilerevert","onprocessfile","onprocessfiles","onremovefile","onpreparefile","onupdatefiles","onreorderfiles","beforeDropFile","beforeAddFile","beforeRemoveFile","beforePrepareFile","stylePanelLayout","stylePanelAspectRatio","styleItemPanelAspectRatio","styleButtonRemoveItemPosition","styleButtonProcessItemPosition","styleLoadIndicatorPosition","styleProgressIndicatorPosition","styleButtonRemoveItemAlign","files","credits","getItemByQuery","find","getNumericAspectRatioFromString","aspectRatio","getActiveItems","archived","Status","EMPTY","ERROR","BUSY","READY","res","canUpdateFileInput","dataTransfer","DataTransfer","File","ITEM_ERROR","ITEM_BUSY","ITEM_READY","isItemInErrorState","isItemInBusyState","isItemInReadyState","isAsync","GET_STATUS","some","GET_ITEM","GET_ACTIVE_ITEM","GET_ACTIVE_ITEMS","GET_ITEMS","GET_ITEM_NAME","filename","GET_ITEM_SIZE","fileSize","GET_STYLES","GET_PANEL_ASPECT_RATIO","GET_ITEM_PANEL_ASPECT_RATIO","GET_ITEMS_BY_STATUS","GET_TOTAL_ITEMS","SHOULD_UPDATE_FILE_INPUT","IS_ASYNC","GET_FILE_SIZE_LABELS","labelBytes","labelKilobytes","labelMegabytes","labelGigabytes","hasRoomForItem","count","maxFileCount","limit","min","max","arrayInsert","insertItem","isBase64DataURI","getFilenameFromURL","pop","guesstimateExtension","subtype","leftPad","padding","getDateString","date","getFullYear","getMonth","getDate","getHours","getMinutes","getSeconds","getFileFromBlob","blob","size","lastModifiedDate","_relativePath","getBlobBuilder","BlobBuilder","WebKitBlobBuilder","MozBlobBuilder","MSBlobBuilder","createBlob","arrayBuffer","mimeType","BB","bb","append","getBlob","Blob","getBlobFromByteStringWithMimeType","byteString","ab","ia","Uint8Array","getMimeTypeFromBase64DataURI","dataURI","getBase64DataFromBase64DataURI","getByteStringFromBase64DataURI","atob","getBlobFromBase64DataURI","getFileFromBase64DataURI","getFileNameFromHeader","matches","decodeURI","getFileSizeFromHeader","getTranfserIdFromHeader","getFileInfoFromHeaders","info","rows","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","createFileLoader","fetchFn","complete","progress","getProgress","loadURL","body","computable","total","fileinfo","setSource","isGet","sendRequest","onheaders","onprogress","xhr","headersReceived","encodeURI","lengthComputable","loaded","createResponse","createTimeoutResponse","hasQS","createFetchFunction","apiUrl","ChunkStatus","QUEUED","COMPLETE","WAITING","processFileChunked","metadata","transfer","chunks","chunkTransferId","chunkServer","serverId","fd","getResponseHeader","requestTransferId","formData","FormData","requestParams","requestTransferOffset","requestUrl","lastChunkIndex","retries","completeProcessingChunks","canProcessChunk","chunk","processChunk","processChunks","updateTotalProgress","retryProcessChunk","every","totalBytesTransfered","totalSize","abortChunks","createFileProcessorFunction","canChunkUpload","shouldChunkUpload","willChunkUpload","createProcessorFunction","createRevertFunction","uniqueFileId","getRandomNumber","createPerceivedPerformanceUpdater","tickMin","tickMax","runtime","clear","createFileProcessor","processFn","perceivedProgress","perceivedPerformanceUpdater","perceivedDuration","progressFn","completeFn","transferId","reset","getDuration","lastIndexOf","createFileStub","deepCloneObject","createItem","origin","serverFileReference","frozen","processingAborted","activeLoader","activeProcessor","abortProcessingRequestComplete","setStatus","getFileExtension","getFileType","getFileSize","getFile","loader","meta","success","retryLoad","abortLoad","processor","onprocess","requestProcessing","abortProcessing","revertFileUpload","serverTransferId","_setMetadata","silent","getMetadata","filenameWithoutExtension","fileExtension","fileType","relativePath","setMetadata","handler","itemAPI","freeze","release","archive","getItemIndexByQuery","getItemById","itemId","fetchBlob","getDomainFromURL","isExternalURL","dynamicLabel","label","isMockItem","listUpdated","optionalPromise","sortItems","compare","getItemByQueryFromState","itemHandler","_ref$success","_ref$failure","failure","ABORT_ALL","DID_SET_FILES","_ref2$value","activeItems","interactionMethod","DID_UPDATE_ITEM_METADATA","_ref3","change","doUpload","shouldPrepareOutput","MOVE_ITEM","_ref4","currentIndex","SORT","_ref5","ADD_ITEMS","_ref6","_ref6$success","_ref6$failure","insertLocation","totalItems","isValidFile","ADD_ITEM","_ref7","_ref7$index","_ref7$success","_ref7$failure","_ref7$options","_item","mainStatus","main","sub","handleAdd","shouldAdd","loadComplete","_ref8","REQUEST_PREPARE_OUTPUT","_ref9","_ref9$failure","COMPLETE_LOAD_ITEM","_ref10","RETRY_ITEM_LOAD","REQUEST_ITEM_PREPARE","_success","output","REQUEST_ITEM_PROCESSING","processNow","PROCESS_ITEM","processNext","queueEntry","itemReference","noop","RETRY_ITEM_PROCESSING","REQUEST_REMOVE_ITEM","shouldRemove","RELEASE_ITEM","REMOVE_ITEM","removeFromView","ABORT_ITEM_LOAD","ABORT_ITEM_PROCESSING","REQUEST_REVERT_ITEM_PROCESSING","handleRevert","shouldRevert","requestRemoveResult","REVERT_ITEM_PROCESSING","SET_OPTIONS","_ref11","optionKeys","prioritizedOptionKeys","PrioritizedOptions","formatFilename","createElement$1","tagName","text","textNode","nodeValue","createTextNode","polarToCartesian","centerX","centerY","radius","angleInDegrees","angleInRadians","PI","x","cos","y","sin","describeArc","startAngle","endAngle","arcSweep","end","percentageArc","to","spin","svg","align","dataset","ringStrokeWidth","ringFrom","ringTo","coordinates","progressIndicator","create$1","innerHTML","icon","isDisabled","write$1","shouldDisable","removeAttribute","fileActionButton","toNaturalFileSize","_options$labelBytes","_options$labelKilobyt","_options$labelMegabyt","_options$labelGigabyt","KB","MB","GB","round","removeDecimalsWhenZero","decimalCount","toFixed","create$2","updateFile","updateFileSizeOnError","fileInfo","DID_LOAD_ITEM","DID_UPDATE_ITEM_META","DID_THROW_ITEM_LOAD_ERROR","DID_THROW_ITEM_INVALID","toPercentage","create$3","didSetItemLoadProgress","title","didSetItemProcessProgress","didRequestItemProcessing","didAbortItemProcessing","didCompleteItemProcessing","fileStatus","DID_REVERT_ITEM_PROCESSING","DID_REQUEST_ITEM_PROCESSING","DID_ABORT_ITEM_PROCESSING","DID_COMPLETE_ITEM_PROCESSING","DID_UPDATE_ITEM_PROCESS_PROGRESS","DID_UPDATE_ITEM_LOAD_PROGRESS","DID_THROW_ITEM_PROCESSING_ERROR","DID_THROW_ITEM_PROCESSING_REVERT_ERROR","DID_THROW_ITEM_REMOVE_ERROR","Buttons","AbortItemLoad","RetryItemLoad","RemoveItem","ProcessItem","AbortItemProcessing","RetryItemProcessing","RevertItemProcessing","ButtonKeys","isSupported","calculateFileInfoOffset","getRemoveIndicatorAligment","buttonRect","buttonRemoveItem","calculateButtonWidth","buttonAbortItemLoad","calculateFileVerticalCenterOffset","calculateFileHorizontalCenterOffset","getLoadIndicatorAlignment","getProcessIndicatorAlignment","DefaultStyle","buttonRetryItemLoad","buttonProcessItem","buttonAbortItemProcessing","buttonRetryItemProcessing","buttonRevertItemProcessing","loadProgressIndicator","processProgressIndicator","processingCompleteIndicator","IdleStyle","ProcessingStyle","StyleMap","DID_START_ITEM_LOAD","DID_START_ITEM_REMOVE","DID_LOAD_LOCAL_ITEM","DID_START_ITEM_PROCESSING","processingCompleteIndicatorView","create$4","buttonFilter","LocalButtons","prev","curr","alignRemoveItemButton","enabledButtons","_map","buttonView","stopPropagation","loadIndicatorView","progressIndicatorView","activeStyles","write$2","route","stylesToApply","defaultStyles","control","DID_SET_LABEL_BUTTON_ABORT_ITEM_PROCESSING","DID_SET_LABEL_BUTTON_ABORT_ITEM_LOAD","DID_SET_LABEL_BUTTON_ABORT_ITEM_REMOVAL","buttonAbortItemRemoval","_ref12","create$5","didLoadItem","fileWrapper","PANEL_SPRING_PROPS","create$6","section","createSection","scalable","viewConstructor","write$3","topRect","bottomRect","center","panel","heightCurrent","createDragHelper","itemIds","prevIndex","setIndex","getIndex","getItemIndex","ITEM_TRANSLATE_SPRING","ITEM_SCALE_SPRING","StateMap","create$7","handleClick","container","markedForRemoval","dragState","grab","isPrimary","removedActivateListener","pageX","pageY","dragOrigin","dragCenter","offsetX","offsetY","drag","preventDefault","dragOffset","drop","route$1","DID_UPDATE_PANEL_HEIGHT","write$4","DID_GRAB_ITEM","DID_DRAG_ITEM","DID_DROP_ITEM","currentState","filepondItemState","getItemsPerRow","horizontalSpace","itemWidth","getItemIndexByPosition","positionInView","itemRect","itemHorizontalMargin","itemsPerRow","childMid","itemVerticalMargin","itemHeight","_index","itemTop","itemRight","itemBottom","dropAreaDimensions","getHeight","setHeight","getWidth","setWidth","setDimensions","create$8","lastItemSpanwDate","addItemView","addIndex","spawnDate","cooldown","dist","moveItem","vx","vy","introItemView","removeItemView","getItemHeight","getItemWidth","dragItem","numItems","oldIndex","dragPosition","dragHeight","dragWidth","cols","getGridIndex","getColIndex","visibleChildren","idx","childBottom","childTop","route$2","DID_ADD_ITEM","DID_REMOVE_ITEM","write$5","dragCoordinates","dragIndex","dragIndexOffset","removeIndexOffset","addIndexOffset","childRect","visualHeight","prevX","prevY","visualIndex","indexX","indexY","vectorX","sign","vectorY","filterSetItemActions","list","create$9","overflowing","storeDragCoordinates","scopeLeft","scopeTop","route$3","DID_DRAG","DID_END_DRAG","write$6","overflow","newHeight","listScroller","attrToggle","resetFileInput","input","form","create$a","setAcceptedFileTypes","toggleAllowMultiple","toggleDirectoryFilter","toggleDisabled","toggleRequired","setCaptureMethod","handleChange","webkitRelativePath","doesAllowBrowse","disableField","updateRequiredStatus","setCustomValidity","updateFieldValidityStatus","browser","DID_SET_DISABLED","DID_SET_ALLOW_BROWSE","DID_SET_ALLOW_DIRECTORIES_ONLY","DID_SET_ALLOW_MULTIPLE","DID_SET_ACCEPTED_FILE_TYPES","DID_SET_CAPTURE_METHOD","DID_SET_REQUIRED","Key","ENTER","SPACE","create$b","handleKeyDown","keyCode","click","contains","updateLabelValue","caption","clickable","querySelector","dropLabel","DID_SET_LABEL_IDLE","addBlob","moveBlob","hideBlob","explodeBlob","write$7","route$4","DID_DROP","drip","setInputFiles","create$c","fields","getField","syncFieldPositionsWithItems","didReorderItems","didAddItem","shouldUseFileInput","dataContainer","didLoadItem$1","field","fileItem","didPrepareOutput","didSetDisabled","didRemoveItem","didDefineValue","write$8","DID_DEFINE_VALUE","DID_PREPARE_OUTPUT","DID_REORDER_ITEMS","DID_SORT_ITEMS","getRootNode","images","text$1","zip","epub","guesstimateMimeType","requestDataTransferItems","links","getLinks","hasFiles","getFiles","promisedFiles","isFileSystemItem","getFilesFromItem","returnedFileGroups","group","isEntry","entry","getAsEntry","isDirectory","kind","isDirectoryEntry","getFilesInDirectory","getAsFile","dirCounter","fileCounter","resolveIfDone","readEntries","dirEntry","directoryReader","createReader","readBatch","entries","correctedFile","correctMissingFileType","webkitGetAsEntry","getLinksFromTransferMetaData","getLinksFromTransferURLData","getData","dragNDropObservers","eventPosition","pageLeft","pageTop","layerX","layerY","createDragNDropClient","scopeToObserve","filterElement","observer","getDragNDropObserver","client","ondrop","onenter","ondrag","onexit","allowdrop","addListener","newObserver","createDragNDropObserver","clients","dragenter","dragover","dragleave","createHandler","elementFromPoint","point","isEventTarget","elementAtPosition","pageXOffset","pageYOffset","initialTarget","setDropEffect","effect","dropEffect","overDropTarget","allowsTransfer","createHopper","scope","validateItems","catchesDropsOnPage","requiresDropOnElement","_options$filterItems","filterItems","documentElement","lastState","filteredItems","ondragend","ondragstart","updateHopperState","hopperState","listening","listeners$1","handlePaste","activeEl","activeElement","nodeName","inScope","clipboardData","listen","unlisten","createPaster","create$d","addFilesNotificationTimeout","notificationClearTimeout","filenames","assist","textContent","clear$1","listModified","isUsingFilePond","itemAdded","itemRemoved","itemProcessed","itemProcessedUndo","itemError","assistant","toCamels","debounce","func","immidiateOnly","MAX_FILES_LIMIT","prevent","create$e","measure","bounds","widthPrevious","widthUpdated","updateHistory","previousAspectRatio","canHover","matchMedia","hasPointerEvents","passive","frag","tabindex","rel","write$9","route$5","calculateRootBoundingBoxHeight","_root$ref","hopper","isMultiItem","atMaxCapacity","addAction","listItemMargin","calculateListItemMargin","listHeight","calculateListHeight","labelHeight","currentLabelHeight","listMarginTop","listMarginBottom","visual","boundsHeight","history","MAX_BOUNCES","bounces","listAvailableHeight","fixedHeight","_listAvailableHeight","cappedHeight","isCappedHeight","panelHeight","_listAvailableHeight2","itemMargin","transform","scrollList","itemList","newItem","removedItem","verticalItemCount","ceil","measureHeight","maxHeight","exceedsMaxFiles","maxItems","totalBrowseItems","getDragIndex","toggleDrop","isAllowed","enabled","toggleBrowse","togglePaste","paster","DID_SET_ALLOW_DROP","DID_SET_ALLOW_PASTE","createApp","initialOptions","originalElement","visibilityHandler","resizeDoneTimer","isResizing","isResizingHorizontally","initialWindowWidth","currentWindowWidth","resizeHandler","isHidden","readWriteApi","innerWidth","routeActionsToEvents","createEvent","eventRoutes","DID_DESTROY","DID_INIT","DID_THROW_MAX_FILES","DID_INIT_ITEM","DID_COMPLETE_ITEM_PROCESSING_ALL","DID_UPDATE_ITEMS","DID_ACTIVATE_ITEM","exposeEvent","pond","bubbles","cancelable","composed","filtered","prepareFile","addFile","addFiles","isFilePondFile","removeFile","sources","lastArgument","processFile","prepareFiles","processFiles","_len3","_key3","removeFiles","_len4","_key4","q","moveFile","browse","appendTo","replaceElement","restoreElement","isAttachedTo","createAppObject","customOptions","lowerCaseFirstLetter","attributeNameToPropertyName","attributeName","mapObject","propertyMap","selector","mapping","selectorRegExp","getAttributesAsObject","attributeMapping","attribute","createAppAtElement","mergedOptions","attributeOptions","querySelectorAll","app","createApp$1","PRIVATE_METHODS","createAppAPI","replaceInString","replacements","createWorker","workerBlob","workerURL","URL","createObjectURL","worker","Worker","post","transferList","onmessage","postMessage","terminate","revokeObjectURL","loadImage","img","Image","renamedFile","copyFile","registeredPlugins","createAppPlugin","pluginOutline","views","isOperaMini","operamini","hasPromises","hasBlobSlice","hasCreateObjectURL","hasVisibility","hasTiming","hasCSSSupports","CSS","isIE11","supported","apps","FileStatus","OptionTypes","registerPlugin","updateOptionTypes","hook","indexToRemove","newHook","plugins","global","w","noGlobal","getProto","flat","class2type","hasOwn","fnToString","ObjectFunctionString","support","nodeType","isWindow","preservedScriptAttributes","nonce","noModule","DOMEval","doc","script","head","toType","isArrayLike","jquery","num","pushStack","elems","ret","prevObject","elem","first","eq","even","grep","_elem","odd","len","j","copy","copyIsArray","clone","deep","expando","isReady","msg","proto","Ctor","isEmptyObject","globalEval","makeArray","results","inArray","second","invert","callbackExpect","guid","_i","Sizzle","Expr","getText","isXML","tokenize","compile","select","outermostContext","sortInput","hasDuplicate","setDocument","docElem","documentIsHTML","rbuggyQSA","rbuggyMatches","preferredDoc","dirruns","classCache","createCache","tokenCache","compilerCache","nonnativeSelectorCache","sortOrder","pushNative","booleans","whitespace","identifier","pseudos","rwhitespace","rtrim","rcomma","rcombinators","rdescend","rpseudo","ridentifier","matchExpr","rhtml","rinputs","rheader","rnative","rquickExpr","rsibling","runescape","funescape","escape","nonHex","high","String","fromCharCode","rcssescape","fcssescape","ch","asCodePoint","unloadHandler","inDisabledFieldset","addCombinator","dir","els","seed","m","nid","groups","newSelector","newContext","ownerDocument","getElementById","qsa","testContext","toSelector","qsaError","cache","cacheLength","markFunction","assert","addHandle","attrs","attrHandle","siblingCheck","cur","diff","sourceIndex","createInputPseudo","createButtonPseudo","createDisabledPseudo","createPositionalPseudo","argument","matchIndexes","namespace","namespaceURI","hasCompare","subWindow","defaultView","attachEvent","createComment","getById","getElementsByName","attrId","getAttributeNode","tmp","matchesSelector","webkitMatchesSelector","mozMatchesSelector","oMatchesSelector","msMatchesSelector","disconnectedMatch","compareDocumentPosition","adown","bup","sortDetached","aup","ap","bp","expr","elements","specified","sel","uniqueSort","duplicates","detectDuplicates","sortStable","firstChild","selectors","createPseudo","relative","preFilter","excess","unquoted","nodeNameSelector","pattern","operator","check","what","_argument","simple","forward","ofType","_context","xml","uniqueCache","outerCache","nodeIndex","useCache","lastChild","uniqueID","pseudo","setFilters","matched","matcher","unmatched","lang","elemLang","hasFocus","tabIndex","checked","selected","selectedIndex","_matchIndexes","radio","checkbox","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","parseOnly","soFar","preFilters","cached","setMatchers","elementMatchers","bySet","byElement","superMatcher","outermost","matchedCount","setMatched","contextBackup","dirrunsUnique","matcherFromGroupMatchers","compiled","_name","unique","isXMLDoc","escapeSelector","until","truncate","siblings","n","rneedsContext","needsContext","rsingleTag","winnow","qualifier","rootjQuery","parseHTML","rparentsprev","guaranteedUnique","contents","sibling","targets","closest","prevAll","addBack","parents","parentsUntil","nextAll","nextUntil","prevUntil","contentDocument","rnothtmlwhite","Identity","Thrower","ex","adoptValue","noValue","fail","Callbacks","flag","firing","memory","fired","locked","firingIndex","once","stopOnFalse","empty","disable","lock","fireWith","Deferred","tuples","always","newDefer","tuple","returned","notify","onProgress","maxDepth","depth","special","that","mightThrow","notifyWith","resolveWith","exceptionHook","stackTrace","rejectWith","getStackHook","stateString","when","singleValue","remaining","resolveContexts","resolveValues","primary","updateFunc","rerrorNames","readyException","readyList","completed","readyWait","wait","doScroll","access","chainable","emptyGet","raw","bulk","rmsPrefix","rdashAlpha","fcamelCase","_all","letter","camelCase","acceptData","owner","Data","uid","configurable","hasData","dataPriv","dataUser","rbrace","rmultiDash","dataAttr","removeData","_data","_removeData","dequeue","startLength","hooks","_queueHooks","stop","clearQueue","defer","pnum","rcssNum","cssExpand","isAttached","isHiddenWithinTree","display","css","adjustCSS","valueParts","adjusted","maxIterations","initial","unit","cssNumber","initialInUnit","defaultDisplayMap","getDefaultDisplay","showHide","show","values","hide","div","rcheckableType","rtagName","rscriptType","createDocumentFragment","checkClone","cloneNode","noCloneChecked","wrapMap","thead","col","tr","td","_default","getAll","setGlobalEval","refElements","tbody","tfoot","colgroup","th","optgroup","buildFragment","scripts","selection","ignored","wrap","attached","fragment","nodes","htmlPrefilter","rtypenamespace","returnTrue","returnFalse","expectSync","safeActiveElement","types","one","origFn","leverageNative","notAsync","saved","isTrigger","delegateType","stopImmediatePropagation","trigger","Event","handleObjIn","eventHandle","handleObj","namespaces","origType","elemData","handle","triggered","bindType","delegateCount","setup","mappedTypes","origCount","teardown","nativeEvent","handlerQueue","fix","delegateTarget","preDispatch","isPropagationStopped","currentTarget","isImmediatePropagationStopped","rnamespace","postDispatch","matchedHandlers","matchedSelectors","button","addProp","originalEvent","writable","noBubble","beforeunload","returnValue","isDefaultPrevented","defaultPrevented","relatedTarget","timeStamp","isSimulated","altKey","changedTouches","ctrlKey","eventPhase","metaKey","shiftKey","charCode","buttons","clientX","clientY","pointerId","pointerType","screenX","screenY","targetTouches","toElement","touches","which","focus","blur","mouseenter","mouseleave","pointerenter","pointerleave","orig","related","rnoInnerhtml","rchecked","rcleanScript","manipulationTarget","disableScript","restoreScript","cloneCopyEvent","dest","udataOld","udataCur","fixInput","domManip","collection","hasScripts","iNoClone","valueIsFunction","_evalUrl","keepData","cleanData","dataAndEvents","deepDataAndEvents","srcElements","destElements","inPage","detach","prepend","before","after","replaceWith","replaceChild","prependTo","replaceAll","original","insert","rnumnonpx","getStyles","opener","swap","old","rboxStyle","curCSS","computed","minWidth","maxWidth","getPropertyValue","pixelBoxStyles","addGetHookIf","conditionFn","hookFn","computeStyleTests","divStyle","pixelPositionVal","reliableMarginLeftVal","roundPixelMeasures","pixelBoxStylesVal","boxSizingReliableVal","scrollboxSizeVal","reliableTrDimensionsVal","backgroundClip","clearCloneStyle","boxSizingReliable","pixelPosition","reliableMarginLeft","scrollboxSize","reliableTrDimensions","table","trChild","trStyle","borderTopWidth","borderBottomWidth","cssPrefixes","emptyStyle","vendorProps","finalPropName","final","cssProps","capName","vendorPropName","rdisplayswap","rcustomProp","cssShow","visibility","cssNormalTransform","letterSpacing","fontWeight","setPositiveNumber","subtract","boxModelAdjustment","dimension","box","isBorderBox","computedVal","extra","getWidthOrHeight","valueIsBorderBox","offsetProp","getClientRects","Tween","cssHooks","origName","isCustomProp","setProperty","getBoundingClientRect","scrollboxSizeBuggy","margin","border","prefix","suffix","expand","expanded","propHooks","percent","eased","pos","step","fx","scrollLeft","linear","swing","fxNow","inProgress","rfxtypes","rrun","schedule","createFxNow","genFx","includeWidth","createTween","Animation","tweeners","properties","stopped","prefilters","currentTime","startTime","tweens","specialEasing","originalProperties","originalOptions","gotoEnd","propFilter","timer","anim","tweener","oldfire","propTween","restoreDisplay","isBox","dataShow","unqueued","overflowX","overflowY","prefilter","speed","speeds","fadeTo","animate","optall","doAnimation","finish","stopQueue","timers","cssFn","slideDown","slideUp","slideToggle","fadeIn","fadeOut","fadeToggle","slow","fast","time","checkOn","optSelected","radioValue","boolHook","removeAttr","nType","attrHooks","bool","attrNames","lowercaseName","rfocusable","rclickable","stripAndCollapse","getClass","classesToArray","removeProp","propFix","classes","curValue","clazz","finalValue","stateVal","isValidValue","classNames","rreturn","valHooks","optionSet","focusin","rfocusMorph","stopPropagationCallback","onlyHandlers","bubbleType","ontype","lastElement","eventPath","parentWindow","simulate","triggerHandler","attaches","rquery","parseXML","parserErrorElem","DOMParser","parseFromString","rbracket","rCRLF","rsubmitterTypes","rsubmittable","buildParams","traditional","param","s","valueOrFunction","serialize","serializeArray","r20","rhash","rantiCache","rheaders","rnoContent","rprotocol","transports","allTypes","originAnchor","addToPrefiltersOrTransports","structure","dataTypeExpression","dataType","dataTypes","inspectPrefiltersOrTransports","jqXHR","inspected","seekingTransport","inspect","prefilterOrFactory","dataTypeOrTransport","ajaxExtend","flatOptions","ajaxSettings","active","lastModified","etag","isLocal","processData","async","contentType","accepts","json","responseFields","converters","ajaxSetup","settings","ajaxPrefilter","ajaxTransport","ajax","transport","cacheURL","responseHeadersString","timeoutTimer","urlAnchor","fireGlobals","uncached","callbackContext","globalEventContext","completeDeferred","statusCode","requestHeadersNames","strAbort","overrideMimeType","finalText","crossDomain","hasContent","ifModified","beforeSend","nativeStatusText","responses","isSuccess","modified","ct","finalDataType","firstDataType","ajaxHandleResponses","conv2","conv","dataFilter","throws","ajaxConvert","getJSON","getScript","wrapAll","firstElementChild","wrapInner","htmlIsFunction","unwrap","visible","xhrSuccessStatus","xhrSupported","cors","errorCallback","xhrFields","binary","scriptAttrs","charset","scriptCharset","evt","oldCallbacks","rjsonp","jsonp","jsonpCallback","originalSettings","callbackName","overwritten","responseContainer","jsonProp","createHTMLDocument","implementation","keepScripts","animated","setOffset","curPosition","curLeft","curCSSTop","curTop","curOffset","curCSSLeft","curElem","using","win","parentOffset","scrollTo","Height","Width","defaultExtra","funcName","unbind","delegate","undelegate","hover","fnOver","fnOut","proxy","holdReady","hold","parseJSON","isNumeric","isNaN","_jQuery","_$","noConflict","FUNC_ERROR_TEXT","HASH_UNDEFINED","PLACEHOLDER","WRAP_CURRY_RIGHT_FLAG","WRAP_PARTIAL_FLAG","WRAP_PARTIAL_RIGHT_FLAG","WRAP_ARY_FLAG","WRAP_REARG_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","rePropName","reRegExpChar","reHasRegExpChar","reTrimStart","reWhitespace","reWrapComment","reWrapDetails","reSplitDetails","reAsciiWord","reForbiddenIdentifierChars","reEscapeChar","reEsTemplate","reFlags","reIsBadHex","reIsBinary","reIsHostCtor","reIsOctal","reIsUint","reLatin","reNoMatch","reUnescapedString","rsComboRange","rsComboMarksRange","rsDingbatRange","rsLowerRange","rsUpperRange","rsVarRange","rsBreakRange","rsMathOpRange","rsApos","rsAstral","rsBreak","rsCombo","rsDigits","rsDingbat","rsLower","rsMisc","rsFitz","rsNonAstral","rsRegional","rsSurrPair","rsUpper","rsMiscLower","rsMiscUpper","rsOptContrLower","rsOptContrUpper","reOptMod","rsOptVar","rsSeq","rsEmoji","rsSymbol","reApos","reComboMark","reUnicode","reUnicodeWord","reHasUnicode","reHasUnicodeWord","contextProps","templateCounter","typedArrayTags","cloneableTags","stringEscapes","freeParseFloat","freeParseInt","freeGlobal","g","freeSelf","Function","freeExports","freeModule","moduleExports","freeProcess","nodeUtil","binding","nodeIsArrayBuffer","nodeIsDate","nodeIsMap","isMap","nodeIsRegExp","isRegExp","nodeIsSet","isSet","nodeIsTypedArray","isTypedArray","arrayAggregator","iteratee","accumulator","arrayEach","arrayEachRight","arrayEvery","predicate","arrayFilter","resIndex","arrayIncludes","baseIndexOf","arrayIncludesWith","comparator","arrayMap","arrayPush","arrayReduce","initAccum","arrayReduceRight","arraySome","asciiSize","baseProperty","baseFindKey","eachFunc","baseFindIndex","fromIndex","fromRight","strictIndexOf","baseIsNaN","baseIndexOfWith","baseMean","baseSum","basePropertyOf","baseReduce","baseTimes","baseTrim","trimmedEndIndex","baseUnary","baseValues","cacheHas","charsStartIndex","strSymbols","chrSymbols","charsEndIndex","countHolders","placeholder","deburrLetter","escapeHtmlChar","escapeStringChar","chr","hasUnicode","mapToArray","overArg","replaceHolders","setToArray","setToPairs","stringSize","lastIndex","unicodeSize","stringToArray","unicodeToArray","asciiToArray","unescapeHtmlChar","runInContext","pick","arrayProto","funcProto","objectProto","coreJsData","funcToString","idCounter","maskSrcKey","IE_PROTO","nativeObjectToString","objectCtorString","oldDash","reIsNative","Buffer","allocUnsafe","getPrototype","objectCreate","spreadableSymbol","isConcatSpreadable","symIterator","symToStringTag","toStringTag","getNative","ctxClearTimeout","ctxNow","ctxSetTimeout","nativeCeil","nativeFloor","nativeGetSymbols","nativeIsBuffer","nativeIsFinite","nativeJoin","nativeKeys","nativeMax","nativeMin","nativeNow","nativeParseInt","nativeRandom","nativeReverse","DataView","Map","Set","WeakMap","nativeCreate","metaMap","realNames","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","valueOf","symbolToString","lodash","isObjectLike","LazyWrapper","LodashWrapper","wrapperClone","baseCreate","baseLodash","chainAll","__wrapped__","__actions__","__chain__","__index__","__values__","__dir__","__filtered__","__iteratees__","__takeCount__","__views__","Hash","ListCache","MapCache","SetCache","__data__","Stack","arrayLikeKeys","inherited","isArr","isArg","isArguments","isBuff","isType","skipIndexes","isIndex","arraySample","baseRandom","arraySampleSize","shuffleSelf","copyArray","baseClamp","arrayShuffle","assignMergeValue","baseAssignValue","objValue","assocIndexOf","baseAggregator","baseEach","baseAssign","copyObject","baseAt","paths","lower","upper","baseClone","bitmask","customizer","isDeep","isFlat","isFull","initCloneArray","getTag","isFunc","cloneBuffer","initCloneObject","getSymbolsIn","copySymbolsIn","keysIn","baseAssignIn","getSymbols","copySymbols","cloneArrayBuffer","dataView","byteOffset","byteLength","cloneDataView","cloneTypedArray","regexp","cloneRegExp","symbol","initCloneByTag","stacked","subValue","getAllKeysIn","getAllKeys","baseConformsTo","baseDelay","baseDifference","isCommon","valuesLength","valuesIndex","templateSettings","getMapData","pairs","LARGE_ARRAY_SIZE","createBaseEach","baseForOwn","baseEachRight","baseForOwnRight","baseEvery","baseExtremum","isSymbol","baseFilter","baseFlatten","isStrict","isFlattenable","baseFor","createBaseFor","baseForRight","baseFunctions","baseGet","castPath","toKey","baseGetAllKeys","keysFunc","symbolsFunc","baseGetTag","isOwn","unmasked","getRawTag","objectToString","baseGt","other","baseHas","baseHasIn","baseIntersection","arrays","othLength","othIndex","caches","maxLength","Infinity","seen","baseInvoke","baseIsArguments","baseIsEqual","equalFunc","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","equalArrays","convert","isPartial","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","objProps","objLength","objStacked","othStacked","skipCtor","othValue","compared","objCtor","othCtor","equalObjects","baseIsEqualDeep","baseIsMatch","matchData","noCustomizer","srcValue","COMPARE_PARTIAL_FLAG","baseIsNative","baseIteratee","identity","baseMatchesProperty","baseMatches","baseKeys","isPrototype","baseKeysIn","nativeKeysIn","isProto","baseLt","baseMap","getMatchData","matchesStrictComparable","isKey","isStrictComparable","hasIn","baseMerge","srcIndex","mergeFunc","safeGet","isTyped","isArrayLikeObject","toPlainObject","baseMergeDeep","baseNth","baseOrderBy","iteratees","orders","getIteratee","criteria","comparer","baseSortBy","objCriteria","othCriteria","ordersLength","compareAscending","compareMultiple","basePickBy","baseSet","basePullAll","basePullAt","indexes","previous","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","baseXor","baseZipObject","assignFunc","valsLength","castArrayLikeObject","castFunction","stringToPath","castRest","castSlice","typedArray","valIsDefined","valIsReflexive","composeArgs","partials","holders","isCurried","argsIndex","argsLength","holdersLength","leftIndex","leftLength","rangeLength","isUncurried","composeArgsRight","holdersIndex","rightIndex","rightLength","isNew","createAggregator","initializer","createAssigner","assigner","guard","isIterateeCall","iterable","createCaseFirst","methodName","trailing","createCompounder","words","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","newHolders","createRecurry","reorder","createInverter","toIteratee","baseInverter","createMathOperation","createOver","arrayFunc","createPadding","chars","charsLength","createRange","toFinite","baseRange","createRelationalOperation","wrapFunc","isCurry","newData","setData","setWrapToString","createRound","precision","toInteger","pair","createToPairs","baseToPairs","createWrap","srcBitmask","newBitmask","isCombo","mergeData","createCurry","createPartial","createBind","customDefaultsAssignIn","customDefaultsMerge","customOmitClone","arrLength","arrStacked","arrValue","flatten","otherFunc","getValue","stubArray","hasPath","hasFunc","isLength","ctorString","isMaskable","stubFalse","otherArgs","oldArray","shortOut","reference","details","insertWrapDetails","updateWrapDetails","getWrapDetails","lastCalled","stamp","rand","memoize","memoizeCapped","quote","subString","difference","differenceBy","differenceWith","findLastIndex","intersection","intersectionBy","intersectionWith","pull","pullAll","pullAt","union","unionBy","unionWith","unzip","unzipWith","without","xor","xorBy","xorWith","zipWith","wrapperAt","countBy","findLast","forEachRight","groupBy","invokeMap","keyBy","partition","sortBy","bindKey","WRAP_BIND_FLAG","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","invokeFunc","leadingEdge","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","flush","resolver","memoized","Cache","negate","overArgs","funcsLength","partial","partialRight","rearg","gt","gte","isError","isInteger","lt","lte","iteratorToArray","remainder","toLength","isBinary","assignIn","assignInWith","assignWith","at","propsIndex","propsLength","defaultsDeep","mergeWith","invertBy","invoke","omit","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","over","overEvery","overSome","basePropertyDeep","range","rangeRight","augend","addend","divide","dividend","divisor","multiply","multiplier","multiplicand","minuend","subtrahend","castArray","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","rest","sampleSize","setWith","shuffle","sortedUniq","sortedUniqBy","tail","take","takeRight","takeRightWhile","takeWhile","tap","throttle","toPath","isArrLike","unary","uniq","uniqBy","uniqWith","unset","update","updateWith","valuesIn","zipObject","zipObjectDeep","entriesIn","extendWith","clamp","cloneDeep","cloneDeepWith","cloneWith","conformsTo","defaultTo","endsWith","escapeRegExp","findKey","findLastKey","forIn","forInRight","forOwn","forOwnRight","inRange","baseInRange","isElement","isEqual","isEqualWith","isMatch","isMatchWith","isNative","isNil","isSafeInteger","isWeakMap","isWeakSet","strictLastIndexOf","maxBy","mean","meanBy","minBy","stubObject","stubString","stubTrue","nth","pad","strLength","padEnd","padStart","radix","floating","reduceRight","repeat","sample","sortedIndex","sortedIndexBy","sortedIndexOf","sortedLastIndex","sortedLastIndexBy","sortedLastIndexOf","startsWith","sum","sumBy","template","isEscaping","isEvaluating","imports","importsKeys","importsValues","reDelimiters","evaluate","sourceURL","escapeValue","interpolateValue","esTemplateValue","evaluateValue","variable","times","toLower","toSafeInteger","toUpper","trimEnd","trimStart","omission","newEnd","uniqueId","eachRight","isFilter","takeName","dropName","checkIteratee","isTaker","lodashFunc","retUnwrapped","isLazy","useLazy","isHybrid","isUnwrapped","onlyLazy","chainName","isRight","getView","iterLength","takeCount","iterIndex","commit","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","currentQueue","draining","queueIndex","cleanUpNextTick","drainQueue","marker","runClearTimeout","Item","nextTick","env","argv","versions","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","cwd","chdir","umask","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","O","chunkIds","priority","notFulfilled","r","__esModule","d","globalThis","nmd","installedChunks","chunkId","webpackJsonpCallback","parentChunkLoadingFunction","moreModules","chunkLoadingGlobal","__webpack_exports__"],"sourceRoot":""}