{"version":3,"file":"js/785-cad4beb85a9175d0da50.js","mappings":"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","sources":["webpack://tutorshop/./node_modules/@rails/actioncable/app/assets/javascripts/action_cable.js","webpack://tutorshop/./node_modules/jquery/dist/jquery-exposed.js","webpack://tutorshop/./node_modules/expose-loader/dist/runtime/getGlobalThis.js","webpack://tutorshop/./node_modules/jquery/dist/jquery.js","webpack://tutorshop/./node_modules/stimulus/dist/stimulus.js","webpack://tutorshop/./node_modules/stimulus/dist/webpack-helpers.js"],"sourcesContent":["(function(global, factory) {\n  typeof exports === \"object\" && typeof module !== \"undefined\" ? factory(exports) : typeof define === \"function\" && define.amd ? define([ \"exports\" ], factory) : factory(global.ActionCable = {});\n})(this, function(exports) {\n  \"use strict\";\n  var adapters = {\n    logger: self.console,\n    WebSocket: self.WebSocket\n  };\n  var logger = {\n    log: function log() {\n      if (this.enabled) {\n        var _adapters$logger;\n        for (var _len = arguments.length, messages = Array(_len), _key = 0; _key < _len; _key++) {\n          messages[_key] = arguments[_key];\n        }\n        messages.push(Date.now());\n        (_adapters$logger = adapters.logger).log.apply(_adapters$logger, [ \"[ActionCable]\" ].concat(messages));\n      }\n    }\n  };\n  var _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function(obj) {\n    return typeof obj;\n  } : function(obj) {\n    return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  };\n  var classCallCheck = function(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n      throw new TypeError(\"Cannot call a class as a function\");\n    }\n  };\n  var createClass = function() {\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    return function(Constructor, protoProps, staticProps) {\n      if (protoProps) defineProperties(Constructor.prototype, protoProps);\n      if (staticProps) defineProperties(Constructor, staticProps);\n      return Constructor;\n    };\n  }();\n  var now = function now() {\n    return new Date().getTime();\n  };\n  var secondsSince = function secondsSince(time) {\n    return (now() - time) / 1e3;\n  };\n  var clamp = function clamp(number, min, max) {\n    return Math.max(min, Math.min(max, number));\n  };\n  var ConnectionMonitor = function() {\n    function ConnectionMonitor(connection) {\n      classCallCheck(this, ConnectionMonitor);\n      this.visibilityDidChange = this.visibilityDidChange.bind(this);\n      this.connection = connection;\n      this.reconnectAttempts = 0;\n    }\n    ConnectionMonitor.prototype.start = function start() {\n      if (!this.isRunning()) {\n        this.startedAt = now();\n        delete this.stoppedAt;\n        this.startPolling();\n        addEventListener(\"visibilitychange\", this.visibilityDidChange);\n        logger.log(\"ConnectionMonitor started. pollInterval = \" + this.getPollInterval() + \" ms\");\n      }\n    };\n    ConnectionMonitor.prototype.stop = function stop() {\n      if (this.isRunning()) {\n        this.stoppedAt = now();\n        this.stopPolling();\n        removeEventListener(\"visibilitychange\", this.visibilityDidChange);\n        logger.log(\"ConnectionMonitor stopped\");\n      }\n    };\n    ConnectionMonitor.prototype.isRunning = function isRunning() {\n      return this.startedAt && !this.stoppedAt;\n    };\n    ConnectionMonitor.prototype.recordPing = function recordPing() {\n      this.pingedAt = now();\n    };\n    ConnectionMonitor.prototype.recordConnect = function recordConnect() {\n      this.reconnectAttempts = 0;\n      this.recordPing();\n      delete this.disconnectedAt;\n      logger.log(\"ConnectionMonitor recorded connect\");\n    };\n    ConnectionMonitor.prototype.recordDisconnect = function recordDisconnect() {\n      this.disconnectedAt = now();\n      logger.log(\"ConnectionMonitor recorded disconnect\");\n    };\n    ConnectionMonitor.prototype.startPolling = function startPolling() {\n      this.stopPolling();\n      this.poll();\n    };\n    ConnectionMonitor.prototype.stopPolling = function stopPolling() {\n      clearTimeout(this.pollTimeout);\n    };\n    ConnectionMonitor.prototype.poll = function poll() {\n      var _this = this;\n      this.pollTimeout = setTimeout(function() {\n        _this.reconnectIfStale();\n        _this.poll();\n      }, this.getPollInterval());\n    };\n    ConnectionMonitor.prototype.getPollInterval = function getPollInterval() {\n      var _constructor$pollInte = this.constructor.pollInterval, min = _constructor$pollInte.min, max = _constructor$pollInte.max, multiplier = _constructor$pollInte.multiplier;\n      var interval = multiplier * Math.log(this.reconnectAttempts + 1);\n      return Math.round(clamp(interval, min, max) * 1e3);\n    };\n    ConnectionMonitor.prototype.reconnectIfStale = function reconnectIfStale() {\n      if (this.connectionIsStale()) {\n        logger.log(\"ConnectionMonitor detected stale connection. reconnectAttempts = \" + this.reconnectAttempts + \", pollInterval = \" + this.getPollInterval() + \" ms, time disconnected = \" + secondsSince(this.disconnectedAt) + \" s, stale threshold = \" + this.constructor.staleThreshold + \" s\");\n        this.reconnectAttempts++;\n        if (this.disconnectedRecently()) {\n          logger.log(\"ConnectionMonitor skipping reopening recent disconnect\");\n        } else {\n          logger.log(\"ConnectionMonitor reopening\");\n          this.connection.reopen();\n        }\n      }\n    };\n    ConnectionMonitor.prototype.connectionIsStale = function connectionIsStale() {\n      return secondsSince(this.pingedAt ? this.pingedAt : this.startedAt) > this.constructor.staleThreshold;\n    };\n    ConnectionMonitor.prototype.disconnectedRecently = function disconnectedRecently() {\n      return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;\n    };\n    ConnectionMonitor.prototype.visibilityDidChange = function visibilityDidChange() {\n      var _this2 = this;\n      if (document.visibilityState === \"visible\") {\n        setTimeout(function() {\n          if (_this2.connectionIsStale() || !_this2.connection.isOpen()) {\n            logger.log(\"ConnectionMonitor reopening stale connection on visibilitychange. visibilityState = \" + document.visibilityState);\n            _this2.connection.reopen();\n          }\n        }, 200);\n      }\n    };\n    return ConnectionMonitor;\n  }();\n  ConnectionMonitor.pollInterval = {\n    min: 3,\n    max: 30,\n    multiplier: 5\n  };\n  ConnectionMonitor.staleThreshold = 6;\n  var INTERNAL = {\n    message_types: {\n      welcome: \"welcome\",\n      disconnect: \"disconnect\",\n      ping: \"ping\",\n      confirmation: \"confirm_subscription\",\n      rejection: \"reject_subscription\"\n    },\n    disconnect_reasons: {\n      unauthorized: \"unauthorized\",\n      invalid_request: \"invalid_request\",\n      server_restart: \"server_restart\"\n    },\n    default_mount_path: \"/cable\",\n    protocols: [ \"actioncable-v1-json\", \"actioncable-unsupported\" ]\n  };\n  var message_types = INTERNAL.message_types, protocols = INTERNAL.protocols;\n  var supportedProtocols = protocols.slice(0, protocols.length - 1);\n  var indexOf = [].indexOf;\n  var Connection = function() {\n    function Connection(consumer) {\n      classCallCheck(this, Connection);\n      this.open = this.open.bind(this);\n      this.consumer = consumer;\n      this.subscriptions = this.consumer.subscriptions;\n      this.monitor = new ConnectionMonitor(this);\n      this.disconnected = true;\n    }\n    Connection.prototype.send = function send(data) {\n      if (this.isOpen()) {\n        this.webSocket.send(JSON.stringify(data));\n        return true;\n      } else {\n        return false;\n      }\n    };\n    Connection.prototype.open = function open() {\n      if (this.isActive()) {\n        logger.log(\"Attempted to open WebSocket, but existing socket is \" + this.getState());\n        return false;\n      } else {\n        logger.log(\"Opening WebSocket, current state is \" + this.getState() + \", subprotocols: \" + protocols);\n        if (this.webSocket) {\n          this.uninstallEventHandlers();\n        }\n        this.webSocket = new adapters.WebSocket(this.consumer.url, protocols);\n        this.installEventHandlers();\n        this.monitor.start();\n        return true;\n      }\n    };\n    Connection.prototype.close = function close() {\n      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {\n        allowReconnect: true\n      }, allowReconnect = _ref.allowReconnect;\n      if (!allowReconnect) {\n        this.monitor.stop();\n      }\n      if (this.isActive()) {\n        return this.webSocket.close();\n      }\n    };\n    Connection.prototype.reopen = function reopen() {\n      logger.log(\"Reopening WebSocket, current state is \" + this.getState());\n      if (this.isActive()) {\n        try {\n          return this.close();\n        } catch (error) {\n          logger.log(\"Failed to reopen WebSocket\", error);\n        } finally {\n          logger.log(\"Reopening WebSocket in \" + this.constructor.reopenDelay + \"ms\");\n          setTimeout(this.open, this.constructor.reopenDelay);\n        }\n      } else {\n        return this.open();\n      }\n    };\n    Connection.prototype.getProtocol = function getProtocol() {\n      if (this.webSocket) {\n        return this.webSocket.protocol;\n      }\n    };\n    Connection.prototype.isOpen = function isOpen() {\n      return this.isState(\"open\");\n    };\n    Connection.prototype.isActive = function isActive() {\n      return this.isState(\"open\", \"connecting\");\n    };\n    Connection.prototype.isProtocolSupported = function isProtocolSupported() {\n      return indexOf.call(supportedProtocols, this.getProtocol()) >= 0;\n    };\n    Connection.prototype.isState = function isState() {\n      for (var _len = arguments.length, states = Array(_len), _key = 0; _key < _len; _key++) {\n        states[_key] = arguments[_key];\n      }\n      return indexOf.call(states, this.getState()) >= 0;\n    };\n    Connection.prototype.getState = function getState() {\n      if (this.webSocket) {\n        for (var state in adapters.WebSocket) {\n          if (adapters.WebSocket[state] === this.webSocket.readyState) {\n            return state.toLowerCase();\n          }\n        }\n      }\n      return null;\n    };\n    Connection.prototype.installEventHandlers = function installEventHandlers() {\n      for (var eventName in this.events) {\n        var handler = this.events[eventName].bind(this);\n        this.webSocket[\"on\" + eventName] = handler;\n      }\n    };\n    Connection.prototype.uninstallEventHandlers = function uninstallEventHandlers() {\n      for (var eventName in this.events) {\n        this.webSocket[\"on\" + eventName] = function() {};\n      }\n    };\n    return Connection;\n  }();\n  Connection.reopenDelay = 500;\n  Connection.prototype.events = {\n    message: function message(event) {\n      if (!this.isProtocolSupported()) {\n        return;\n      }\n      var _JSON$parse = JSON.parse(event.data), identifier = _JSON$parse.identifier, message = _JSON$parse.message, reason = _JSON$parse.reason, reconnect = _JSON$parse.reconnect, type = _JSON$parse.type;\n      switch (type) {\n       case message_types.welcome:\n        this.monitor.recordConnect();\n        return this.subscriptions.reload();\n\n       case message_types.disconnect:\n        logger.log(\"Disconnecting. Reason: \" + reason);\n        return this.close({\n          allowReconnect: reconnect\n        });\n\n       case message_types.ping:\n        return this.monitor.recordPing();\n\n       case message_types.confirmation:\n        this.subscriptions.confirmSubscription(identifier);\n        return this.subscriptions.notify(identifier, \"connected\");\n\n       case message_types.rejection:\n        return this.subscriptions.reject(identifier);\n\n       default:\n        return this.subscriptions.notify(identifier, \"received\", message);\n      }\n    },\n    open: function open() {\n      logger.log(\"WebSocket onopen event, using '\" + this.getProtocol() + \"' subprotocol\");\n      this.disconnected = false;\n      if (!this.isProtocolSupported()) {\n        logger.log(\"Protocol is unsupported. Stopping monitor and disconnecting.\");\n        return this.close({\n          allowReconnect: false\n        });\n      }\n    },\n    close: function close(event) {\n      logger.log(\"WebSocket onclose event\");\n      if (this.disconnected) {\n        return;\n      }\n      this.disconnected = true;\n      this.monitor.recordDisconnect();\n      return this.subscriptions.notifyAll(\"disconnected\", {\n        willAttemptReconnect: this.monitor.isRunning()\n      });\n    },\n    error: function error() {\n      logger.log(\"WebSocket onerror event\");\n    }\n  };\n  var extend = function extend(object, properties) {\n    if (properties != null) {\n      for (var key in properties) {\n        var value = properties[key];\n        object[key] = value;\n      }\n    }\n    return object;\n  };\n  var Subscription = function() {\n    function Subscription(consumer) {\n      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      var mixin = arguments[2];\n      classCallCheck(this, Subscription);\n      this.consumer = consumer;\n      this.identifier = JSON.stringify(params);\n      extend(this, mixin);\n    }\n    Subscription.prototype.perform = function perform(action) {\n      var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      data.action = action;\n      return this.send(data);\n    };\n    Subscription.prototype.send = function send(data) {\n      return this.consumer.send({\n        command: \"message\",\n        identifier: this.identifier,\n        data: JSON.stringify(data)\n      });\n    };\n    Subscription.prototype.unsubscribe = function unsubscribe() {\n      return this.consumer.subscriptions.remove(this);\n    };\n    return Subscription;\n  }();\n  var SubscriptionGuarantor = function() {\n    function SubscriptionGuarantor(subscriptions) {\n      classCallCheck(this, SubscriptionGuarantor);\n      this.subscriptions = subscriptions;\n      this.pendingSubscriptions = [];\n    }\n    SubscriptionGuarantor.prototype.guarantee = function guarantee(subscription) {\n      if (this.pendingSubscriptions.indexOf(subscription) == -1) {\n        logger.log(\"SubscriptionGuarantor guaranteeing \" + subscription.identifier);\n        this.pendingSubscriptions.push(subscription);\n      } else {\n        logger.log(\"SubscriptionGuarantor already guaranteeing \" + subscription.identifier);\n      }\n      this.startGuaranteeing();\n    };\n    SubscriptionGuarantor.prototype.forget = function forget(subscription) {\n      logger.log(\"SubscriptionGuarantor forgetting \" + subscription.identifier);\n      this.pendingSubscriptions = this.pendingSubscriptions.filter(function(s) {\n        return s !== subscription;\n      });\n    };\n    SubscriptionGuarantor.prototype.startGuaranteeing = function startGuaranteeing() {\n      this.stopGuaranteeing();\n      this.retrySubscribing();\n    };\n    SubscriptionGuarantor.prototype.stopGuaranteeing = function stopGuaranteeing() {\n      clearTimeout(this.retryTimeout);\n    };\n    SubscriptionGuarantor.prototype.retrySubscribing = function retrySubscribing() {\n      var _this = this;\n      this.retryTimeout = setTimeout(function() {\n        if (_this.subscriptions && typeof _this.subscriptions.subscribe === \"function\") {\n          _this.pendingSubscriptions.map(function(subscription) {\n            logger.log(\"SubscriptionGuarantor resubscribing \" + subscription.identifier);\n            _this.subscriptions.subscribe(subscription);\n          });\n        }\n      }, 500);\n    };\n    return SubscriptionGuarantor;\n  }();\n  var Subscriptions = function() {\n    function Subscriptions(consumer) {\n      classCallCheck(this, Subscriptions);\n      this.consumer = consumer;\n      this.guarantor = new SubscriptionGuarantor(this);\n      this.subscriptions = [];\n    }\n    Subscriptions.prototype.create = function create(channelName, mixin) {\n      var channel = channelName;\n      var params = (typeof channel === \"undefined\" ? \"undefined\" : _typeof(channel)) === \"object\" ? channel : {\n        channel: channel\n      };\n      var subscription = new Subscription(this.consumer, params, mixin);\n      return this.add(subscription);\n    };\n    Subscriptions.prototype.add = function add(subscription) {\n      this.subscriptions.push(subscription);\n      this.consumer.ensureActiveConnection();\n      this.notify(subscription, \"initialized\");\n      this.subscribe(subscription);\n      return subscription;\n    };\n    Subscriptions.prototype.remove = function remove(subscription) {\n      this.forget(subscription);\n      if (!this.findAll(subscription.identifier).length) {\n        this.sendCommand(subscription, \"unsubscribe\");\n      }\n      return subscription;\n    };\n    Subscriptions.prototype.reject = function reject(identifier) {\n      var _this = this;\n      return this.findAll(identifier).map(function(subscription) {\n        _this.forget(subscription);\n        _this.notify(subscription, \"rejected\");\n        return subscription;\n      });\n    };\n    Subscriptions.prototype.forget = function forget(subscription) {\n      this.guarantor.forget(subscription);\n      this.subscriptions = this.subscriptions.filter(function(s) {\n        return s !== subscription;\n      });\n      return subscription;\n    };\n    Subscriptions.prototype.findAll = function findAll(identifier) {\n      return this.subscriptions.filter(function(s) {\n        return s.identifier === identifier;\n      });\n    };\n    Subscriptions.prototype.reload = function reload() {\n      var _this2 = this;\n      return this.subscriptions.map(function(subscription) {\n        return _this2.subscribe(subscription);\n      });\n    };\n    Subscriptions.prototype.notifyAll = function notifyAll(callbackName) {\n      var _this3 = this;\n      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n        args[_key - 1] = arguments[_key];\n      }\n      return this.subscriptions.map(function(subscription) {\n        return _this3.notify.apply(_this3, [ subscription, callbackName ].concat(args));\n      });\n    };\n    Subscriptions.prototype.notify = function notify(subscription, callbackName) {\n      for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\n        args[_key2 - 2] = arguments[_key2];\n      }\n      var subscriptions = void 0;\n      if (typeof subscription === \"string\") {\n        subscriptions = this.findAll(subscription);\n      } else {\n        subscriptions = [ subscription ];\n      }\n      return subscriptions.map(function(subscription) {\n        return typeof subscription[callbackName] === \"function\" ? subscription[callbackName].apply(subscription, args) : undefined;\n      });\n    };\n    Subscriptions.prototype.subscribe = function subscribe(subscription) {\n      if (this.sendCommand(subscription, \"subscribe\")) {\n        this.guarantor.guarantee(subscription);\n      }\n    };\n    Subscriptions.prototype.confirmSubscription = function confirmSubscription(identifier) {\n      var _this4 = this;\n      logger.log(\"Subscription confirmed \" + identifier);\n      this.findAll(identifier).map(function(subscription) {\n        return _this4.guarantor.forget(subscription);\n      });\n    };\n    Subscriptions.prototype.sendCommand = function sendCommand(subscription, command) {\n      var identifier = subscription.identifier;\n      return this.consumer.send({\n        command: command,\n        identifier: identifier\n      });\n    };\n    return Subscriptions;\n  }();\n  var Consumer = function() {\n    function Consumer(url) {\n      classCallCheck(this, Consumer);\n      this._url = url;\n      this.subscriptions = new Subscriptions(this);\n      this.connection = new Connection(this);\n    }\n    Consumer.prototype.send = function send(data) {\n      return this.connection.send(data);\n    };\n    Consumer.prototype.connect = function connect() {\n      return this.connection.open();\n    };\n    Consumer.prototype.disconnect = function disconnect() {\n      return this.connection.close({\n        allowReconnect: false\n      });\n    };\n    Consumer.prototype.ensureActiveConnection = function ensureActiveConnection() {\n      if (!this.connection.isActive()) {\n        return this.connection.open();\n      }\n    };\n    createClass(Consumer, [ {\n      key: \"url\",\n      get: function get$$1() {\n        return createWebSocketURL(this._url);\n      }\n    } ]);\n    return Consumer;\n  }();\n  function createWebSocketURL(url) {\n    if (typeof url === \"function\") {\n      url = url();\n    }\n    if (url && !/^wss?:/i.test(url)) {\n      var a = document.createElement(\"a\");\n      a.href = url;\n      a.href = a.href;\n      a.protocol = a.protocol.replace(\"http\", \"ws\");\n      return a.href;\n    } else {\n      return url;\n    }\n  }\n  function createConsumer() {\n    var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getConfig(\"url\") || INTERNAL.default_mount_path;\n    return new Consumer(url);\n  }\n  function getConfig(name) {\n    var element = document.head.querySelector(\"meta[name='action-cable-\" + name + \"']\");\n    if (element) {\n      return element.getAttribute(\"content\");\n    }\n  }\n  exports.Connection = Connection;\n  exports.ConnectionMonitor = ConnectionMonitor;\n  exports.Consumer = Consumer;\n  exports.INTERNAL = INTERNAL;\n  exports.Subscription = Subscription;\n  exports.Subscriptions = Subscriptions;\n  exports.SubscriptionGuarantor = SubscriptionGuarantor;\n  exports.adapters = adapters;\n  exports.createWebSocketURL = createWebSocketURL;\n  exports.logger = logger;\n  exports.createConsumer = createConsumer;\n  exports.getConfig = getConfig;\n  Object.defineProperty(exports, \"__esModule\", {\n    value: true\n  });\n});\n","var ___EXPOSE_LOADER_IMPORT___ = require(\"-!./jquery.js\");\nvar ___EXPOSE_LOADER_GET_GLOBAL_THIS___ = require(\"../../expose-loader/dist/runtime/getGlobalThis.js\");\nvar ___EXPOSE_LOADER_GLOBAL_THIS___ = ___EXPOSE_LOADER_GET_GLOBAL_THIS___;\nif (typeof ___EXPOSE_LOADER_GLOBAL_THIS___[\"$\"] === 'undefined') ___EXPOSE_LOADER_GLOBAL_THIS___[\"$\"] = ___EXPOSE_LOADER_IMPORT___;\nif (typeof ___EXPOSE_LOADER_GLOBAL_THIS___[\"jQuery\"] === 'undefined') ___EXPOSE_LOADER_GLOBAL_THIS___[\"jQuery\"] = ___EXPOSE_LOADER_IMPORT___;\nmodule.exports = ___EXPOSE_LOADER_IMPORT___;\n","\"use strict\";\n\n// eslint-disable-next-line func-names\nmodule.exports = function () {\n  if (typeof globalThis === \"object\") {\n    return globalThis;\n  }\n\n  var g;\n\n  try {\n    // This works if eval is allowed (see CSP)\n    // eslint-disable-next-line no-new-func\n    g = this || new Function(\"return this\")();\n  } catch (e) {\n    // This works if the window reference is available\n    if (typeof window === \"object\") {\n      return window;\n    } // This works if the self reference is available\n\n\n    if (typeof self === \"object\") {\n      return self;\n    } // This works if the global reference is available\n\n\n    if (typeof global !== \"undefined\") {\n      return global;\n    }\n  }\n\n  return g;\n}();","/*!\n * jQuery JavaScript Library v3.6.4\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: 2023-03-08T15:28Z\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 trac-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.4\",\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.10\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: 2023-02-14\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\trleadingCombinator = 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 ) || rleadingCombinator.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// Support: Chrome 105 - 110+, Safari 15.4 - 16.3+\n\t// Make sure the the `:has()` argument is parsed unforgivingly.\n\t// We include `*` in the test to detect buggy implementations that are\n\t// _selectively_ forgiving (specifically when the list includes at least\n\t// one valid selector).\n\t// Note that we treat complete lack of support for `:has()` as if it were\n\t// spec-compliant support, which is fine because use of `:has()` in such\n\t// environments will fail in the qSA path and fall back to jQuery traversal\n\t// anyway.\n\tsupport.cssHas = assert( function() {\n\t\ttry {\n\t\t\tdocument.querySelector( \":has(*,:jqfake)\" );\n\t\t\treturn false;\n\t\t} catch ( e ) {\n\t\t\treturn true;\n\t\t}\n\t} );\n\n\t/* Attributes\n\t---------------------------------------------------------------------- */\n\n\t// Support: IE<8\n\t// Verify that getAttribute really returns attributes and not properties\n\t// (excepting IE8 booleans)\n\tsupport.attributes = assert( function( el ) {\n\t\tel.className = \"i\";\n\t\treturn !el.getAttribute( \"className\" );\n\t} );\n\n\t/* getElement(s)By*\n\t---------------------------------------------------------------------- */\n\n\t// Check if getElementsByTagName(\"*\") returns only elements\n\tsupport.getElementsByTagName = assert( function( el ) {\n\t\tel.appendChild( document.createComment( \"\" ) );\n\t\treturn !el.getElementsByTagName( \"*\" ).length;\n\t} );\n\n\t// Support: IE<9\n\tsupport.getElementsByClassName = rnative.test( document.getElementsByClassName );\n\n\t// Support: IE<10\n\t// Check if getElementById returns elements by name\n\t// The broken getElementById methods don't pick up programmatically-set names,\n\t// so use a roundabout getElementsByName test\n\tsupport.getById = assert( function( el ) {\n\t\tdocElem.appendChild( el ).id = expando;\n\t\treturn !document.getElementsByName || !document.getElementsByName( expando ).length;\n\t} );\n\n\t// ID filter and find\n\tif ( support.getById ) {\n\t\tExpr.filter[ \"ID\" ] = function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn elem.getAttribute( \"id\" ) === attrId;\n\t\t\t};\n\t\t};\n\t\tExpr.find[ \"ID\" ] = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar elem = context.getElementById( id );\n\t\t\t\treturn elem ? [ elem ] : [];\n\t\t\t}\n\t\t};\n\t} else {\n\t\tExpr.filter[ \"ID\" ] =  function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\tvar node = typeof elem.getAttributeNode !== \"undefined\" &&\n\t\t\t\t\telem.getAttributeNode( \"id\" );\n\t\t\t\treturn node && node.value === attrId;\n\t\t\t};\n\t\t};\n\n\t\t// Support: IE 6 - 7 only\n\t\t// getElementById is not reliable as a find shortcut\n\t\tExpr.find[ \"ID\" ] = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar node, i, elems,\n\t\t\t\t\telem = context.getElementById( id );\n\n\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t// Verify the id attribute\n\t\t\t\t\tnode = elem.getAttributeNode( \"id\" );\n\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t}\n\n\t\t\t\t\t// Fall back on getElementsByName\n\t\t\t\t\telems = context.getElementsByName( id );\n\t\t\t\t\ti = 0;\n\t\t\t\t\twhile ( ( elem = elems[ i++ ] ) ) {\n\t\t\t\t\t\tnode = elem.getAttributeNode( \"id\" );\n\t\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn [];\n\t\t\t}\n\t\t};\n\t}\n\n\t// Tag\n\tExpr.find[ \"TAG\" ] = support.getElementsByTagName ?\n\t\tfunction( tag, context ) {\n\t\t\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\t\t\treturn context.getElementsByTagName( tag );\n\n\t\t\t// DocumentFragment nodes don't have gEBTN\n\t\t\t} else if ( support.qsa ) {\n\t\t\t\treturn context.querySelectorAll( tag );\n\t\t\t}\n\t\t} :\n\n\t\tfunction( tag, context ) {\n\t\t\tvar elem,\n\t\t\t\ttmp = [],\n\t\t\t\ti = 0,\n\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\tif ( !support.cssHas ) {\n\n\t\t// Support: Chrome 105 - 110+, Safari 15.4 - 16.3+\n\t\t// Our regular `try-catch` mechanism fails to detect natively-unsupported\n\t\t// pseudo-classes inside `:has()` (such as `:has(:contains(\"Foo\"))`)\n\t\t// in browsers that parse the `:has()` argument as a forgiving selector list.\n\t\t// https://drafts.csswg.org/selectors/#relational now requires the argument\n\t\t// to be parsed unforgivingly, but browsers have not yet fully adjusted.\n\t\trbuggyQSA.push( \":has\" );\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\n\t\t\t// Support: IE <9 only\n\t\t\t// IE doesn't have `contains` on `document` so we need to check for\n\t\t\t// `documentElement` presence.\n\t\t\t// We need to fall back to `a` when `documentElement` is missing\n\t\t\t// as `ownerDocument` of elements within `<template/>` may have\n\t\t\t// a null one - a default behavior of all modern browsers.\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 <10 only\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 = rleadingCombinator.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 (trac-9521)\n\t// Strict HTML recognition (trac-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 trac-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 (trac-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 trac-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 (trac-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 (trac-11217)\n\t// Support: Windows Web Apps (WWA)\n\t// `name` and `type` must use .setAttribute for WWA (trac-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 (trac-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 (trac-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 (trac-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 (trac-13208)\n\t\t\t\t// Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-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 (trac-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 (trac-504, trac-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 if we're currently inside\n\t\t// a leveraged native-event stack\n\t\t_default: function( event ) {\n\t\t\treturn dataPriv.get( event.target, type );\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\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 (trac-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\n\t\t\t\t\t\t\t// Unwrap a CDATA section containing script contents. This shouldn't be\n\t\t\t\t\t\t\t// needed as in XML documents they're already not visible when\n\t\t\t\t\t\t\t// inspecting element contents and in HTML documents they have no\n\t\t\t\t\t\t\t// meaning but we're preserving that logic for backwards compatibility.\n\t\t\t\t\t\t\t// This will be removed completely in 4.0. See gh-4904.\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 rcustomProp = /^--/;\n\n\nvar getStyles = function( elem ) {\n\n\t\t// Support: IE <=11 only, Firefox <=30 (trac-15098, trac-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\nvar whitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\";\n\n\nvar rtrimCSS = new RegExp(\n\t\"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\",\n\t\"g\"\n);\n\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 (trac-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\t\tisCustomProp = rcustomProp.test( name ),\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, trac-12537)\n\t//   .css('--customProperty) (gh-3144)\n\tif ( computed ) {\n\n\t\t// Support: IE <=9 - 11+\n\t\t// IE only supports `\"float\"` in `getPropertyValue`; in computed styles\n\t\t// it's only available as `\"cssFloat\"`. We no longer modify properties\n\t\t// sent to `.css()` apart from camelCasing, so we need to check both.\n\t\t// Normally, this would create difference in behavior: if\n\t\t// `getPropertyValue` returns an empty string, the value returned\n\t\t// by `.css()` would be `undefined`. This is usually the case for\n\t\t// disconnected elements. However, in IE even disconnected elements\n\t\t// with no styles return `\"none\"` for `getPropertyValue( \"float\" )`\n\t\tret = computed.getPropertyValue( name ) || computed[ name ];\n\n\t\tif ( isCustomProp && ret ) {\n\n\t\t\t// Support: Firefox 105+, Chrome <=105+\n\t\t\t// Spec requires trimming whitespace for custom properties (gh-4926).\n\t\t\t// Firefox only trims leading whitespace. Chrome just collapses\n\t\t\t// both leading & trailing whitespace to a single space.\n\t\t\t//\n\t\t\t// Fall back to `undefined` if empty string returned.\n\t\t\t// This collapses a missing definition with property defined\n\t\t\t// and set to an empty string but there's no standard API\n\t\t\t// allowing us to differentiate them without a performance penalty\n\t\t\t// and returning `undefined` aligns with older jQuery.\n\t\t\t//\n\t\t\t// rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED\n\t\t\t// as whitespace while CSS does not, but this is not a problem\n\t\t\t// because CSS preprocessing replaces them with U+000A LINE FEED\n\t\t\t// (which *is* CSS whitespace)\n\t\t\t// https://www.w3.org/TR/css-syntax-3/#input-preprocessing\n\t\t\tret = ret.replace( rtrimCSS, \"$1\" ) || undefined;\n\t\t}\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\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 (trac-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 trac-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 (trac-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 )` (trac-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.\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// Use proper attribute retrieval (trac-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 classNames, cur, curValue, className, i, finalValue;\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\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tcurValue = getClass( this );\n\t\t\t\tcur = this.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\t\tclassName = classNames[ i ];\n\t\t\t\t\t\tif ( cur.indexOf( \" \" + className + \" \" ) < 0 ) {\n\t\t\t\t\t\t\tcur += className + \" \";\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\tthis.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 classNames, cur, curValue, className, i, finalValue;\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\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tcurValue = getClass( this );\n\n\t\t\t\t// This expression is here for better compressibility (see addClass)\n\t\t\t\tcur = this.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\t\tclassName = classNames[ i ];\n\n\t\t\t\t\t\t// Remove *all* instances\n\t\t\t\t\t\twhile ( cur.indexOf( \" \" + className + \" \" ) > -1 ) {\n\t\t\t\t\t\t\tcur = cur.replace( \" \" + className + \" \", \" \" );\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\tthis.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 classNames, className, i, self,\n\t\t\ttype = typeof value,\n\t\t\tisValidValue = type === \"string\" || Array.isArray( value );\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\tif ( typeof stateVal === \"boolean\" && isValidValue ) {\n\t\t\treturn stateVal ? this.addClass( value ) : this.removeClass( value );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\treturn this.each( function() {\n\t\t\tif ( isValidValue ) {\n\n\t\t\t\t// Toggle individual class names\n\t\t\t\tself = jQuery( this );\n\n\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\tclassName = 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 (trac-14686, trac-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 (trac-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 (trac-9951)\n\t\t// Bubble up to document, then to window; watch for a global ownerDocument var (trac-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 (trac-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// trac-7653, trac-8125, trac-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 (trac-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 trac-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 (trac-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 trac-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 (trac-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// trac-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 (trac-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// trac-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 trac-8605, trac-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// trac-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\n// Require that the \"whitespace run\" starts from a non-whitespace\n// to avoid O(N^2) behavior when the engine would try matching \"\\s+$\" at each space position.\nvar rtrim = /^[\\s\\uFEFF\\xA0]+|([^\\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, \"$1\" );\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// (trac-7102#comment:10, https://github.com/jquery/jquery/pull/557)\n// and CommonJS for browser emulators (trac-13566)\nif ( typeof noGlobal === \"undefined\" ) {\n\twindow.jQuery = window.$ = jQuery;\n}\n\n\n\n\nreturn jQuery;\n} );\n","/*\nStimulus 3.2.1\nCopyright © 2022 Basecamp, LLC\n */\nclass EventListener {\n    constructor(eventTarget, eventName, eventOptions) {\n        this.eventTarget = eventTarget;\n        this.eventName = eventName;\n        this.eventOptions = eventOptions;\n        this.unorderedBindings = new Set();\n    }\n    connect() {\n        this.eventTarget.addEventListener(this.eventName, this, this.eventOptions);\n    }\n    disconnect() {\n        this.eventTarget.removeEventListener(this.eventName, this, this.eventOptions);\n    }\n    bindingConnected(binding) {\n        this.unorderedBindings.add(binding);\n    }\n    bindingDisconnected(binding) {\n        this.unorderedBindings.delete(binding);\n    }\n    handleEvent(event) {\n        const extendedEvent = extendEvent(event);\n        for (const binding of this.bindings) {\n            if (extendedEvent.immediatePropagationStopped) {\n                break;\n            }\n            else {\n                binding.handleEvent(extendedEvent);\n            }\n        }\n    }\n    hasBindings() {\n        return this.unorderedBindings.size > 0;\n    }\n    get bindings() {\n        return Array.from(this.unorderedBindings).sort((left, right) => {\n            const leftIndex = left.index, rightIndex = right.index;\n            return leftIndex < rightIndex ? -1 : leftIndex > rightIndex ? 1 : 0;\n        });\n    }\n}\nfunction extendEvent(event) {\n    if (\"immediatePropagationStopped\" in event) {\n        return event;\n    }\n    else {\n        const { stopImmediatePropagation } = event;\n        return Object.assign(event, {\n            immediatePropagationStopped: false,\n            stopImmediatePropagation() {\n                this.immediatePropagationStopped = true;\n                stopImmediatePropagation.call(this);\n            },\n        });\n    }\n}\n\nclass Dispatcher {\n    constructor(application) {\n        this.application = application;\n        this.eventListenerMaps = new Map();\n        this.started = false;\n    }\n    start() {\n        if (!this.started) {\n            this.started = true;\n            this.eventListeners.forEach((eventListener) => eventListener.connect());\n        }\n    }\n    stop() {\n        if (this.started) {\n            this.started = false;\n            this.eventListeners.forEach((eventListener) => eventListener.disconnect());\n        }\n    }\n    get eventListeners() {\n        return Array.from(this.eventListenerMaps.values()).reduce((listeners, map) => listeners.concat(Array.from(map.values())), []);\n    }\n    bindingConnected(binding) {\n        this.fetchEventListenerForBinding(binding).bindingConnected(binding);\n    }\n    bindingDisconnected(binding, clearEventListeners = false) {\n        this.fetchEventListenerForBinding(binding).bindingDisconnected(binding);\n        if (clearEventListeners)\n            this.clearEventListenersForBinding(binding);\n    }\n    handleError(error, message, detail = {}) {\n        this.application.handleError(error, `Error ${message}`, detail);\n    }\n    clearEventListenersForBinding(binding) {\n        const eventListener = this.fetchEventListenerForBinding(binding);\n        if (!eventListener.hasBindings()) {\n            eventListener.disconnect();\n            this.removeMappedEventListenerFor(binding);\n        }\n    }\n    removeMappedEventListenerFor(binding) {\n        const { eventTarget, eventName, eventOptions } = binding;\n        const eventListenerMap = this.fetchEventListenerMapForEventTarget(eventTarget);\n        const cacheKey = this.cacheKey(eventName, eventOptions);\n        eventListenerMap.delete(cacheKey);\n        if (eventListenerMap.size == 0)\n            this.eventListenerMaps.delete(eventTarget);\n    }\n    fetchEventListenerForBinding(binding) {\n        const { eventTarget, eventName, eventOptions } = binding;\n        return this.fetchEventListener(eventTarget, eventName, eventOptions);\n    }\n    fetchEventListener(eventTarget, eventName, eventOptions) {\n        const eventListenerMap = this.fetchEventListenerMapForEventTarget(eventTarget);\n        const cacheKey = this.cacheKey(eventName, eventOptions);\n        let eventListener = eventListenerMap.get(cacheKey);\n        if (!eventListener) {\n            eventListener = this.createEventListener(eventTarget, eventName, eventOptions);\n            eventListenerMap.set(cacheKey, eventListener);\n        }\n        return eventListener;\n    }\n    createEventListener(eventTarget, eventName, eventOptions) {\n        const eventListener = new EventListener(eventTarget, eventName, eventOptions);\n        if (this.started) {\n            eventListener.connect();\n        }\n        return eventListener;\n    }\n    fetchEventListenerMapForEventTarget(eventTarget) {\n        let eventListenerMap = this.eventListenerMaps.get(eventTarget);\n        if (!eventListenerMap) {\n            eventListenerMap = new Map();\n            this.eventListenerMaps.set(eventTarget, eventListenerMap);\n        }\n        return eventListenerMap;\n    }\n    cacheKey(eventName, eventOptions) {\n        const parts = [eventName];\n        Object.keys(eventOptions)\n            .sort()\n            .forEach((key) => {\n            parts.push(`${eventOptions[key] ? \"\" : \"!\"}${key}`);\n        });\n        return parts.join(\":\");\n    }\n}\n\nconst defaultActionDescriptorFilters = {\n    stop({ event, value }) {\n        if (value)\n            event.stopPropagation();\n        return true;\n    },\n    prevent({ event, value }) {\n        if (value)\n            event.preventDefault();\n        return true;\n    },\n    self({ event, value, element }) {\n        if (value) {\n            return element === event.target;\n        }\n        else {\n            return true;\n        }\n    },\n};\nconst descriptorPattern = /^(?:(.+?)(?:\\.(.+?))?(?:@(window|document))?->)?(.+?)(?:#([^:]+?))(?::(.+))?$/;\nfunction parseActionDescriptorString(descriptorString) {\n    const source = descriptorString.trim();\n    const matches = source.match(descriptorPattern) || [];\n    let eventName = matches[1];\n    let keyFilter = matches[2];\n    if (keyFilter && ![\"keydown\", \"keyup\", \"keypress\"].includes(eventName)) {\n        eventName += `.${keyFilter}`;\n        keyFilter = \"\";\n    }\n    return {\n        eventTarget: parseEventTarget(matches[3]),\n        eventName,\n        eventOptions: matches[6] ? parseEventOptions(matches[6]) : {},\n        identifier: matches[4],\n        methodName: matches[5],\n        keyFilter,\n    };\n}\nfunction parseEventTarget(eventTargetName) {\n    if (eventTargetName == \"window\") {\n        return window;\n    }\n    else if (eventTargetName == \"document\") {\n        return document;\n    }\n}\nfunction parseEventOptions(eventOptions) {\n    return eventOptions\n        .split(\":\")\n        .reduce((options, token) => Object.assign(options, { [token.replace(/^!/, \"\")]: !/^!/.test(token) }), {});\n}\nfunction stringifyEventTarget(eventTarget) {\n    if (eventTarget == window) {\n        return \"window\";\n    }\n    else if (eventTarget == document) {\n        return \"document\";\n    }\n}\n\nfunction camelize(value) {\n    return value.replace(/(?:[_-])([a-z0-9])/g, (_, char) => char.toUpperCase());\n}\nfunction namespaceCamelize(value) {\n    return camelize(value.replace(/--/g, \"-\").replace(/__/g, \"_\"));\n}\nfunction capitalize(value) {\n    return value.charAt(0).toUpperCase() + value.slice(1);\n}\nfunction dasherize(value) {\n    return value.replace(/([A-Z])/g, (_, char) => `-${char.toLowerCase()}`);\n}\nfunction tokenize(value) {\n    return value.match(/[^\\s]+/g) || [];\n}\n\nclass Action {\n    constructor(element, index, descriptor, schema) {\n        this.element = element;\n        this.index = index;\n        this.eventTarget = descriptor.eventTarget || element;\n        this.eventName = descriptor.eventName || getDefaultEventNameForElement(element) || error(\"missing event name\");\n        this.eventOptions = descriptor.eventOptions || {};\n        this.identifier = descriptor.identifier || error(\"missing identifier\");\n        this.methodName = descriptor.methodName || error(\"missing method name\");\n        this.keyFilter = descriptor.keyFilter || \"\";\n        this.schema = schema;\n    }\n    static forToken(token, schema) {\n        return new this(token.element, token.index, parseActionDescriptorString(token.content), schema);\n    }\n    toString() {\n        const eventFilter = this.keyFilter ? `.${this.keyFilter}` : \"\";\n        const eventTarget = this.eventTargetName ? `@${this.eventTargetName}` : \"\";\n        return `${this.eventName}${eventFilter}${eventTarget}->${this.identifier}#${this.methodName}`;\n    }\n    isFilterTarget(event) {\n        if (!this.keyFilter) {\n            return false;\n        }\n        const filteres = this.keyFilter.split(\"+\");\n        const modifiers = [\"meta\", \"ctrl\", \"alt\", \"shift\"];\n        const [meta, ctrl, alt, shift] = modifiers.map((modifier) => filteres.includes(modifier));\n        if (event.metaKey !== meta || event.ctrlKey !== ctrl || event.altKey !== alt || event.shiftKey !== shift) {\n            return true;\n        }\n        const standardFilter = filteres.filter((key) => !modifiers.includes(key))[0];\n        if (!standardFilter) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(this.keyMappings, standardFilter)) {\n            error(`contains unknown key filter: ${this.keyFilter}`);\n        }\n        return this.keyMappings[standardFilter].toLowerCase() !== event.key.toLowerCase();\n    }\n    get params() {\n        const params = {};\n        const pattern = new RegExp(`^data-${this.identifier}-(.+)-param$`, \"i\");\n        for (const { name, value } of Array.from(this.element.attributes)) {\n            const match = name.match(pattern);\n            const key = match && match[1];\n            if (key) {\n                params[camelize(key)] = typecast(value);\n            }\n        }\n        return params;\n    }\n    get eventTargetName() {\n        return stringifyEventTarget(this.eventTarget);\n    }\n    get keyMappings() {\n        return this.schema.keyMappings;\n    }\n}\nconst defaultEventNames = {\n    a: () => \"click\",\n    button: () => \"click\",\n    form: () => \"submit\",\n    details: () => \"toggle\",\n    input: (e) => (e.getAttribute(\"type\") == \"submit\" ? \"click\" : \"input\"),\n    select: () => \"change\",\n    textarea: () => \"input\",\n};\nfunction getDefaultEventNameForElement(element) {\n    const tagName = element.tagName.toLowerCase();\n    if (tagName in defaultEventNames) {\n        return defaultEventNames[tagName](element);\n    }\n}\nfunction error(message) {\n    throw new Error(message);\n}\nfunction typecast(value) {\n    try {\n        return JSON.parse(value);\n    }\n    catch (o_O) {\n        return value;\n    }\n}\n\nclass Binding {\n    constructor(context, action) {\n        this.context = context;\n        this.action = action;\n    }\n    get index() {\n        return this.action.index;\n    }\n    get eventTarget() {\n        return this.action.eventTarget;\n    }\n    get eventOptions() {\n        return this.action.eventOptions;\n    }\n    get identifier() {\n        return this.context.identifier;\n    }\n    handleEvent(event) {\n        if (this.willBeInvokedByEvent(event) && this.applyEventModifiers(event)) {\n            this.invokeWithEvent(event);\n        }\n    }\n    get eventName() {\n        return this.action.eventName;\n    }\n    get method() {\n        const method = this.controller[this.methodName];\n        if (typeof method == \"function\") {\n            return method;\n        }\n        throw new Error(`Action \"${this.action}\" references undefined method \"${this.methodName}\"`);\n    }\n    applyEventModifiers(event) {\n        const { element } = this.action;\n        const { actionDescriptorFilters } = this.context.application;\n        let passes = true;\n        for (const [name, value] of Object.entries(this.eventOptions)) {\n            if (name in actionDescriptorFilters) {\n                const filter = actionDescriptorFilters[name];\n                passes = passes && filter({ name, value, event, element });\n            }\n            else {\n                continue;\n            }\n        }\n        return passes;\n    }\n    invokeWithEvent(event) {\n        const { target, currentTarget } = event;\n        try {\n            const { params } = this.action;\n            const actionEvent = Object.assign(event, { params });\n            this.method.call(this.controller, actionEvent);\n            this.context.logDebugActivity(this.methodName, { event, target, currentTarget, action: this.methodName });\n        }\n        catch (error) {\n            const { identifier, controller, element, index } = this;\n            const detail = { identifier, controller, element, index, event };\n            this.context.handleError(error, `invoking action \"${this.action}\"`, detail);\n        }\n    }\n    willBeInvokedByEvent(event) {\n        const eventTarget = event.target;\n        if (event instanceof KeyboardEvent && this.action.isFilterTarget(event)) {\n            return false;\n        }\n        if (this.element === eventTarget) {\n            return true;\n        }\n        else if (eventTarget instanceof Element && this.element.contains(eventTarget)) {\n            return this.scope.containsElement(eventTarget);\n        }\n        else {\n            return this.scope.containsElement(this.action.element);\n        }\n    }\n    get controller() {\n        return this.context.controller;\n    }\n    get methodName() {\n        return this.action.methodName;\n    }\n    get element() {\n        return this.scope.element;\n    }\n    get scope() {\n        return this.context.scope;\n    }\n}\n\nclass ElementObserver {\n    constructor(element, delegate) {\n        this.mutationObserverInit = { attributes: true, childList: true, subtree: true };\n        this.element = element;\n        this.started = false;\n        this.delegate = delegate;\n        this.elements = new Set();\n        this.mutationObserver = new MutationObserver((mutations) => this.processMutations(mutations));\n    }\n    start() {\n        if (!this.started) {\n            this.started = true;\n            this.mutationObserver.observe(this.element, this.mutationObserverInit);\n            this.refresh();\n        }\n    }\n    pause(callback) {\n        if (this.started) {\n            this.mutationObserver.disconnect();\n            this.started = false;\n        }\n        callback();\n        if (!this.started) {\n            this.mutationObserver.observe(this.element, this.mutationObserverInit);\n            this.started = true;\n        }\n    }\n    stop() {\n        if (this.started) {\n            this.mutationObserver.takeRecords();\n            this.mutationObserver.disconnect();\n            this.started = false;\n        }\n    }\n    refresh() {\n        if (this.started) {\n            const matches = new Set(this.matchElementsInTree());\n            for (const element of Array.from(this.elements)) {\n                if (!matches.has(element)) {\n                    this.removeElement(element);\n                }\n            }\n            for (const element of Array.from(matches)) {\n                this.addElement(element);\n            }\n        }\n    }\n    processMutations(mutations) {\n        if (this.started) {\n            for (const mutation of mutations) {\n                this.processMutation(mutation);\n            }\n        }\n    }\n    processMutation(mutation) {\n        if (mutation.type == \"attributes\") {\n            this.processAttributeChange(mutation.target, mutation.attributeName);\n        }\n        else if (mutation.type == \"childList\") {\n            this.processRemovedNodes(mutation.removedNodes);\n            this.processAddedNodes(mutation.addedNodes);\n        }\n    }\n    processAttributeChange(node, attributeName) {\n        const element = node;\n        if (this.elements.has(element)) {\n            if (this.delegate.elementAttributeChanged && this.matchElement(element)) {\n                this.delegate.elementAttributeChanged(element, attributeName);\n            }\n            else {\n                this.removeElement(element);\n            }\n        }\n        else if (this.matchElement(element)) {\n            this.addElement(element);\n        }\n    }\n    processRemovedNodes(nodes) {\n        for (const node of Array.from(nodes)) {\n            const element = this.elementFromNode(node);\n            if (element) {\n                this.processTree(element, this.removeElement);\n            }\n        }\n    }\n    processAddedNodes(nodes) {\n        for (const node of Array.from(nodes)) {\n            const element = this.elementFromNode(node);\n            if (element && this.elementIsActive(element)) {\n                this.processTree(element, this.addElement);\n            }\n        }\n    }\n    matchElement(element) {\n        return this.delegate.matchElement(element);\n    }\n    matchElementsInTree(tree = this.element) {\n        return this.delegate.matchElementsInTree(tree);\n    }\n    processTree(tree, processor) {\n        for (const element of this.matchElementsInTree(tree)) {\n            processor.call(this, element);\n        }\n    }\n    elementFromNode(node) {\n        if (node.nodeType == Node.ELEMENT_NODE) {\n            return node;\n        }\n    }\n    elementIsActive(element) {\n        if (element.isConnected != this.element.isConnected) {\n            return false;\n        }\n        else {\n            return this.element.contains(element);\n        }\n    }\n    addElement(element) {\n        if (!this.elements.has(element)) {\n            if (this.elementIsActive(element)) {\n                this.elements.add(element);\n                if (this.delegate.elementMatched) {\n                    this.delegate.elementMatched(element);\n                }\n            }\n        }\n    }\n    removeElement(element) {\n        if (this.elements.has(element)) {\n            this.elements.delete(element);\n            if (this.delegate.elementUnmatched) {\n                this.delegate.elementUnmatched(element);\n            }\n        }\n    }\n}\n\nclass AttributeObserver {\n    constructor(element, attributeName, delegate) {\n        this.attributeName = attributeName;\n        this.delegate = delegate;\n        this.elementObserver = new ElementObserver(element, this);\n    }\n    get element() {\n        return this.elementObserver.element;\n    }\n    get selector() {\n        return `[${this.attributeName}]`;\n    }\n    start() {\n        this.elementObserver.start();\n    }\n    pause(callback) {\n        this.elementObserver.pause(callback);\n    }\n    stop() {\n        this.elementObserver.stop();\n    }\n    refresh() {\n        this.elementObserver.refresh();\n    }\n    get started() {\n        return this.elementObserver.started;\n    }\n    matchElement(element) {\n        return element.hasAttribute(this.attributeName);\n    }\n    matchElementsInTree(tree) {\n        const match = this.matchElement(tree) ? [tree] : [];\n        const matches = Array.from(tree.querySelectorAll(this.selector));\n        return match.concat(matches);\n    }\n    elementMatched(element) {\n        if (this.delegate.elementMatchedAttribute) {\n            this.delegate.elementMatchedAttribute(element, this.attributeName);\n        }\n    }\n    elementUnmatched(element) {\n        if (this.delegate.elementUnmatchedAttribute) {\n            this.delegate.elementUnmatchedAttribute(element, this.attributeName);\n        }\n    }\n    elementAttributeChanged(element, attributeName) {\n        if (this.delegate.elementAttributeValueChanged && this.attributeName == attributeName) {\n            this.delegate.elementAttributeValueChanged(element, attributeName);\n        }\n    }\n}\n\nfunction add(map, key, value) {\n    fetch(map, key).add(value);\n}\nfunction del(map, key, value) {\n    fetch(map, key).delete(value);\n    prune(map, key);\n}\nfunction fetch(map, key) {\n    let values = map.get(key);\n    if (!values) {\n        values = new Set();\n        map.set(key, values);\n    }\n    return values;\n}\nfunction prune(map, key) {\n    const values = map.get(key);\n    if (values != null && values.size == 0) {\n        map.delete(key);\n    }\n}\n\nclass Multimap {\n    constructor() {\n        this.valuesByKey = new Map();\n    }\n    get keys() {\n        return Array.from(this.valuesByKey.keys());\n    }\n    get values() {\n        const sets = Array.from(this.valuesByKey.values());\n        return sets.reduce((values, set) => values.concat(Array.from(set)), []);\n    }\n    get size() {\n        const sets = Array.from(this.valuesByKey.values());\n        return sets.reduce((size, set) => size + set.size, 0);\n    }\n    add(key, value) {\n        add(this.valuesByKey, key, value);\n    }\n    delete(key, value) {\n        del(this.valuesByKey, key, value);\n    }\n    has(key, value) {\n        const values = this.valuesByKey.get(key);\n        return values != null && values.has(value);\n    }\n    hasKey(key) {\n        return this.valuesByKey.has(key);\n    }\n    hasValue(value) {\n        const sets = Array.from(this.valuesByKey.values());\n        return sets.some((set) => set.has(value));\n    }\n    getValuesForKey(key) {\n        const values = this.valuesByKey.get(key);\n        return values ? Array.from(values) : [];\n    }\n    getKeysForValue(value) {\n        return Array.from(this.valuesByKey)\n            .filter(([_key, values]) => values.has(value))\n            .map(([key, _values]) => key);\n    }\n}\n\nclass IndexedMultimap extends Multimap {\n    constructor() {\n        super();\n        this.keysByValue = new Map();\n    }\n    get values() {\n        return Array.from(this.keysByValue.keys());\n    }\n    add(key, value) {\n        super.add(key, value);\n        add(this.keysByValue, value, key);\n    }\n    delete(key, value) {\n        super.delete(key, value);\n        del(this.keysByValue, value, key);\n    }\n    hasValue(value) {\n        return this.keysByValue.has(value);\n    }\n    getKeysForValue(value) {\n        const set = this.keysByValue.get(value);\n        return set ? Array.from(set) : [];\n    }\n}\n\nclass SelectorObserver {\n    constructor(element, selector, delegate, details = {}) {\n        this.selector = selector;\n        this.details = details;\n        this.elementObserver = new ElementObserver(element, this);\n        this.delegate = delegate;\n        this.matchesByElement = new Multimap();\n    }\n    get started() {\n        return this.elementObserver.started;\n    }\n    start() {\n        this.elementObserver.start();\n    }\n    pause(callback) {\n        this.elementObserver.pause(callback);\n    }\n    stop() {\n        this.elementObserver.stop();\n    }\n    refresh() {\n        this.elementObserver.refresh();\n    }\n    get element() {\n        return this.elementObserver.element;\n    }\n    matchElement(element) {\n        const matches = element.matches(this.selector);\n        if (this.delegate.selectorMatchElement) {\n            return matches && this.delegate.selectorMatchElement(element, this.details);\n        }\n        return matches;\n    }\n    matchElementsInTree(tree) {\n        const match = this.matchElement(tree) ? [tree] : [];\n        const matches = Array.from(tree.querySelectorAll(this.selector)).filter((match) => this.matchElement(match));\n        return match.concat(matches);\n    }\n    elementMatched(element) {\n        this.selectorMatched(element);\n    }\n    elementUnmatched(element) {\n        this.selectorUnmatched(element);\n    }\n    elementAttributeChanged(element, _attributeName) {\n        const matches = this.matchElement(element);\n        const matchedBefore = this.matchesByElement.has(this.selector, element);\n        if (!matches && matchedBefore) {\n            this.selectorUnmatched(element);\n        }\n    }\n    selectorMatched(element) {\n        if (this.delegate.selectorMatched) {\n            this.delegate.selectorMatched(element, this.selector, this.details);\n            this.matchesByElement.add(this.selector, element);\n        }\n    }\n    selectorUnmatched(element) {\n        this.delegate.selectorUnmatched(element, this.selector, this.details);\n        this.matchesByElement.delete(this.selector, element);\n    }\n}\n\nclass StringMapObserver {\n    constructor(element, delegate) {\n        this.element = element;\n        this.delegate = delegate;\n        this.started = false;\n        this.stringMap = new Map();\n        this.mutationObserver = new MutationObserver((mutations) => this.processMutations(mutations));\n    }\n    start() {\n        if (!this.started) {\n            this.started = true;\n            this.mutationObserver.observe(this.element, { attributes: true, attributeOldValue: true });\n            this.refresh();\n        }\n    }\n    stop() {\n        if (this.started) {\n            this.mutationObserver.takeRecords();\n            this.mutationObserver.disconnect();\n            this.started = false;\n        }\n    }\n    refresh() {\n        if (this.started) {\n            for (const attributeName of this.knownAttributeNames) {\n                this.refreshAttribute(attributeName, null);\n            }\n        }\n    }\n    processMutations(mutations) {\n        if (this.started) {\n            for (const mutation of mutations) {\n                this.processMutation(mutation);\n            }\n        }\n    }\n    processMutation(mutation) {\n        const attributeName = mutation.attributeName;\n        if (attributeName) {\n            this.refreshAttribute(attributeName, mutation.oldValue);\n        }\n    }\n    refreshAttribute(attributeName, oldValue) {\n        const key = this.delegate.getStringMapKeyForAttribute(attributeName);\n        if (key != null) {\n            if (!this.stringMap.has(attributeName)) {\n                this.stringMapKeyAdded(key, attributeName);\n            }\n            const value = this.element.getAttribute(attributeName);\n            if (this.stringMap.get(attributeName) != value) {\n                this.stringMapValueChanged(value, key, oldValue);\n            }\n            if (value == null) {\n                const oldValue = this.stringMap.get(attributeName);\n                this.stringMap.delete(attributeName);\n                if (oldValue)\n                    this.stringMapKeyRemoved(key, attributeName, oldValue);\n            }\n            else {\n                this.stringMap.set(attributeName, value);\n            }\n        }\n    }\n    stringMapKeyAdded(key, attributeName) {\n        if (this.delegate.stringMapKeyAdded) {\n            this.delegate.stringMapKeyAdded(key, attributeName);\n        }\n    }\n    stringMapValueChanged(value, key, oldValue) {\n        if (this.delegate.stringMapValueChanged) {\n            this.delegate.stringMapValueChanged(value, key, oldValue);\n        }\n    }\n    stringMapKeyRemoved(key, attributeName, oldValue) {\n        if (this.delegate.stringMapKeyRemoved) {\n            this.delegate.stringMapKeyRemoved(key, attributeName, oldValue);\n        }\n    }\n    get knownAttributeNames() {\n        return Array.from(new Set(this.currentAttributeNames.concat(this.recordedAttributeNames)));\n    }\n    get currentAttributeNames() {\n        return Array.from(this.element.attributes).map((attribute) => attribute.name);\n    }\n    get recordedAttributeNames() {\n        return Array.from(this.stringMap.keys());\n    }\n}\n\nclass TokenListObserver {\n    constructor(element, attributeName, delegate) {\n        this.attributeObserver = new AttributeObserver(element, attributeName, this);\n        this.delegate = delegate;\n        this.tokensByElement = new Multimap();\n    }\n    get started() {\n        return this.attributeObserver.started;\n    }\n    start() {\n        this.attributeObserver.start();\n    }\n    pause(callback) {\n        this.attributeObserver.pause(callback);\n    }\n    stop() {\n        this.attributeObserver.stop();\n    }\n    refresh() {\n        this.attributeObserver.refresh();\n    }\n    get element() {\n        return this.attributeObserver.element;\n    }\n    get attributeName() {\n        return this.attributeObserver.attributeName;\n    }\n    elementMatchedAttribute(element) {\n        this.tokensMatched(this.readTokensForElement(element));\n    }\n    elementAttributeValueChanged(element) {\n        const [unmatchedTokens, matchedTokens] = this.refreshTokensForElement(element);\n        this.tokensUnmatched(unmatchedTokens);\n        this.tokensMatched(matchedTokens);\n    }\n    elementUnmatchedAttribute(element) {\n        this.tokensUnmatched(this.tokensByElement.getValuesForKey(element));\n    }\n    tokensMatched(tokens) {\n        tokens.forEach((token) => this.tokenMatched(token));\n    }\n    tokensUnmatched(tokens) {\n        tokens.forEach((token) => this.tokenUnmatched(token));\n    }\n    tokenMatched(token) {\n        this.delegate.tokenMatched(token);\n        this.tokensByElement.add(token.element, token);\n    }\n    tokenUnmatched(token) {\n        this.delegate.tokenUnmatched(token);\n        this.tokensByElement.delete(token.element, token);\n    }\n    refreshTokensForElement(element) {\n        const previousTokens = this.tokensByElement.getValuesForKey(element);\n        const currentTokens = this.readTokensForElement(element);\n        const firstDifferingIndex = zip(previousTokens, currentTokens).findIndex(([previousToken, currentToken]) => !tokensAreEqual(previousToken, currentToken));\n        if (firstDifferingIndex == -1) {\n            return [[], []];\n        }\n        else {\n            return [previousTokens.slice(firstDifferingIndex), currentTokens.slice(firstDifferingIndex)];\n        }\n    }\n    readTokensForElement(element) {\n        const attributeName = this.attributeName;\n        const tokenString = element.getAttribute(attributeName) || \"\";\n        return parseTokenString(tokenString, element, attributeName);\n    }\n}\nfunction parseTokenString(tokenString, element, attributeName) {\n    return tokenString\n        .trim()\n        .split(/\\s+/)\n        .filter((content) => content.length)\n        .map((content, index) => ({ element, attributeName, content, index }));\n}\nfunction zip(left, right) {\n    const length = Math.max(left.length, right.length);\n    return Array.from({ length }, (_, index) => [left[index], right[index]]);\n}\nfunction tokensAreEqual(left, right) {\n    return left && right && left.index == right.index && left.content == right.content;\n}\n\nclass ValueListObserver {\n    constructor(element, attributeName, delegate) {\n        this.tokenListObserver = new TokenListObserver(element, attributeName, this);\n        this.delegate = delegate;\n        this.parseResultsByToken = new WeakMap();\n        this.valuesByTokenByElement = new WeakMap();\n    }\n    get started() {\n        return this.tokenListObserver.started;\n    }\n    start() {\n        this.tokenListObserver.start();\n    }\n    stop() {\n        this.tokenListObserver.stop();\n    }\n    refresh() {\n        this.tokenListObserver.refresh();\n    }\n    get element() {\n        return this.tokenListObserver.element;\n    }\n    get attributeName() {\n        return this.tokenListObserver.attributeName;\n    }\n    tokenMatched(token) {\n        const { element } = token;\n        const { value } = this.fetchParseResultForToken(token);\n        if (value) {\n            this.fetchValuesByTokenForElement(element).set(token, value);\n            this.delegate.elementMatchedValue(element, value);\n        }\n    }\n    tokenUnmatched(token) {\n        const { element } = token;\n        const { value } = this.fetchParseResultForToken(token);\n        if (value) {\n            this.fetchValuesByTokenForElement(element).delete(token);\n            this.delegate.elementUnmatchedValue(element, value);\n        }\n    }\n    fetchParseResultForToken(token) {\n        let parseResult = this.parseResultsByToken.get(token);\n        if (!parseResult) {\n            parseResult = this.parseToken(token);\n            this.parseResultsByToken.set(token, parseResult);\n        }\n        return parseResult;\n    }\n    fetchValuesByTokenForElement(element) {\n        let valuesByToken = this.valuesByTokenByElement.get(element);\n        if (!valuesByToken) {\n            valuesByToken = new Map();\n            this.valuesByTokenByElement.set(element, valuesByToken);\n        }\n        return valuesByToken;\n    }\n    parseToken(token) {\n        try {\n            const value = this.delegate.parseValueForToken(token);\n            return { value };\n        }\n        catch (error) {\n            return { error };\n        }\n    }\n}\n\nclass BindingObserver {\n    constructor(context, delegate) {\n        this.context = context;\n        this.delegate = delegate;\n        this.bindingsByAction = new Map();\n    }\n    start() {\n        if (!this.valueListObserver) {\n            this.valueListObserver = new ValueListObserver(this.element, this.actionAttribute, this);\n            this.valueListObserver.start();\n        }\n    }\n    stop() {\n        if (this.valueListObserver) {\n            this.valueListObserver.stop();\n            delete this.valueListObserver;\n            this.disconnectAllActions();\n        }\n    }\n    get element() {\n        return this.context.element;\n    }\n    get identifier() {\n        return this.context.identifier;\n    }\n    get actionAttribute() {\n        return this.schema.actionAttribute;\n    }\n    get schema() {\n        return this.context.schema;\n    }\n    get bindings() {\n        return Array.from(this.bindingsByAction.values());\n    }\n    connectAction(action) {\n        const binding = new Binding(this.context, action);\n        this.bindingsByAction.set(action, binding);\n        this.delegate.bindingConnected(binding);\n    }\n    disconnectAction(action) {\n        const binding = this.bindingsByAction.get(action);\n        if (binding) {\n            this.bindingsByAction.delete(action);\n            this.delegate.bindingDisconnected(binding);\n        }\n    }\n    disconnectAllActions() {\n        this.bindings.forEach((binding) => this.delegate.bindingDisconnected(binding, true));\n        this.bindingsByAction.clear();\n    }\n    parseValueForToken(token) {\n        const action = Action.forToken(token, this.schema);\n        if (action.identifier == this.identifier) {\n            return action;\n        }\n    }\n    elementMatchedValue(element, action) {\n        this.connectAction(action);\n    }\n    elementUnmatchedValue(element, action) {\n        this.disconnectAction(action);\n    }\n}\n\nclass ValueObserver {\n    constructor(context, receiver) {\n        this.context = context;\n        this.receiver = receiver;\n        this.stringMapObserver = new StringMapObserver(this.element, this);\n        this.valueDescriptorMap = this.controller.valueDescriptorMap;\n    }\n    start() {\n        this.stringMapObserver.start();\n        this.invokeChangedCallbacksForDefaultValues();\n    }\n    stop() {\n        this.stringMapObserver.stop();\n    }\n    get element() {\n        return this.context.element;\n    }\n    get controller() {\n        return this.context.controller;\n    }\n    getStringMapKeyForAttribute(attributeName) {\n        if (attributeName in this.valueDescriptorMap) {\n            return this.valueDescriptorMap[attributeName].name;\n        }\n    }\n    stringMapKeyAdded(key, attributeName) {\n        const descriptor = this.valueDescriptorMap[attributeName];\n        if (!this.hasValue(key)) {\n            this.invokeChangedCallback(key, descriptor.writer(this.receiver[key]), descriptor.writer(descriptor.defaultValue));\n        }\n    }\n    stringMapValueChanged(value, name, oldValue) {\n        const descriptor = this.valueDescriptorNameMap[name];\n        if (value === null)\n            return;\n        if (oldValue === null) {\n            oldValue = descriptor.writer(descriptor.defaultValue);\n        }\n        this.invokeChangedCallback(name, value, oldValue);\n    }\n    stringMapKeyRemoved(key, attributeName, oldValue) {\n        const descriptor = this.valueDescriptorNameMap[key];\n        if (this.hasValue(key)) {\n            this.invokeChangedCallback(key, descriptor.writer(this.receiver[key]), oldValue);\n        }\n        else {\n            this.invokeChangedCallback(key, descriptor.writer(descriptor.defaultValue), oldValue);\n        }\n    }\n    invokeChangedCallbacksForDefaultValues() {\n        for (const { key, name, defaultValue, writer } of this.valueDescriptors) {\n            if (defaultValue != undefined && !this.controller.data.has(key)) {\n                this.invokeChangedCallback(name, writer(defaultValue), undefined);\n            }\n        }\n    }\n    invokeChangedCallback(name, rawValue, rawOldValue) {\n        const changedMethodName = `${name}Changed`;\n        const changedMethod = this.receiver[changedMethodName];\n        if (typeof changedMethod == \"function\") {\n            const descriptor = this.valueDescriptorNameMap[name];\n            try {\n                const value = descriptor.reader(rawValue);\n                let oldValue = rawOldValue;\n                if (rawOldValue) {\n                    oldValue = descriptor.reader(rawOldValue);\n                }\n                changedMethod.call(this.receiver, value, oldValue);\n            }\n            catch (error) {\n                if (error instanceof TypeError) {\n                    error.message = `Stimulus Value \"${this.context.identifier}.${descriptor.name}\" - ${error.message}`;\n                }\n                throw error;\n            }\n        }\n    }\n    get valueDescriptors() {\n        const { valueDescriptorMap } = this;\n        return Object.keys(valueDescriptorMap).map((key) => valueDescriptorMap[key]);\n    }\n    get valueDescriptorNameMap() {\n        const descriptors = {};\n        Object.keys(this.valueDescriptorMap).forEach((key) => {\n            const descriptor = this.valueDescriptorMap[key];\n            descriptors[descriptor.name] = descriptor;\n        });\n        return descriptors;\n    }\n    hasValue(attributeName) {\n        const descriptor = this.valueDescriptorNameMap[attributeName];\n        const hasMethodName = `has${capitalize(descriptor.name)}`;\n        return this.receiver[hasMethodName];\n    }\n}\n\nclass TargetObserver {\n    constructor(context, delegate) {\n        this.context = context;\n        this.delegate = delegate;\n        this.targetsByName = new Multimap();\n    }\n    start() {\n        if (!this.tokenListObserver) {\n            this.tokenListObserver = new TokenListObserver(this.element, this.attributeName, this);\n            this.tokenListObserver.start();\n        }\n    }\n    stop() {\n        if (this.tokenListObserver) {\n            this.disconnectAllTargets();\n            this.tokenListObserver.stop();\n            delete this.tokenListObserver;\n        }\n    }\n    tokenMatched({ element, content: name }) {\n        if (this.scope.containsElement(element)) {\n            this.connectTarget(element, name);\n        }\n    }\n    tokenUnmatched({ element, content: name }) {\n        this.disconnectTarget(element, name);\n    }\n    connectTarget(element, name) {\n        var _a;\n        if (!this.targetsByName.has(name, element)) {\n            this.targetsByName.add(name, element);\n            (_a = this.tokenListObserver) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.targetConnected(element, name));\n        }\n    }\n    disconnectTarget(element, name) {\n        var _a;\n        if (this.targetsByName.has(name, element)) {\n            this.targetsByName.delete(name, element);\n            (_a = this.tokenListObserver) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.targetDisconnected(element, name));\n        }\n    }\n    disconnectAllTargets() {\n        for (const name of this.targetsByName.keys) {\n            for (const element of this.targetsByName.getValuesForKey(name)) {\n                this.disconnectTarget(element, name);\n            }\n        }\n    }\n    get attributeName() {\n        return `data-${this.context.identifier}-target`;\n    }\n    get element() {\n        return this.context.element;\n    }\n    get scope() {\n        return this.context.scope;\n    }\n}\n\nfunction readInheritableStaticArrayValues(constructor, propertyName) {\n    const ancestors = getAncestorsForConstructor(constructor);\n    return Array.from(ancestors.reduce((values, constructor) => {\n        getOwnStaticArrayValues(constructor, propertyName).forEach((name) => values.add(name));\n        return values;\n    }, new Set()));\n}\nfunction readInheritableStaticObjectPairs(constructor, propertyName) {\n    const ancestors = getAncestorsForConstructor(constructor);\n    return ancestors.reduce((pairs, constructor) => {\n        pairs.push(...getOwnStaticObjectPairs(constructor, propertyName));\n        return pairs;\n    }, []);\n}\nfunction getAncestorsForConstructor(constructor) {\n    const ancestors = [];\n    while (constructor) {\n        ancestors.push(constructor);\n        constructor = Object.getPrototypeOf(constructor);\n    }\n    return ancestors.reverse();\n}\nfunction getOwnStaticArrayValues(constructor, propertyName) {\n    const definition = constructor[propertyName];\n    return Array.isArray(definition) ? definition : [];\n}\nfunction getOwnStaticObjectPairs(constructor, propertyName) {\n    const definition = constructor[propertyName];\n    return definition ? Object.keys(definition).map((key) => [key, definition[key]]) : [];\n}\n\nclass OutletObserver {\n    constructor(context, delegate) {\n        this.context = context;\n        this.delegate = delegate;\n        this.outletsByName = new Multimap();\n        this.outletElementsByName = new Multimap();\n        this.selectorObserverMap = new Map();\n    }\n    start() {\n        if (this.selectorObserverMap.size === 0) {\n            this.outletDefinitions.forEach((outletName) => {\n                const selector = this.selector(outletName);\n                const details = { outletName };\n                if (selector) {\n                    this.selectorObserverMap.set(outletName, new SelectorObserver(document.body, selector, this, details));\n                }\n            });\n            this.selectorObserverMap.forEach((observer) => observer.start());\n        }\n        this.dependentContexts.forEach((context) => context.refresh());\n    }\n    stop() {\n        if (this.selectorObserverMap.size > 0) {\n            this.disconnectAllOutlets();\n            this.selectorObserverMap.forEach((observer) => observer.stop());\n            this.selectorObserverMap.clear();\n        }\n    }\n    refresh() {\n        this.selectorObserverMap.forEach((observer) => observer.refresh());\n    }\n    selectorMatched(element, _selector, { outletName }) {\n        const outlet = this.getOutlet(element, outletName);\n        if (outlet) {\n            this.connectOutlet(outlet, element, outletName);\n        }\n    }\n    selectorUnmatched(element, _selector, { outletName }) {\n        const outlet = this.getOutletFromMap(element, outletName);\n        if (outlet) {\n            this.disconnectOutlet(outlet, element, outletName);\n        }\n    }\n    selectorMatchElement(element, { outletName }) {\n        return (this.hasOutlet(element, outletName) &&\n            element.matches(`[${this.context.application.schema.controllerAttribute}~=${outletName}]`));\n    }\n    connectOutlet(outlet, element, outletName) {\n        var _a;\n        if (!this.outletElementsByName.has(outletName, element)) {\n            this.outletsByName.add(outletName, outlet);\n            this.outletElementsByName.add(outletName, element);\n            (_a = this.selectorObserverMap.get(outletName)) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.outletConnected(outlet, element, outletName));\n        }\n    }\n    disconnectOutlet(outlet, element, outletName) {\n        var _a;\n        if (this.outletElementsByName.has(outletName, element)) {\n            this.outletsByName.delete(outletName, outlet);\n            this.outletElementsByName.delete(outletName, element);\n            (_a = this.selectorObserverMap\n                .get(outletName)) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.outletDisconnected(outlet, element, outletName));\n        }\n    }\n    disconnectAllOutlets() {\n        for (const outletName of this.outletElementsByName.keys) {\n            for (const element of this.outletElementsByName.getValuesForKey(outletName)) {\n                for (const outlet of this.outletsByName.getValuesForKey(outletName)) {\n                    this.disconnectOutlet(outlet, element, outletName);\n                }\n            }\n        }\n    }\n    selector(outletName) {\n        return this.scope.outlets.getSelectorForOutletName(outletName);\n    }\n    get outletDependencies() {\n        const dependencies = new Multimap();\n        this.router.modules.forEach((module) => {\n            const constructor = module.definition.controllerConstructor;\n            const outlets = readInheritableStaticArrayValues(constructor, \"outlets\");\n            outlets.forEach((outlet) => dependencies.add(outlet, module.identifier));\n        });\n        return dependencies;\n    }\n    get outletDefinitions() {\n        return this.outletDependencies.getKeysForValue(this.identifier);\n    }\n    get dependentControllerIdentifiers() {\n        return this.outletDependencies.getValuesForKey(this.identifier);\n    }\n    get dependentContexts() {\n        const identifiers = this.dependentControllerIdentifiers;\n        return this.router.contexts.filter((context) => identifiers.includes(context.identifier));\n    }\n    hasOutlet(element, outletName) {\n        return !!this.getOutlet(element, outletName) || !!this.getOutletFromMap(element, outletName);\n    }\n    getOutlet(element, outletName) {\n        return this.application.getControllerForElementAndIdentifier(element, outletName);\n    }\n    getOutletFromMap(element, outletName) {\n        return this.outletsByName.getValuesForKey(outletName).find((outlet) => outlet.element === element);\n    }\n    get scope() {\n        return this.context.scope;\n    }\n    get identifier() {\n        return this.context.identifier;\n    }\n    get application() {\n        return this.context.application;\n    }\n    get router() {\n        return this.application.router;\n    }\n}\n\nclass Context {\n    constructor(module, scope) {\n        this.logDebugActivity = (functionName, detail = {}) => {\n            const { identifier, controller, element } = this;\n            detail = Object.assign({ identifier, controller, element }, detail);\n            this.application.logDebugActivity(this.identifier, functionName, detail);\n        };\n        this.module = module;\n        this.scope = scope;\n        this.controller = new module.controllerConstructor(this);\n        this.bindingObserver = new BindingObserver(this, this.dispatcher);\n        this.valueObserver = new ValueObserver(this, this.controller);\n        this.targetObserver = new TargetObserver(this, this);\n        this.outletObserver = new OutletObserver(this, this);\n        try {\n            this.controller.initialize();\n            this.logDebugActivity(\"initialize\");\n        }\n        catch (error) {\n            this.handleError(error, \"initializing controller\");\n        }\n    }\n    connect() {\n        this.bindingObserver.start();\n        this.valueObserver.start();\n        this.targetObserver.start();\n        this.outletObserver.start();\n        try {\n            this.controller.connect();\n            this.logDebugActivity(\"connect\");\n        }\n        catch (error) {\n            this.handleError(error, \"connecting controller\");\n        }\n    }\n    refresh() {\n        this.outletObserver.refresh();\n    }\n    disconnect() {\n        try {\n            this.controller.disconnect();\n            this.logDebugActivity(\"disconnect\");\n        }\n        catch (error) {\n            this.handleError(error, \"disconnecting controller\");\n        }\n        this.outletObserver.stop();\n        this.targetObserver.stop();\n        this.valueObserver.stop();\n        this.bindingObserver.stop();\n    }\n    get application() {\n        return this.module.application;\n    }\n    get identifier() {\n        return this.module.identifier;\n    }\n    get schema() {\n        return this.application.schema;\n    }\n    get dispatcher() {\n        return this.application.dispatcher;\n    }\n    get element() {\n        return this.scope.element;\n    }\n    get parentElement() {\n        return this.element.parentElement;\n    }\n    handleError(error, message, detail = {}) {\n        const { identifier, controller, element } = this;\n        detail = Object.assign({ identifier, controller, element }, detail);\n        this.application.handleError(error, `Error ${message}`, detail);\n    }\n    targetConnected(element, name) {\n        this.invokeControllerMethod(`${name}TargetConnected`, element);\n    }\n    targetDisconnected(element, name) {\n        this.invokeControllerMethod(`${name}TargetDisconnected`, element);\n    }\n    outletConnected(outlet, element, name) {\n        this.invokeControllerMethod(`${namespaceCamelize(name)}OutletConnected`, outlet, element);\n    }\n    outletDisconnected(outlet, element, name) {\n        this.invokeControllerMethod(`${namespaceCamelize(name)}OutletDisconnected`, outlet, element);\n    }\n    invokeControllerMethod(methodName, ...args) {\n        const controller = this.controller;\n        if (typeof controller[methodName] == \"function\") {\n            controller[methodName](...args);\n        }\n    }\n}\n\nfunction bless(constructor) {\n    return shadow(constructor, getBlessedProperties(constructor));\n}\nfunction shadow(constructor, properties) {\n    const shadowConstructor = extend(constructor);\n    const shadowProperties = getShadowProperties(constructor.prototype, properties);\n    Object.defineProperties(shadowConstructor.prototype, shadowProperties);\n    return shadowConstructor;\n}\nfunction getBlessedProperties(constructor) {\n    const blessings = readInheritableStaticArrayValues(constructor, \"blessings\");\n    return blessings.reduce((blessedProperties, blessing) => {\n        const properties = blessing(constructor);\n        for (const key in properties) {\n            const descriptor = blessedProperties[key] || {};\n            blessedProperties[key] = Object.assign(descriptor, properties[key]);\n        }\n        return blessedProperties;\n    }, {});\n}\nfunction getShadowProperties(prototype, properties) {\n    return getOwnKeys(properties).reduce((shadowProperties, key) => {\n        const descriptor = getShadowedDescriptor(prototype, properties, key);\n        if (descriptor) {\n            Object.assign(shadowProperties, { [key]: descriptor });\n        }\n        return shadowProperties;\n    }, {});\n}\nfunction getShadowedDescriptor(prototype, properties, key) {\n    const shadowingDescriptor = Object.getOwnPropertyDescriptor(prototype, key);\n    const shadowedByValue = shadowingDescriptor && \"value\" in shadowingDescriptor;\n    if (!shadowedByValue) {\n        const descriptor = Object.getOwnPropertyDescriptor(properties, key).value;\n        if (shadowingDescriptor) {\n            descriptor.get = shadowingDescriptor.get || descriptor.get;\n            descriptor.set = shadowingDescriptor.set || descriptor.set;\n        }\n        return descriptor;\n    }\n}\nconst getOwnKeys = (() => {\n    if (typeof Object.getOwnPropertySymbols == \"function\") {\n        return (object) => [...Object.getOwnPropertyNames(object), ...Object.getOwnPropertySymbols(object)];\n    }\n    else {\n        return Object.getOwnPropertyNames;\n    }\n})();\nconst extend = (() => {\n    function extendWithReflect(constructor) {\n        function extended() {\n            return Reflect.construct(constructor, arguments, new.target);\n        }\n        extended.prototype = Object.create(constructor.prototype, {\n            constructor: { value: extended },\n        });\n        Reflect.setPrototypeOf(extended, constructor);\n        return extended;\n    }\n    function testReflectExtension() {\n        const a = function () {\n            this.a.call(this);\n        };\n        const b = extendWithReflect(a);\n        b.prototype.a = function () { };\n        return new b();\n    }\n    try {\n        testReflectExtension();\n        return extendWithReflect;\n    }\n    catch (error) {\n        return (constructor) => class extended extends constructor {\n        };\n    }\n})();\n\nfunction blessDefinition(definition) {\n    return {\n        identifier: definition.identifier,\n        controllerConstructor: bless(definition.controllerConstructor),\n    };\n}\n\nclass Module {\n    constructor(application, definition) {\n        this.application = application;\n        this.definition = blessDefinition(definition);\n        this.contextsByScope = new WeakMap();\n        this.connectedContexts = new Set();\n    }\n    get identifier() {\n        return this.definition.identifier;\n    }\n    get controllerConstructor() {\n        return this.definition.controllerConstructor;\n    }\n    get contexts() {\n        return Array.from(this.connectedContexts);\n    }\n    connectContextForScope(scope) {\n        const context = this.fetchContextForScope(scope);\n        this.connectedContexts.add(context);\n        context.connect();\n    }\n    disconnectContextForScope(scope) {\n        const context = this.contextsByScope.get(scope);\n        if (context) {\n            this.connectedContexts.delete(context);\n            context.disconnect();\n        }\n    }\n    fetchContextForScope(scope) {\n        let context = this.contextsByScope.get(scope);\n        if (!context) {\n            context = new Context(this, scope);\n            this.contextsByScope.set(scope, context);\n        }\n        return context;\n    }\n}\n\nclass ClassMap {\n    constructor(scope) {\n        this.scope = scope;\n    }\n    has(name) {\n        return this.data.has(this.getDataKey(name));\n    }\n    get(name) {\n        return this.getAll(name)[0];\n    }\n    getAll(name) {\n        const tokenString = this.data.get(this.getDataKey(name)) || \"\";\n        return tokenize(tokenString);\n    }\n    getAttributeName(name) {\n        return this.data.getAttributeNameForKey(this.getDataKey(name));\n    }\n    getDataKey(name) {\n        return `${name}-class`;\n    }\n    get data() {\n        return this.scope.data;\n    }\n}\n\nclass DataMap {\n    constructor(scope) {\n        this.scope = scope;\n    }\n    get element() {\n        return this.scope.element;\n    }\n    get identifier() {\n        return this.scope.identifier;\n    }\n    get(key) {\n        const name = this.getAttributeNameForKey(key);\n        return this.element.getAttribute(name);\n    }\n    set(key, value) {\n        const name = this.getAttributeNameForKey(key);\n        this.element.setAttribute(name, value);\n        return this.get(key);\n    }\n    has(key) {\n        const name = this.getAttributeNameForKey(key);\n        return this.element.hasAttribute(name);\n    }\n    delete(key) {\n        if (this.has(key)) {\n            const name = this.getAttributeNameForKey(key);\n            this.element.removeAttribute(name);\n            return true;\n        }\n        else {\n            return false;\n        }\n    }\n    getAttributeNameForKey(key) {\n        return `data-${this.identifier}-${dasherize(key)}`;\n    }\n}\n\nclass Guide {\n    constructor(logger) {\n        this.warnedKeysByObject = new WeakMap();\n        this.logger = logger;\n    }\n    warn(object, key, message) {\n        let warnedKeys = this.warnedKeysByObject.get(object);\n        if (!warnedKeys) {\n            warnedKeys = new Set();\n            this.warnedKeysByObject.set(object, warnedKeys);\n        }\n        if (!warnedKeys.has(key)) {\n            warnedKeys.add(key);\n            this.logger.warn(message, object);\n        }\n    }\n}\n\nfunction attributeValueContainsToken(attributeName, token) {\n    return `[${attributeName}~=\"${token}\"]`;\n}\n\nclass TargetSet {\n    constructor(scope) {\n        this.scope = scope;\n    }\n    get element() {\n        return this.scope.element;\n    }\n    get identifier() {\n        return this.scope.identifier;\n    }\n    get schema() {\n        return this.scope.schema;\n    }\n    has(targetName) {\n        return this.find(targetName) != null;\n    }\n    find(...targetNames) {\n        return targetNames.reduce((target, targetName) => target || this.findTarget(targetName) || this.findLegacyTarget(targetName), undefined);\n    }\n    findAll(...targetNames) {\n        return targetNames.reduce((targets, targetName) => [\n            ...targets,\n            ...this.findAllTargets(targetName),\n            ...this.findAllLegacyTargets(targetName),\n        ], []);\n    }\n    findTarget(targetName) {\n        const selector = this.getSelectorForTargetName(targetName);\n        return this.scope.findElement(selector);\n    }\n    findAllTargets(targetName) {\n        const selector = this.getSelectorForTargetName(targetName);\n        return this.scope.findAllElements(selector);\n    }\n    getSelectorForTargetName(targetName) {\n        const attributeName = this.schema.targetAttributeForScope(this.identifier);\n        return attributeValueContainsToken(attributeName, targetName);\n    }\n    findLegacyTarget(targetName) {\n        const selector = this.getLegacySelectorForTargetName(targetName);\n        return this.deprecate(this.scope.findElement(selector), targetName);\n    }\n    findAllLegacyTargets(targetName) {\n        const selector = this.getLegacySelectorForTargetName(targetName);\n        return this.scope.findAllElements(selector).map((element) => this.deprecate(element, targetName));\n    }\n    getLegacySelectorForTargetName(targetName) {\n        const targetDescriptor = `${this.identifier}.${targetName}`;\n        return attributeValueContainsToken(this.schema.targetAttribute, targetDescriptor);\n    }\n    deprecate(element, targetName) {\n        if (element) {\n            const { identifier } = this;\n            const attributeName = this.schema.targetAttribute;\n            const revisedAttributeName = this.schema.targetAttributeForScope(identifier);\n            this.guide.warn(element, `target:${targetName}`, `Please replace ${attributeName}=\"${identifier}.${targetName}\" with ${revisedAttributeName}=\"${targetName}\". ` +\n                `The ${attributeName} attribute is deprecated and will be removed in a future version of Stimulus.`);\n        }\n        return element;\n    }\n    get guide() {\n        return this.scope.guide;\n    }\n}\n\nclass OutletSet {\n    constructor(scope, controllerElement) {\n        this.scope = scope;\n        this.controllerElement = controllerElement;\n    }\n    get element() {\n        return this.scope.element;\n    }\n    get identifier() {\n        return this.scope.identifier;\n    }\n    get schema() {\n        return this.scope.schema;\n    }\n    has(outletName) {\n        return this.find(outletName) != null;\n    }\n    find(...outletNames) {\n        return outletNames.reduce((outlet, outletName) => outlet || this.findOutlet(outletName), undefined);\n    }\n    findAll(...outletNames) {\n        return outletNames.reduce((outlets, outletName) => [...outlets, ...this.findAllOutlets(outletName)], []);\n    }\n    getSelectorForOutletName(outletName) {\n        const attributeName = this.schema.outletAttributeForScope(this.identifier, outletName);\n        return this.controllerElement.getAttribute(attributeName);\n    }\n    findOutlet(outletName) {\n        const selector = this.getSelectorForOutletName(outletName);\n        if (selector)\n            return this.findElement(selector, outletName);\n    }\n    findAllOutlets(outletName) {\n        const selector = this.getSelectorForOutletName(outletName);\n        return selector ? this.findAllElements(selector, outletName) : [];\n    }\n    findElement(selector, outletName) {\n        const elements = this.scope.queryElements(selector);\n        return elements.filter((element) => this.matchesElement(element, selector, outletName))[0];\n    }\n    findAllElements(selector, outletName) {\n        const elements = this.scope.queryElements(selector);\n        return elements.filter((element) => this.matchesElement(element, selector, outletName));\n    }\n    matchesElement(element, selector, outletName) {\n        const controllerAttribute = element.getAttribute(this.scope.schema.controllerAttribute) || \"\";\n        return element.matches(selector) && controllerAttribute.split(\" \").includes(outletName);\n    }\n}\n\nclass Scope {\n    constructor(schema, element, identifier, logger) {\n        this.targets = new TargetSet(this);\n        this.classes = new ClassMap(this);\n        this.data = new DataMap(this);\n        this.containsElement = (element) => {\n            return element.closest(this.controllerSelector) === this.element;\n        };\n        this.schema = schema;\n        this.element = element;\n        this.identifier = identifier;\n        this.guide = new Guide(logger);\n        this.outlets = new OutletSet(this.documentScope, element);\n    }\n    findElement(selector) {\n        return this.element.matches(selector) ? this.element : this.queryElements(selector).find(this.containsElement);\n    }\n    findAllElements(selector) {\n        return [\n            ...(this.element.matches(selector) ? [this.element] : []),\n            ...this.queryElements(selector).filter(this.containsElement),\n        ];\n    }\n    queryElements(selector) {\n        return Array.from(this.element.querySelectorAll(selector));\n    }\n    get controllerSelector() {\n        return attributeValueContainsToken(this.schema.controllerAttribute, this.identifier);\n    }\n    get isDocumentScope() {\n        return this.element === document.documentElement;\n    }\n    get documentScope() {\n        return this.isDocumentScope\n            ? this\n            : new Scope(this.schema, document.documentElement, this.identifier, this.guide.logger);\n    }\n}\n\nclass ScopeObserver {\n    constructor(element, schema, delegate) {\n        this.element = element;\n        this.schema = schema;\n        this.delegate = delegate;\n        this.valueListObserver = new ValueListObserver(this.element, this.controllerAttribute, this);\n        this.scopesByIdentifierByElement = new WeakMap();\n        this.scopeReferenceCounts = new WeakMap();\n    }\n    start() {\n        this.valueListObserver.start();\n    }\n    stop() {\n        this.valueListObserver.stop();\n    }\n    get controllerAttribute() {\n        return this.schema.controllerAttribute;\n    }\n    parseValueForToken(token) {\n        const { element, content: identifier } = token;\n        const scopesByIdentifier = this.fetchScopesByIdentifierForElement(element);\n        let scope = scopesByIdentifier.get(identifier);\n        if (!scope) {\n            scope = this.delegate.createScopeForElementAndIdentifier(element, identifier);\n            scopesByIdentifier.set(identifier, scope);\n        }\n        return scope;\n    }\n    elementMatchedValue(element, value) {\n        const referenceCount = (this.scopeReferenceCounts.get(value) || 0) + 1;\n        this.scopeReferenceCounts.set(value, referenceCount);\n        if (referenceCount == 1) {\n            this.delegate.scopeConnected(value);\n        }\n    }\n    elementUnmatchedValue(element, value) {\n        const referenceCount = this.scopeReferenceCounts.get(value);\n        if (referenceCount) {\n            this.scopeReferenceCounts.set(value, referenceCount - 1);\n            if (referenceCount == 1) {\n                this.delegate.scopeDisconnected(value);\n            }\n        }\n    }\n    fetchScopesByIdentifierForElement(element) {\n        let scopesByIdentifier = this.scopesByIdentifierByElement.get(element);\n        if (!scopesByIdentifier) {\n            scopesByIdentifier = new Map();\n            this.scopesByIdentifierByElement.set(element, scopesByIdentifier);\n        }\n        return scopesByIdentifier;\n    }\n}\n\nclass Router {\n    constructor(application) {\n        this.application = application;\n        this.scopeObserver = new ScopeObserver(this.element, this.schema, this);\n        this.scopesByIdentifier = new Multimap();\n        this.modulesByIdentifier = new Map();\n    }\n    get element() {\n        return this.application.element;\n    }\n    get schema() {\n        return this.application.schema;\n    }\n    get logger() {\n        return this.application.logger;\n    }\n    get controllerAttribute() {\n        return this.schema.controllerAttribute;\n    }\n    get modules() {\n        return Array.from(this.modulesByIdentifier.values());\n    }\n    get contexts() {\n        return this.modules.reduce((contexts, module) => contexts.concat(module.contexts), []);\n    }\n    start() {\n        this.scopeObserver.start();\n    }\n    stop() {\n        this.scopeObserver.stop();\n    }\n    loadDefinition(definition) {\n        this.unloadIdentifier(definition.identifier);\n        const module = new Module(this.application, definition);\n        this.connectModule(module);\n        const afterLoad = definition.controllerConstructor.afterLoad;\n        if (afterLoad) {\n            afterLoad(definition.identifier, this.application);\n        }\n    }\n    unloadIdentifier(identifier) {\n        const module = this.modulesByIdentifier.get(identifier);\n        if (module) {\n            this.disconnectModule(module);\n        }\n    }\n    getContextForElementAndIdentifier(element, identifier) {\n        const module = this.modulesByIdentifier.get(identifier);\n        if (module) {\n            return module.contexts.find((context) => context.element == element);\n        }\n    }\n    handleError(error, message, detail) {\n        this.application.handleError(error, message, detail);\n    }\n    createScopeForElementAndIdentifier(element, identifier) {\n        return new Scope(this.schema, element, identifier, this.logger);\n    }\n    scopeConnected(scope) {\n        this.scopesByIdentifier.add(scope.identifier, scope);\n        const module = this.modulesByIdentifier.get(scope.identifier);\n        if (module) {\n            module.connectContextForScope(scope);\n        }\n    }\n    scopeDisconnected(scope) {\n        this.scopesByIdentifier.delete(scope.identifier, scope);\n        const module = this.modulesByIdentifier.get(scope.identifier);\n        if (module) {\n            module.disconnectContextForScope(scope);\n        }\n    }\n    connectModule(module) {\n        this.modulesByIdentifier.set(module.identifier, module);\n        const scopes = this.scopesByIdentifier.getValuesForKey(module.identifier);\n        scopes.forEach((scope) => module.connectContextForScope(scope));\n    }\n    disconnectModule(module) {\n        this.modulesByIdentifier.delete(module.identifier);\n        const scopes = this.scopesByIdentifier.getValuesForKey(module.identifier);\n        scopes.forEach((scope) => module.disconnectContextForScope(scope));\n    }\n}\n\nconst defaultSchema = {\n    controllerAttribute: \"data-controller\",\n    actionAttribute: \"data-action\",\n    targetAttribute: \"data-target\",\n    targetAttributeForScope: (identifier) => `data-${identifier}-target`,\n    outletAttributeForScope: (identifier, outlet) => `data-${identifier}-${outlet}-outlet`,\n    keyMappings: Object.assign(Object.assign({ enter: \"Enter\", tab: \"Tab\", esc: \"Escape\", space: \" \", up: \"ArrowUp\", down: \"ArrowDown\", left: \"ArrowLeft\", right: \"ArrowRight\", home: \"Home\", end: \"End\" }, objectFromEntries(\"abcdefghijklmnopqrstuvwxyz\".split(\"\").map((c) => [c, c]))), objectFromEntries(\"0123456789\".split(\"\").map((n) => [n, n]))),\n};\nfunction objectFromEntries(array) {\n    return array.reduce((memo, [k, v]) => (Object.assign(Object.assign({}, memo), { [k]: v })), {});\n}\n\nclass Application {\n    constructor(element = document.documentElement, schema = defaultSchema) {\n        this.logger = console;\n        this.debug = false;\n        this.logDebugActivity = (identifier, functionName, detail = {}) => {\n            if (this.debug) {\n                this.logFormattedMessage(identifier, functionName, detail);\n            }\n        };\n        this.element = element;\n        this.schema = schema;\n        this.dispatcher = new Dispatcher(this);\n        this.router = new Router(this);\n        this.actionDescriptorFilters = Object.assign({}, defaultActionDescriptorFilters);\n    }\n    static start(element, schema) {\n        const application = new this(element, schema);\n        application.start();\n        return application;\n    }\n    async start() {\n        await domReady();\n        this.logDebugActivity(\"application\", \"starting\");\n        this.dispatcher.start();\n        this.router.start();\n        this.logDebugActivity(\"application\", \"start\");\n    }\n    stop() {\n        this.logDebugActivity(\"application\", \"stopping\");\n        this.dispatcher.stop();\n        this.router.stop();\n        this.logDebugActivity(\"application\", \"stop\");\n    }\n    register(identifier, controllerConstructor) {\n        this.load({ identifier, controllerConstructor });\n    }\n    registerActionOption(name, filter) {\n        this.actionDescriptorFilters[name] = filter;\n    }\n    load(head, ...rest) {\n        const definitions = Array.isArray(head) ? head : [head, ...rest];\n        definitions.forEach((definition) => {\n            if (definition.controllerConstructor.shouldLoad) {\n                this.router.loadDefinition(definition);\n            }\n        });\n    }\n    unload(head, ...rest) {\n        const identifiers = Array.isArray(head) ? head : [head, ...rest];\n        identifiers.forEach((identifier) => this.router.unloadIdentifier(identifier));\n    }\n    get controllers() {\n        return this.router.contexts.map((context) => context.controller);\n    }\n    getControllerForElementAndIdentifier(element, identifier) {\n        const context = this.router.getContextForElementAndIdentifier(element, identifier);\n        return context ? context.controller : null;\n    }\n    handleError(error, message, detail) {\n        var _a;\n        this.logger.error(`%s\\n\\n%o\\n\\n%o`, message, error, detail);\n        (_a = window.onerror) === null || _a === void 0 ? void 0 : _a.call(window, message, \"\", 0, 0, error);\n    }\n    logFormattedMessage(identifier, functionName, detail = {}) {\n        detail = Object.assign({ application: this }, detail);\n        this.logger.groupCollapsed(`${identifier} #${functionName}`);\n        this.logger.log(\"details:\", Object.assign({}, detail));\n        this.logger.groupEnd();\n    }\n}\nfunction domReady() {\n    return new Promise((resolve) => {\n        if (document.readyState == \"loading\") {\n            document.addEventListener(\"DOMContentLoaded\", () => resolve());\n        }\n        else {\n            resolve();\n        }\n    });\n}\n\nfunction ClassPropertiesBlessing(constructor) {\n    const classes = readInheritableStaticArrayValues(constructor, \"classes\");\n    return classes.reduce((properties, classDefinition) => {\n        return Object.assign(properties, propertiesForClassDefinition(classDefinition));\n    }, {});\n}\nfunction propertiesForClassDefinition(key) {\n    return {\n        [`${key}Class`]: {\n            get() {\n                const { classes } = this;\n                if (classes.has(key)) {\n                    return classes.get(key);\n                }\n                else {\n                    const attribute = classes.getAttributeName(key);\n                    throw new Error(`Missing attribute \"${attribute}\"`);\n                }\n            },\n        },\n        [`${key}Classes`]: {\n            get() {\n                return this.classes.getAll(key);\n            },\n        },\n        [`has${capitalize(key)}Class`]: {\n            get() {\n                return this.classes.has(key);\n            },\n        },\n    };\n}\n\nfunction OutletPropertiesBlessing(constructor) {\n    const outlets = readInheritableStaticArrayValues(constructor, \"outlets\");\n    return outlets.reduce((properties, outletDefinition) => {\n        return Object.assign(properties, propertiesForOutletDefinition(outletDefinition));\n    }, {});\n}\nfunction propertiesForOutletDefinition(name) {\n    const camelizedName = namespaceCamelize(name);\n    return {\n        [`${camelizedName}Outlet`]: {\n            get() {\n                const outlet = this.outlets.find(name);\n                if (outlet) {\n                    const outletController = this.application.getControllerForElementAndIdentifier(outlet, name);\n                    if (outletController) {\n                        return outletController;\n                    }\n                    else {\n                        throw new Error(`Missing \"data-controller=${name}\" attribute on outlet element for \"${this.identifier}\" controller`);\n                    }\n                }\n                throw new Error(`Missing outlet element \"${name}\" for \"${this.identifier}\" controller`);\n            },\n        },\n        [`${camelizedName}Outlets`]: {\n            get() {\n                const outlets = this.outlets.findAll(name);\n                if (outlets.length > 0) {\n                    return outlets\n                        .map((outlet) => {\n                        const controller = this.application.getControllerForElementAndIdentifier(outlet, name);\n                        if (controller) {\n                            return controller;\n                        }\n                        else {\n                            console.warn(`The provided outlet element is missing the outlet controller \"${name}\" for \"${this.identifier}\"`, outlet);\n                        }\n                    })\n                        .filter((controller) => controller);\n                }\n                return [];\n            },\n        },\n        [`${camelizedName}OutletElement`]: {\n            get() {\n                const outlet = this.outlets.find(name);\n                if (outlet) {\n                    return outlet;\n                }\n                else {\n                    throw new Error(`Missing outlet element \"${name}\" for \"${this.identifier}\" controller`);\n                }\n            },\n        },\n        [`${camelizedName}OutletElements`]: {\n            get() {\n                return this.outlets.findAll(name);\n            },\n        },\n        [`has${capitalize(camelizedName)}Outlet`]: {\n            get() {\n                return this.outlets.has(name);\n            },\n        },\n    };\n}\n\nfunction TargetPropertiesBlessing(constructor) {\n    const targets = readInheritableStaticArrayValues(constructor, \"targets\");\n    return targets.reduce((properties, targetDefinition) => {\n        return Object.assign(properties, propertiesForTargetDefinition(targetDefinition));\n    }, {});\n}\nfunction propertiesForTargetDefinition(name) {\n    return {\n        [`${name}Target`]: {\n            get() {\n                const target = this.targets.find(name);\n                if (target) {\n                    return target;\n                }\n                else {\n                    throw new Error(`Missing target element \"${name}\" for \"${this.identifier}\" controller`);\n                }\n            },\n        },\n        [`${name}Targets`]: {\n            get() {\n                return this.targets.findAll(name);\n            },\n        },\n        [`has${capitalize(name)}Target`]: {\n            get() {\n                return this.targets.has(name);\n            },\n        },\n    };\n}\n\nfunction ValuePropertiesBlessing(constructor) {\n    const valueDefinitionPairs = readInheritableStaticObjectPairs(constructor, \"values\");\n    const propertyDescriptorMap = {\n        valueDescriptorMap: {\n            get() {\n                return valueDefinitionPairs.reduce((result, valueDefinitionPair) => {\n                    const valueDescriptor = parseValueDefinitionPair(valueDefinitionPair, this.identifier);\n                    const attributeName = this.data.getAttributeNameForKey(valueDescriptor.key);\n                    return Object.assign(result, { [attributeName]: valueDescriptor });\n                }, {});\n            },\n        },\n    };\n    return valueDefinitionPairs.reduce((properties, valueDefinitionPair) => {\n        return Object.assign(properties, propertiesForValueDefinitionPair(valueDefinitionPair));\n    }, propertyDescriptorMap);\n}\nfunction propertiesForValueDefinitionPair(valueDefinitionPair, controller) {\n    const definition = parseValueDefinitionPair(valueDefinitionPair, controller);\n    const { key, name, reader: read, writer: write } = definition;\n    return {\n        [name]: {\n            get() {\n                const value = this.data.get(key);\n                if (value !== null) {\n                    return read(value);\n                }\n                else {\n                    return definition.defaultValue;\n                }\n            },\n            set(value) {\n                if (value === undefined) {\n                    this.data.delete(key);\n                }\n                else {\n                    this.data.set(key, write(value));\n                }\n            },\n        },\n        [`has${capitalize(name)}`]: {\n            get() {\n                return this.data.has(key) || definition.hasCustomDefaultValue;\n            },\n        },\n    };\n}\nfunction parseValueDefinitionPair([token, typeDefinition], controller) {\n    return valueDescriptorForTokenAndTypeDefinition({\n        controller,\n        token,\n        typeDefinition,\n    });\n}\nfunction parseValueTypeConstant(constant) {\n    switch (constant) {\n        case Array:\n            return \"array\";\n        case Boolean:\n            return \"boolean\";\n        case Number:\n            return \"number\";\n        case Object:\n            return \"object\";\n        case String:\n            return \"string\";\n    }\n}\nfunction parseValueTypeDefault(defaultValue) {\n    switch (typeof defaultValue) {\n        case \"boolean\":\n            return \"boolean\";\n        case \"number\":\n            return \"number\";\n        case \"string\":\n            return \"string\";\n    }\n    if (Array.isArray(defaultValue))\n        return \"array\";\n    if (Object.prototype.toString.call(defaultValue) === \"[object Object]\")\n        return \"object\";\n}\nfunction parseValueTypeObject(payload) {\n    const typeFromObject = parseValueTypeConstant(payload.typeObject.type);\n    if (!typeFromObject)\n        return;\n    const defaultValueType = parseValueTypeDefault(payload.typeObject.default);\n    if (typeFromObject !== defaultValueType) {\n        const propertyPath = payload.controller ? `${payload.controller}.${payload.token}` : payload.token;\n        throw new Error(`The specified default value for the Stimulus Value \"${propertyPath}\" must match the defined type \"${typeFromObject}\". The provided default value of \"${payload.typeObject.default}\" is of type \"${defaultValueType}\".`);\n    }\n    return typeFromObject;\n}\nfunction parseValueTypeDefinition(payload) {\n    const typeFromObject = parseValueTypeObject({\n        controller: payload.controller,\n        token: payload.token,\n        typeObject: payload.typeDefinition,\n    });\n    const typeFromDefaultValue = parseValueTypeDefault(payload.typeDefinition);\n    const typeFromConstant = parseValueTypeConstant(payload.typeDefinition);\n    const type = typeFromObject || typeFromDefaultValue || typeFromConstant;\n    if (type)\n        return type;\n    const propertyPath = payload.controller ? `${payload.controller}.${payload.typeDefinition}` : payload.token;\n    throw new Error(`Unknown value type \"${propertyPath}\" for \"${payload.token}\" value`);\n}\nfunction defaultValueForDefinition(typeDefinition) {\n    const constant = parseValueTypeConstant(typeDefinition);\n    if (constant)\n        return defaultValuesByType[constant];\n    const defaultValue = typeDefinition.default;\n    if (defaultValue !== undefined)\n        return defaultValue;\n    return typeDefinition;\n}\nfunction valueDescriptorForTokenAndTypeDefinition(payload) {\n    const key = `${dasherize(payload.token)}-value`;\n    const type = parseValueTypeDefinition(payload);\n    return {\n        type,\n        key,\n        name: camelize(key),\n        get defaultValue() {\n            return defaultValueForDefinition(payload.typeDefinition);\n        },\n        get hasCustomDefaultValue() {\n            return parseValueTypeDefault(payload.typeDefinition) !== undefined;\n        },\n        reader: readers[type],\n        writer: writers[type] || writers.default,\n    };\n}\nconst defaultValuesByType = {\n    get array() {\n        return [];\n    },\n    boolean: false,\n    number: 0,\n    get object() {\n        return {};\n    },\n    string: \"\",\n};\nconst readers = {\n    array(value) {\n        const array = JSON.parse(value);\n        if (!Array.isArray(array)) {\n            throw new TypeError(`expected value of type \"array\" but instead got value \"${value}\" of type \"${parseValueTypeDefault(array)}\"`);\n        }\n        return array;\n    },\n    boolean(value) {\n        return !(value == \"0\" || String(value).toLowerCase() == \"false\");\n    },\n    number(value) {\n        return Number(value);\n    },\n    object(value) {\n        const object = JSON.parse(value);\n        if (object === null || typeof object != \"object\" || Array.isArray(object)) {\n            throw new TypeError(`expected value of type \"object\" but instead got value \"${value}\" of type \"${parseValueTypeDefault(object)}\"`);\n        }\n        return object;\n    },\n    string(value) {\n        return value;\n    },\n};\nconst writers = {\n    default: writeString,\n    array: writeJSON,\n    object: writeJSON,\n};\nfunction writeJSON(value) {\n    return JSON.stringify(value);\n}\nfunction writeString(value) {\n    return `${value}`;\n}\n\nclass Controller {\n    constructor(context) {\n        this.context = context;\n    }\n    static get shouldLoad() {\n        return true;\n    }\n    static afterLoad(_identifier, _application) {\n        return;\n    }\n    get application() {\n        return this.context.application;\n    }\n    get scope() {\n        return this.context.scope;\n    }\n    get element() {\n        return this.scope.element;\n    }\n    get identifier() {\n        return this.scope.identifier;\n    }\n    get targets() {\n        return this.scope.targets;\n    }\n    get outlets() {\n        return this.scope.outlets;\n    }\n    get classes() {\n        return this.scope.classes;\n    }\n    get data() {\n        return this.scope.data;\n    }\n    initialize() {\n    }\n    connect() {\n    }\n    disconnect() {\n    }\n    dispatch(eventName, { target = this.element, detail = {}, prefix = this.identifier, bubbles = true, cancelable = true } = {}) {\n        const type = prefix ? `${prefix}:${eventName}` : eventName;\n        const event = new CustomEvent(type, { detail, bubbles, cancelable });\n        target.dispatchEvent(event);\n        return event;\n    }\n}\nController.blessings = [\n    ClassPropertiesBlessing,\n    TargetPropertiesBlessing,\n    ValuePropertiesBlessing,\n    OutletPropertiesBlessing,\n];\nController.targets = [];\nController.outlets = [];\nController.values = {};\n\nexport { Application, AttributeObserver, Context, Controller, ElementObserver, IndexedMultimap, Multimap, SelectorObserver, StringMapObserver, TokenListObserver, ValueListObserver, add, defaultSchema, del, fetch, prune };\n","/*\nStimulus Webpack Helpers 1.0.0\nCopyright © 2021 Basecamp, LLC\n */\nfunction definitionsFromContext(context) {\n    return context.keys()\n        .map((key) => definitionForModuleWithContextAndKey(context, key))\n        .filter((value) => value);\n}\nfunction definitionForModuleWithContextAndKey(context, key) {\n    const identifier = identifierForContextKey(key);\n    if (identifier) {\n        return definitionForModuleAndIdentifier(context(key), identifier);\n    }\n}\nfunction definitionForModuleAndIdentifier(module, identifier) {\n    const controllerConstructor = module.default;\n    if (typeof controllerConstructor == \"function\") {\n        return { identifier, controllerConstructor };\n    }\n}\nfunction identifierForContextKey(key) {\n    const logicalName = (key.match(/^(?:\\.\\/)?(.+)(?:[_-]controller\\..+?)$/) || [])[1];\n    if (logicalName) {\n        return logicalName.replace(/_/g, \"-\").replace(/\\//g, \"--\");\n    }\n}\n\nexport { definitionForModuleAndIdentifier, definitionForModuleWithContextAndKey, definitionsFromContext, identifierForContextKey };\n"],"names":["exports","adapters","logger","self","console","WebSocket","log","this","enabled","_adapters$logger","_len","arguments","length","messages","Array","_key","push","Date","now","apply","concat","_typeof","Symbol","iterator","obj","constructor","prototype","classCallCheck","instance","Constructor","TypeError","createClass","defineProperties","target","props","i","descriptor","enumerable","configurable","writable","Object","defineProperty","key","protoProps","staticProps","getTime","secondsSince","time","clamp","number","min","max","Math","ConnectionMonitor","connection","visibilityDidChange","bind","reconnectAttempts","start","isRunning","startedAt","stoppedAt","startPolling","addEventListener","getPollInterval","stop","stopPolling","removeEventListener","recordPing","pingedAt","recordConnect","disconnectedAt","recordDisconnect","poll","clearTimeout","pollTimeout","_this","setTimeout","reconnectIfStale","_constructor$pollInte","pollInterval","interval","multiplier","round","connectionIsStale","staleThreshold","disconnectedRecently","reopen","_this2","document","visibilityState","isOpen","INTERNAL","message_types","welcome","disconnect","ping","confirmation","rejection","disconnect_reasons","unauthorized","invalid_request","server_restart","default_mount_path","protocols","supportedProtocols","slice","indexOf","Connection","consumer","open","subscriptions","monitor","disconnected","send","data","webSocket","JSON","stringify","isActive","getState","uninstallEventHandlers","url","installEventHandlers","close","undefined","allowReconnect","error","reopenDelay","getProtocol","protocol","isState","isProtocolSupported","call","states","state","readyState","toLowerCase","eventName","events","handler","message","event","_JSON$parse","parse","identifier","reason","reconnect","type","reload","confirmSubscription","notify","reject","notifyAll","willAttemptReconnect","extend","object","properties","value","Subscription","params","mixin","perform","action","command","unsubscribe","remove","SubscriptionGuarantor","pendingSubscriptions","guarantee","subscription","startGuaranteeing","forget","filter","s","stopGuaranteeing","retrySubscribing","retryTimeout","subscribe","map","Subscriptions","guarantor","create","channelName","channel","add","ensureActiveConnection","findAll","sendCommand","callbackName","_this3","args","_len2","_key2","_this4","Consumer","_url","connect","get","createWebSocketURL","test","a","createElement","href","replace","createConsumer","getConfig","name","element","head","querySelector","getAttribute","factory","___EXPOSE_LOADER_IMPORT___","___EXPOSE_LOADER_GLOBAL_THIS___","module","globalThis","g","Function","e","window","global","w","Error","noGlobal","arr","getProto","getPrototypeOf","flat","array","class2type","toString","hasOwn","hasOwnProperty","fnToString","ObjectFunctionString","support","isFunction","nodeType","item","isWindow","preservedScriptAttributes","src","nonce","noModule","DOMEval","code","node","doc","val","script","text","setAttribute","appendChild","parentNode","removeChild","toType","version","jQuery","selector","context","fn","init","isArrayLike","jquery","toArray","num","pushStack","elems","ret","merge","prevObject","each","callback","elem","first","eq","last","even","grep","_elem","odd","len","j","end","sort","splice","options","copy","copyIsArray","clone","deep","isPlainObject","isArray","expando","random","isReady","msg","noop","proto","Ctor","isEmptyObject","globalEval","makeArray","results","inArray","second","invert","matches","callbackExpect","arg","guid","split","_i","Sizzle","Expr","getText","isXML","tokenize","compile","select","outermostContext","sortInput","hasDuplicate","setDocument","docElem","documentIsHTML","rbuggyQSA","rbuggyMatches","contains","preferredDoc","dirruns","done","classCache","createCache","tokenCache","compilerCache","nonnativeSelectorCache","sortOrder","b","pop","pushNative","list","booleans","whitespace","attributes","pseudos","rwhitespace","RegExp","rtrim","rcomma","rleadingCombinator","rdescend","rpseudo","ridentifier","matchExpr","rhtml","rinputs","rheader","rnative","rquickExpr","rsibling","runescape","funescape","escape","nonHex","high","String","fromCharCode","rcssescape","fcssescape","ch","asCodePoint","charCodeAt","unloadHandler","inDisabledFieldset","addCombinator","disabled","nodeName","dir","next","childNodes","els","seed","m","nid","match","groups","newSelector","newContext","ownerDocument","exec","getElementById","id","getElementsByTagName","getElementsByClassName","qsa","testContext","scope","toSelector","join","querySelectorAll","qsaError","removeAttribute","keys","cache","cacheLength","shift","markFunction","assert","el","addHandle","attrs","attrHandle","siblingCheck","cur","diff","sourceIndex","nextSibling","createInputPseudo","createButtonPseudo","createDisabledPseudo","isDisabled","createPositionalPseudo","argument","matchIndexes","namespace","namespaceURI","documentElement","hasCompare","subWindow","defaultView","top","attachEvent","cssHas","className","createComment","getById","getElementsByName","attrId","find","getAttributeNode","tag","tmp","input","innerHTML","matchesSelector","webkitMatchesSelector","mozMatchesSelector","oMatchesSelector","msMatchesSelector","disconnectedMatch","compareDocumentPosition","adown","bup","compare","sortDetached","aup","ap","bp","unshift","expr","elements","attr","specified","sel","uniqueSort","duplicates","detectDuplicates","sortStable","textContent","firstChild","nodeValue","selectors","createPseudo","relative","preFilter","excess","unquoted","nodeNameSelector","pattern","operator","check","result","what","_argument","simple","forward","ofType","_context","xml","uniqueCache","outerCache","nodeIndex","parent","useCache","lastChild","uniqueID","pseudo","setFilters","idx","matched","matcher","unmatched","lang","elemLang","hash","location","activeElement","hasFocus","tabIndex","checked","selected","selectedIndex","_matchIndexes","radio","checkbox","file","password","image","submit","reset","tokens","combinator","base","skip","checkNonElements","doneName","oldCache","newCache","elementMatcher","matchers","condense","newUnmatched","mapped","setMatcher","postFilter","postFinder","postSelector","temp","preMap","postMap","preexisting","contexts","multipleContexts","matcherIn","matcherOut","matcherFromTokens","checkContext","leadingRelative","implicitRelative","matchContext","matchAnyContext","filters","parseOnly","soFar","preFilters","cached","setMatchers","elementMatchers","bySet","byElement","superMatcher","outermost","matchedCount","setMatched","contextBackup","dirrunsUnique","matcherFromGroupMatchers","token","compiled","_name","defaultValue","unique","isXMLDoc","escapeSelector","until","truncate","is","siblings","n","rneedsContext","needsContext","rsingleTag","winnow","qualifier","not","rootjQuery","root","parseHTML","ready","rparentsprev","guaranteedUnique","children","contents","prev","sibling","has","targets","l","closest","index","prevAll","addBack","parents","parentsUntil","nextAll","nextUntil","prevUntil","contentDocument","content","reverse","rnothtmlwhite","Identity","v","Thrower","ex","adoptValue","resolve","noValue","method","promise","fail","then","Callbacks","_","flag","createOptions","firing","memory","fired","locked","queue","firingIndex","fire","once","stopOnFalse","empty","disable","lock","fireWith","Deferred","func","tuples","always","deferred","pipe","fns","newDefer","tuple","returned","progress","onFulfilled","onRejected","onProgress","maxDepth","depth","special","that","mightThrow","notifyWith","resolveWith","process","exceptionHook","stackTrace","rejectWith","getStackHook","stateString","when","singleValue","remaining","resolveContexts","resolveValues","primary","updateFunc","rerrorNames","stack","warn","readyException","readyList","completed","catch","readyWait","wait","doScroll","access","chainable","emptyGet","raw","bulk","rmsPrefix","rdashAlpha","fcamelCase","_all","letter","toUpperCase","camelCase","string","acceptData","owner","Data","uid","set","prop","hasData","dataPriv","dataUser","rbrace","rmultiDash","dataAttr","getData","removeData","_data","_removeData","dequeue","startLength","hooks","_queueHooks","setter","clearQueue","count","defer","pnum","source","rcssNum","cssExpand","isAttached","composed","getRootNode","isHiddenWithinTree","style","display","css","adjustCSS","valueParts","tween","adjusted","scale","maxIterations","currentValue","initial","unit","cssNumber","initialInUnit","defaultDisplayMap","getDefaultDisplay","body","showHide","show","values","hide","toggle","div","rcheckableType","rtagName","rscriptType","createDocumentFragment","checkClone","cloneNode","noCloneChecked","option","wrapMap","thead","col","tr","td","_default","getAll","setGlobalEval","refElements","tbody","tfoot","colgroup","caption","th","optgroup","buildFragment","scripts","selection","ignored","wrap","attached","fragment","nodes","htmlPrefilter","createTextNode","rtypenamespace","returnTrue","returnFalse","expectSync","err","safeActiveElement","on","types","one","origFn","off","leverageNative","notAsync","saved","isTrigger","delegateType","stopPropagation","stopImmediatePropagation","preventDefault","trigger","Event","handleObjIn","eventHandle","t","handleObj","handlers","namespaces","origType","elemData","handle","triggered","dispatch","bindType","delegateCount","setup","mappedTypes","origCount","teardown","removeEvent","nativeEvent","handlerQueue","fix","delegateTarget","preDispatch","isPropagationStopped","currentTarget","isImmediatePropagationStopped","rnamespace","postDispatch","matchedHandlers","matchedSelectors","button","addProp","hook","originalEvent","load","noBubble","click","beforeunload","returnValue","isDefaultPrevented","defaultPrevented","relatedTarget","timeStamp","isSimulated","altKey","bubbles","cancelable","changedTouches","ctrlKey","detail","eventPhase","metaKey","pageX","pageY","shiftKey","view","charCode","keyCode","buttons","clientX","clientY","offsetX","offsetY","pointerId","pointerType","screenX","screenY","targetTouches","toElement","touches","which","focus","blur","mouseenter","mouseleave","pointerenter","pointerleave","orig","related","rnoInnerhtml","rchecked","rcleanScript","manipulationTarget","disableScript","restoreScript","cloneCopyEvent","dest","udataOld","udataCur","fixInput","domManip","collection","hasScripts","iNoClone","valueIsFunction","html","_evalUrl","keepData","cleanData","dataAndEvents","deepDataAndEvents","srcElements","destElements","inPage","detach","append","prepend","insertBefore","before","after","replaceWith","replaceChild","appendTo","prependTo","insertAfter","replaceAll","original","insert","rnumnonpx","rcustomProp","getStyles","opener","getComputedStyle","swap","old","rboxStyle","rtrimCSS","curCSS","computed","width","minWidth","maxWidth","isCustomProp","getPropertyValue","pixelBoxStyles","addGetHookIf","conditionFn","hookFn","computeStyleTests","container","cssText","divStyle","pixelPositionVal","reliableMarginLeftVal","roundPixelMeasures","marginLeft","right","pixelBoxStylesVal","boxSizingReliableVal","position","scrollboxSizeVal","offsetWidth","measure","parseFloat","reliableTrDimensionsVal","backgroundClip","clearCloneStyle","boxSizingReliable","pixelPosition","reliableMarginLeft","scrollboxSize","reliableTrDimensions","table","trChild","trStyle","height","parseInt","borderTopWidth","borderBottomWidth","offsetHeight","cssPrefixes","emptyStyle","vendorProps","finalPropName","final","cssProps","capName","vendorPropName","rdisplayswap","cssShow","visibility","cssNormalTransform","letterSpacing","fontWeight","setPositiveNumber","subtract","boxModelAdjustment","dimension","box","isBorderBox","styles","computedVal","extra","delta","ceil","getWidthOrHeight","valueIsBorderBox","offsetProp","getClientRects","Tween","easing","cssHooks","opacity","origName","setProperty","isFinite","getBoundingClientRect","scrollboxSizeBuggy","left","margin","padding","border","prefix","suffix","expand","expanded","parts","propHooks","run","percent","eased","duration","pos","step","fx","scrollTop","scrollLeft","linear","p","swing","cos","PI","fxNow","inProgress","rfxtypes","rrun","schedule","hidden","requestAnimationFrame","tick","createFxNow","genFx","includeWidth","createTween","animation","Animation","tweeners","stopped","prefilters","currentTime","startTime","tweens","opts","specialEasing","originalProperties","originalOptions","gotoEnd","propFilter","complete","timer","anim","tweener","oldfire","propTween","restoreDisplay","isBox","dataShow","unqueued","overflow","overflowX","overflowY","prefilter","speed","opt","speeds","fadeTo","to","animate","optall","doAnimation","finish","stopQueue","timers","cssFn","slideDown","slideUp","slideToggle","fadeIn","fadeOut","fadeToggle","slow","fast","delay","timeout","checkOn","optSelected","radioValue","boolHook","removeAttr","nType","attrHooks","bool","attrNames","getter","lowercaseName","rfocusable","rclickable","stripAndCollapse","getClass","classesToArray","removeProp","propFix","tabindex","addClass","classNames","curValue","finalValue","removeClass","toggleClass","stateVal","isValidValue","hasClass","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","valueOrFunction","encodeURIComponent","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","responseHeaders","timeoutTimer","urlAnchor","fireGlobals","uncached","callbackContext","globalEventContext","completeDeferred","statusCode","requestHeaders","requestHeadersNames","strAbort","getResponseHeader","getAllResponseHeaders","setRequestHeader","overrideMimeType","mimeType","status","abort","statusText","finalText","crossDomain","host","hasContent","ifModified","headers","beforeSend","success","nativeStatusText","responses","isSuccess","response","modified","ct","finalDataType","firstDataType","ajaxHandleResponses","conv2","current","conv","dataFilter","throws","ajaxConvert","getJSON","getScript","wrapAll","firstElementChild","wrapInner","htmlIsFunction","unwrap","visible","xhr","XMLHttpRequest","xhrSuccessStatus","xhrSupported","cors","errorCallback","username","xhrFields","onload","onerror","onabort","ontimeout","onreadystatechange","responseType","responseText","binary","scriptAttrs","charset","scriptCharset","evt","oldCallbacks","rjsonp","jsonp","jsonpCallback","originalSettings","overwritten","responseContainer","jsonProp","createHTMLDocument","implementation","keepScripts","parsed","animated","offset","setOffset","curPosition","curLeft","curCSSTop","curTop","curOffset","curCSSLeft","curElem","using","rect","win","pageYOffset","pageXOffset","offsetParent","parentOffset","scrollTo","Height","Width","defaultExtra","funcName","unbind","delegate","undelegate","hover","fnOver","fnOut","proxy","holdReady","hold","parseJSON","isNumeric","isNaN","trim","_jQuery","_$","$","noConflict","EventListener","eventTarget","eventOptions","unorderedBindings","Set","bindingConnected","binding","bindingDisconnected","delete","handleEvent","extendedEvent","assign","immediatePropagationStopped","extendEvent","bindings","hasBindings","size","from","leftIndex","rightIndex","Dispatcher","application","eventListenerMaps","Map","started","eventListeners","forEach","eventListener","reduce","listeners","fetchEventListenerForBinding","clearEventListeners","clearEventListenersForBinding","handleError","removeMappedEventListenerFor","eventListenerMap","fetchEventListenerMapForEventTarget","cacheKey","fetchEventListener","createEventListener","defaultActionDescriptorFilters","prevent","descriptorPattern","parseEventTarget","eventTargetName","camelize","char","namespaceCamelize","capitalize","charAt","dasherize","Action","schema","tagName","defaultEventNames","getDefaultEventNameForElement","methodName","keyFilter","static","descriptorString","includes","parseActionDescriptorString","eventFilter","isFilterTarget","filteres","modifiers","meta","ctrl","alt","modifier","standardFilter","keyMappings","typecast","form","details","textarea","o_O","Binding","willBeInvokedByEvent","applyEventModifiers","invokeWithEvent","controller","actionDescriptorFilters","passes","entries","actionEvent","logDebugActivity","KeyboardEvent","Element","containsElement","ElementObserver","mutationObserverInit","childList","subtree","mutationObserver","MutationObserver","mutations","processMutations","observe","refresh","pause","takeRecords","matchElementsInTree","removeElement","addElement","mutation","processMutation","processAttributeChange","attributeName","processRemovedNodes","removedNodes","processAddedNodes","addedNodes","elementAttributeChanged","matchElement","elementFromNode","processTree","elementIsActive","tree","processor","Node","ELEMENT_NODE","isConnected","elementMatched","elementUnmatched","AttributeObserver","elementObserver","hasAttribute","elementMatchedAttribute","elementUnmatchedAttribute","elementAttributeValueChanged","fetch","del","prune","Multimap","valuesByKey","hasKey","hasValue","some","getValuesForKey","getKeysForValue","_values","SelectorObserver","matchesByElement","selectorMatchElement","selectorMatched","selectorUnmatched","_attributeName","matchedBefore","StringMapObserver","stringMap","attributeOldValue","knownAttributeNames","refreshAttribute","oldValue","getStringMapKeyForAttribute","stringMapKeyAdded","stringMapValueChanged","stringMapKeyRemoved","currentAttributeNames","recordedAttributeNames","attribute","TokenListObserver","attributeObserver","tokensByElement","tokensMatched","readTokensForElement","unmatchedTokens","matchedTokens","refreshTokensForElement","tokensUnmatched","tokenMatched","tokenUnmatched","previousTokens","currentTokens","firstDifferingIndex","zip","findIndex","previousToken","currentToken","tokenString","parseTokenString","ValueListObserver","tokenListObserver","parseResultsByToken","WeakMap","valuesByTokenByElement","fetchParseResultForToken","fetchValuesByTokenForElement","elementMatchedValue","elementUnmatchedValue","parseResult","parseToken","valuesByToken","parseValueForToken","BindingObserver","bindingsByAction","valueListObserver","actionAttribute","disconnectAllActions","connectAction","disconnectAction","clear","forToken","ValueObserver","receiver","stringMapObserver","valueDescriptorMap","invokeChangedCallbacksForDefaultValues","invokeChangedCallback","writer","valueDescriptorNameMap","valueDescriptors","rawValue","rawOldValue","changedMethodName","changedMethod","reader","descriptors","hasMethodName","TargetObserver","targetsByName","disconnectAllTargets","connectTarget","disconnectTarget","_a","targetConnected","targetDisconnected","readInheritableStaticArrayValues","propertyName","ancestors","getAncestorsForConstructor","definition","getOwnStaticArrayValues","readInheritableStaticObjectPairs","pairs","getOwnStaticObjectPairs","OutletObserver","outletsByName","outletElementsByName","selectorObserverMap","outletDefinitions","outletName","observer","dependentContexts","disconnectAllOutlets","_selector","outlet","getOutlet","connectOutlet","getOutletFromMap","disconnectOutlet","hasOutlet","controllerAttribute","outletConnected","outletDisconnected","outlets","getSelectorForOutletName","outletDependencies","dependencies","router","modules","controllerConstructor","dependentControllerIdentifiers","identifiers","getControllerForElementAndIdentifier","Context","functionName","bindingObserver","dispatcher","valueObserver","targetObserver","outletObserver","initialize","parentElement","invokeControllerMethod","bless","shadowConstructor","shadowProperties","getOwnKeys","shadowingDescriptor","getOwnPropertyDescriptor","getShadowedDescriptor","getShadowProperties","shadow","blessings","blessedProperties","blessing","getBlessedProperties","getOwnPropertySymbols","getOwnPropertyNames","extendWithReflect","extended","Reflect","construct","setPrototypeOf","testReflectExtension","Module","blessDefinition","contextsByScope","connectedContexts","connectContextForScope","fetchContextForScope","disconnectContextForScope","ClassMap","getDataKey","getAttributeName","getAttributeNameForKey","DataMap","Guide","warnedKeysByObject","warnedKeys","attributeValueContainsToken","TargetSet","targetName","targetNames","findTarget","findLegacyTarget","findAllTargets","findAllLegacyTargets","getSelectorForTargetName","findElement","findAllElements","targetAttributeForScope","getLegacySelectorForTargetName","deprecate","targetDescriptor","targetAttribute","revisedAttributeName","guide","OutletSet","controllerElement","outletNames","findOutlet","findAllOutlets","outletAttributeForScope","queryElements","matchesElement","Scope","classes","controllerSelector","documentScope","isDocumentScope","ScopeObserver","scopesByIdentifierByElement","scopeReferenceCounts","scopesByIdentifier","fetchScopesByIdentifierForElement","createScopeForElementAndIdentifier","referenceCount","scopeConnected","scopeDisconnected","Router","scopeObserver","modulesByIdentifier","loadDefinition","unloadIdentifier","connectModule","afterLoad","disconnectModule","getContextForElementAndIdentifier","defaultSchema","enter","tab","esc","space","up","down","home","objectFromEntries","c","memo","k","Application","debug","logFormattedMessage","Promise","register","registerActionOption","rest","shouldLoad","unload","controllers","groupCollapsed","groupEnd","parseValueDefinitionPair","typeDefinition","payload","typeFromObject","parseValueTypeConstant","typeObject","defaultValueType","parseValueTypeDefault","default","propertyPath","parseValueTypeObject","typeFromDefaultValue","typeFromConstant","parseValueTypeDefinition","constant","defaultValuesByType","defaultValueForDefinition","hasCustomDefaultValue","readers","writers","valueDescriptorForTokenAndTypeDefinition","Boolean","Number","boolean","writeJSON","Controller","_identifier","_application","CustomEvent","dispatchEvent","classDefinition","targetDefinition","valueDefinitionPairs","propertyDescriptorMap","valueDefinitionPair","valueDescriptor","read","write","propertiesForValueDefinitionPair","outletDefinition","camelizedName","outletController","propertiesForOutletDefinition","definitionsFromContext","logicalName","identifierForContextKey","definitionForModuleAndIdentifier","definitionForModuleWithContextAndKey"],"sourceRoot":""}