From a77d1acd90129cfb8bf5a1d491b50eb4e91a03c9 Mon Sep 17 00:00:00 2001 From: Elias Rodrigues Date: Sat, 6 Jan 2024 16:57:20 -0300 Subject: [PATCH] Start bundling compiled assets in the Gem Taking inspiration from how Avo handles their gem assets, this bundles a compiled version of our assets inside the gem. We're using `jsbundling-rails` with `esbuild`, along with `cssbundling-rails` with `saas` to build Administrate's asset files, which is the closest of the newer approaches for handling assets in Rails as to what we'd been doing previously. We then remove `jquery-rails`, `sassc-rails` and `selectize-rails` gems which are replaced with the equivalents from `npm`. When releasing, we'll need to run `yarn run build` and `yarn run build:css` to compile the assets before building the gem which will now ship the contents of `app/assets/builds` with it. For someone using Administrate, they'll no longer need to compile the assets shipped by it as these will now be ready-to-use `.js` and `.css` files and any asset bundling approaches we choose (or need to, because they've changed upstream in Rails) should no longer have an impact on users of the gem. This is part of: #2311 https://avohq.io/blog/how-to-bundle-assets-in-a-rails-engine Co-authored-by: Elias Rodrigues Co-authored-by: Pablo Brasero --- .github/workflows/main.yml | 10 +- .gitignore | 12 + .sample.env | 1 + Gemfile | 4 + Gemfile.lock | 25 +- Procfile.dev | 3 + administrate.gemspec | 4 - app/assets/builds/.keep | 0 .../builds/administrate-internal/docs.css | 89 + .../builds/administrate-internal/docs.css.map | 1 + .../builds/administrate/application.css | 1960 ++++ .../builds/administrate/application.css.map | 1 + app/assets/builds/administrate/application.js | 8110 +++++++++++++++++ .../builds/administrate/application.js.map | 7 + app/assets/config/administrate_manifest.js | 2 + app/assets/images/administrate/.keep | 0 .../javascripts/administrate/add_jquery.js | 4 + .../javascripts/administrate/application.js | 12 +- .../{ => administrate-internal}/docs.scss | 0 .../stylesheets/administrate/application.scss | 3 +- bin/build-gem | 9 + bin/dev | 10 + bin/dev-assets | 3 + bin/release | 7 +- gemfiles/pundit21.gemfile | 3 + gemfiles/rails60.gemfile | 3 + gemfiles/rails61.gemfile | 3 + gemfiles/rails70.gemfile | 3 + lib/administrate/engine.rb | 4 - package.json | 9 + spec/example_app/app/assets/builds/.keep | 0 .../example_app/app/assets/config/manifest.js | 6 +- .../app/assets/javascripts/application.js | 15 - .../app/assets/stylesheets/application.css | 15 - .../example_app/app/javascript/application.js | 1 + .../views/application/_javascript.html.erb | 2 - .../app/views/layouts/application.html.erb | 3 +- .../app/views/layouts/docs.html.erb | 2 +- spec/example_app/config/application.rb | 1 - yarn.lock | 310 +- 40 files changed, 10579 insertions(+), 78 deletions(-) create mode 100644 Procfile.dev create mode 100644 app/assets/builds/.keep create mode 100644 app/assets/builds/administrate-internal/docs.css create mode 100644 app/assets/builds/administrate-internal/docs.css.map create mode 100644 app/assets/builds/administrate/application.css create mode 100644 app/assets/builds/administrate/application.css.map create mode 100644 app/assets/builds/administrate/application.js create mode 100644 app/assets/builds/administrate/application.js.map create mode 100644 app/assets/config/administrate_manifest.js create mode 100644 app/assets/images/administrate/.keep create mode 100644 app/assets/javascripts/administrate/add_jquery.js rename app/assets/stylesheets/{ => administrate-internal}/docs.scss (100%) create mode 100755 bin/build-gem create mode 100755 bin/dev create mode 100755 bin/dev-assets create mode 100644 spec/example_app/app/assets/builds/.keep delete mode 100644 spec/example_app/app/assets/javascripts/application.js delete mode 100644 spec/example_app/app/assets/stylesheets/application.css create mode 100644 spec/example_app/app/javascript/application.js diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index c9cf2e7fa5..fdf8104b5d 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -39,15 +39,23 @@ jobs: with: ruby-version: ${{ matrix.ruby }} bundler-cache: true - - name: Install dependencies + - name: Set up JS + uses: actions/setup-node@v4 + with: + cache: yarn + - name: Install Ruby dependencies run: bundle install - name: Install Appraisal dependencies run: bundle exec appraisal install + - name: Install JS dependencies + run: yarn install - name: Setup the environment run: cp .sample.env .env - run: cp spec/example_app/config/database.yml.sample spec/example_app/config/database.yml - name: Setup the database run: bundle exec rake db:setup + - name: Build assets + run: yarn run build && yarn run build:css - name: Run tests run: bundle exec rspec - name: Appraise Rails 6.0 diff --git a/.gitignore b/.gitignore index 0abba42a0c..1b3907ff1c 100644 --- a/.gitignore +++ b/.gitignore @@ -7,17 +7,28 @@ /.foreman /coverage/* /db/*.sqlite3 + /log/* /tmp/* !/log/.keep !/tmp/.keep + /spec/example_app/log/* /spec/example_app/tmp/* !/spec/example_app/log/.keep !/spec/example_app/tmp/.keep /spec/example_app/public/system /spec/example_app/public/assets + +/spec/example_app/app/assets/builds/* +!/spec/example_app/app/assets/builds/.keep + +/spec/example_app/node_modules /spec/example_app/config/database.yml + +/node_modules +/public + /tags pkg *.ipr @@ -28,3 +39,4 @@ pkg gemfiles/.bundle/ .yardoc /doc +*.gem diff --git a/.sample.env b/.sample.env index 27983d12a9..18464116cf 100644 --- a/.sample.env +++ b/.sample.env @@ -1,3 +1,4 @@ # http://ddollar.github.com/foreman/ RACK_ENV=development SECRET_KEY_BASE=development_secret +PORT=3000 diff --git a/Gemfile b/Gemfile index d39b51116a..9d8bb9da5b 100644 --- a/Gemfile +++ b/Gemfile @@ -15,6 +15,10 @@ gem "sentry-rails" gem "sentry-ruby" gem "unicorn" +gem "cssbundling-rails", "~> 1.2" +gem "jsbundling-rails", "~> 1.1" +gem "sprockets-rails", "~> 3.4" + group :development, :test do gem "appraisal" gem "awesome_print" diff --git a/Gemfile.lock b/Gemfile.lock index dc094c5586..cf23472760 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -5,10 +5,7 @@ PATH actionpack (>= 6.0, < 8.0) actionview (>= 6.0, < 8.0) activerecord (>= 6.0, < 8.0) - jquery-rails (~> 4.6.0) kaminari (~> 1.2.2) - sassc-rails (~> 2.1) - selectize-rails (~> 0.6) GEM remote: https://rubygems.org/ @@ -116,6 +113,8 @@ GEM crack (0.4.5) rexml crass (1.0.6) + cssbundling-rails (1.4.0) + railties (>= 6.0.0) database_cleaner (2.0.2) database_cleaner-active_record (>= 2, < 3) database_cleaner-active_record (2.1.0) @@ -137,7 +136,6 @@ GEM railties (>= 5.0.0) faker (3.2.3) i18n (>= 1.8.11, < 2) - ffi (1.15.5) formulaic (0.4.1) activesupport capybara @@ -160,10 +158,8 @@ GEM rails-i18n rainbow (>= 2.2.2, < 4.0) terminal-table (>= 1.5.1) - jquery-rails (4.6.0) - rails-dom-testing (>= 1, < 3) - railties (>= 4.2.0) - thor (>= 0.14, < 2.0) + jsbundling-rails (1.3.0) + railties (>= 6.0.0) kaminari (1.2.2) activesupport (>= 4.1.0) kaminari-actionview (= 1.2.2) @@ -279,15 +275,6 @@ GEM rspec-support (~> 3.12) rspec-support (3.12.1) rubyzip (2.3.2) - sassc (2.4.0) - ffi (~> 1.9) - sassc-rails (2.1.2) - railties (>= 4.0.0) - sassc (>= 2.0) - sprockets (> 3.0) - sprockets-rails - tilt - selectize-rails (0.12.6) selenium-webdriver (4.17.0) base64 (~> 0.2) rexml (~> 3.2, >= 3.2.5) @@ -311,7 +298,6 @@ GEM terminal-table (3.0.2) unicode-display_width (>= 1.1.1, < 3) thor (1.3.0) - tilt (2.2.0) timecop (0.9.8) timeout (0.4.0) tzinfo (2.0.6) @@ -347,6 +333,7 @@ DEPENDENCIES awesome_print byebug capybara + cssbundling-rails (~> 1.2) database_cleaner dotenv-rails factory_bot_rails @@ -355,6 +342,7 @@ DEPENDENCIES front_matter_parser globalid i18n-tasks (= 1.0.13) + jsbundling-rails (~> 1.1) kaminari-i18n launchy pg @@ -366,6 +354,7 @@ DEPENDENCIES sentry-rails sentry-ruby shoulda-matchers + sprockets-rails (~> 3.4) timecop uglifier unicorn diff --git a/Procfile.dev b/Procfile.dev new file mode 100644 index 0000000000..0733f99e0c --- /dev/null +++ b/Procfile.dev @@ -0,0 +1,3 @@ +web: bundle exec unicorn -p $PORT -c ./config/unicorn.rb +js: yarn build --watch +css: yarn build:css --watch diff --git a/administrate.gemspec b/administrate.gemspec index 2086b778a7..4b77c546d6 100644 --- a/administrate.gemspec +++ b/administrate.gemspec @@ -16,11 +16,7 @@ Gem::Specification.new do |s| s.add_dependency "actionpack", ">= 6.0", "< 8.0" s.add_dependency "actionview", ">= 6.0", "< 8.0" s.add_dependency "activerecord", ">= 6.0", "< 8.0" - - s.add_dependency "jquery-rails", "~> 4.6.0" s.add_dependency "kaminari", "~> 1.2.2" - s.add_dependency "sassc-rails", "~> 2.1" - s.add_dependency "selectize-rails", "~> 0.6" s.description = <<-DESCRIPTION Administrate is heavily inspired by projects like Rails Admin and ActiveAdmin, diff --git a/app/assets/builds/.keep b/app/assets/builds/.keep new file mode 100644 index 0000000000..e69de29bb2 diff --git a/app/assets/builds/administrate-internal/docs.css b/app/assets/builds/administrate-internal/docs.css new file mode 100644 index 0000000000..dcac4782d7 --- /dev/null +++ b/app/assets/builds/administrate-internal/docs.css @@ -0,0 +1,89 @@ +html, +body { + font-family: "Lato", serif; + font-size: 18px; + line-height: 1.62em; + margin: 0; +} + +img { + max-width: 100%; +} + +h1, +h2, +h3 { + font-family: "Fjalla One", sans-serif; + margin-top: 2em; +} + +a { + color: #53adc6; + text-decoration: none; +} + +.content { + margin-bottom: 2em; + margin-left: auto; + margin-right: auto; + margin-top: 2em; + width: 60em; +} +.content .sidebar { + float: left; + width: 20em; +} +.content .sidebar-links { + list-style: none; + padding-left: 0; +} +.content .main { + float: right; + width: 40em; +} + +.flash-wrapper { + background-color: #cf726e; + color: #f0f0f0; + padding: 1em; +} +.flash-wrapper .flash { + margin-left: auto; + margin-right: auto; + width: 40em; +} + +code { + font-family: "Source Code Pro"; + font-size: 0.8rem; + padding: 0.4em 0.2em 0; +} +code.hljs { + background-color: #202020; + color: #e0e0dc; + padding-left: 1rem; +} +code.hljs .hljs-string { + color: #b0bf82; +} +code.hljs .hljs-subst { + color: #e0e0dc; +} +code.hljs .hljs-constant { + color: #8fbdcc; +} +code.hljs .hljs-symbol { + color: #b95c56; +} +code.hljs .hljs-keyword { + color: #f8d29d; +} +code.hljs .hljs-title, +code.hljs .hljs-parent { + color: #8fbdcc; +} +code.hljs .hljs-tag { + color: #f8d29d; +} + +/*# sourceMappingURL=docs.css.map */ diff --git a/app/assets/builds/administrate-internal/docs.css.map b/app/assets/builds/administrate-internal/docs.css.map new file mode 100644 index 0000000000..9f3fc8ebe5 --- /dev/null +++ b/app/assets/builds/administrate-internal/docs.css.map @@ -0,0 +1 @@ +{"version":3,"sourceRoot":"","sources":["../../stylesheets/administrate-internal/docs.scss"],"names":[],"mappings":"AAYA;AAAA;EAEE;EACA;EACA;EACA;;;AAGF;EACE;;;AAGF;AAAA;AAAA;EAGE;EACA;;;AAGF;EACE,OAhCK;EAiCL;;;AAGF;EACE;EACA;EACA;EACA;EACA;;AAEA;EACE;EACA;;AAEA;EACE;EACA;;AAIJ;EACE;EACA;;;AAIJ;EACE,kBA3DI;EA4DJ,OA1DM;EA2DN;;AAEA;EACE;EACA;EACA;;;AAIJ;EACE;EACA;EACA;;AAEA;EACE,kBAxES;EAyET,OAxES;EAyET;;AAEA;EAAe,OA1EN;;AA2ET;EAAc,OA5EL;;AA6ET;EAAiB,OA3ET;;AA4ER;EAAe,OA1ER;;AA2EP;EAAgB,OA5EN;;AA8EV;AAAA;EACe,OAhFP;;AAkFR;EAAY,OAjFF","file":"docs.css"} \ No newline at end of file diff --git a/app/assets/builds/administrate/application.css b/app/assets/builds/administrate/application.css new file mode 100644 index 0000000000..ab2899bc7a --- /dev/null +++ b/app/assets/builds/administrate/application.css @@ -0,0 +1,1960 @@ +@charset "UTF-8"; +/*! normalize.css v7.0.0 | MIT License | github.com/necolas/normalize.css */ +/* Document + ========================================================================== */ +/** + * 1. Correct the line height in all browsers. + * 2. Prevent adjustments of font size after orientation changes in + * IE on Windows Phone and in iOS. + */ +html { + line-height: 1.15; /* 1 */ + -ms-text-size-adjust: 100%; /* 2 */ + -webkit-text-size-adjust: 100%; /* 2 */ +} + +/* Sections + ========================================================================== */ +/** + * Remove the margin in all browsers (opinionated). + */ +body { + margin: 0; +} + +/** + * Add the correct display in IE 9-. + */ +article, +aside, +footer, +header, +nav, +section { + display: block; +} + +/** + * Correct the font size and margin on `h1` elements within `section` and + * `article` contexts in Chrome, Firefox, and Safari. + */ +h1 { + font-size: 2em; + margin: 0.67em 0; +} + +/* Grouping content + ========================================================================== */ +/** + * Add the correct display in IE 9-. + * 1. Add the correct display in IE. + */ +figcaption, +figure, +main { /* 1 */ + display: block; +} + +/** + * Add the correct margin in IE 8. + */ +figure { + margin: 1em 40px; +} + +/** + * 1. Add the correct box sizing in Firefox. + * 2. Show the overflow in Edge and IE. + */ +hr { + box-sizing: content-box; /* 1 */ + height: 0; /* 1 */ + overflow: visible; /* 2 */ +} + +/** + * 1. Correct the inheritance and scaling of font size in all browsers. + * 2. Correct the odd `em` font sizing in all browsers. + */ +pre { + font-family: monospace, monospace; /* 1 */ + font-size: 1em; /* 2 */ +} + +/* Text-level semantics + ========================================================================== */ +/** + * 1. Remove the gray background on active links in IE 10. + * 2. Remove gaps in links underline in iOS 8+ and Safari 8+. + */ +a { + background-color: transparent; /* 1 */ + -webkit-text-decoration-skip: objects; /* 2 */ +} + +/** + * 1. Remove the bottom border in Chrome 57- and Firefox 39-. + * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari. + */ +abbr[title] { + border-bottom: none; /* 1 */ + text-decoration: underline; /* 2 */ + text-decoration: underline dotted; /* 2 */ +} + +/** + * Prevent the duplicate application of `bolder` by the next rule in Safari 6. + */ +b, +strong { + font-weight: inherit; +} + +/** + * Add the correct font weight in Chrome, Edge, and Safari. + */ +b, +strong { + font-weight: bolder; +} + +/** + * 1. Correct the inheritance and scaling of font size in all browsers. + * 2. Correct the odd `em` font sizing in all browsers. + */ +code, +kbd, +samp { + font-family: monospace, monospace; /* 1 */ + font-size: 1em; /* 2 */ +} + +/** + * Add the correct font style in Android 4.3-. + */ +dfn { + font-style: italic; +} + +/** + * Add the correct background and color in IE 9-. + */ +mark { + background-color: #ff0; + color: #000; +} + +/** + * Add the correct font size in all browsers. + */ +small { + font-size: 80%; +} + +/** + * Prevent `sub` and `sup` elements from affecting the line height in + * all browsers. + */ +sub, +sup { + font-size: 75%; + line-height: 0; + position: relative; + vertical-align: baseline; +} + +sub { + bottom: -0.25em; +} + +sup { + top: -0.5em; +} + +/* Embedded content + ========================================================================== */ +/** + * Add the correct display in IE 9-. + */ +audio, +video { + display: inline-block; +} + +/** + * Add the correct display in iOS 4-7. + */ +audio:not([controls]) { + display: none; + height: 0; +} + +/** + * Remove the border on images inside links in IE 10-. + */ +img { + border-style: none; +} + +/** + * Hide the overflow in IE. + */ +svg:not(:root) { + overflow: hidden; +} + +/* Forms + ========================================================================== */ +/** + * 1. Change the font styles in all browsers (opinionated). + * 2. Remove the margin in Firefox and Safari. + */ +button, +input, +optgroup, +select, +textarea { + font-family: sans-serif; /* 1 */ + font-size: 100%; /* 1 */ + line-height: 1.15; /* 1 */ + margin: 0; /* 2 */ +} + +/** + * Show the overflow in IE. + * 1. Show the overflow in Edge. + */ +button, +input { /* 1 */ + overflow: visible; +} + +/** + * Remove the inheritance of text transform in Edge, Firefox, and IE. + * 1. Remove the inheritance of text transform in Firefox. + */ +button, +select { /* 1 */ + text-transform: none; +} + +/** + * 1. Prevent a WebKit bug where (2) destroys native `audio` and `video` + * controls in Android 4. + * 2. Correct the inability to style clickable types in iOS and Safari. + */ +button, +html [type=button], +[type=reset], +[type=submit] { + -webkit-appearance: button; /* 2 */ +} + +/** + * Remove the inner border and padding in Firefox. + */ +button::-moz-focus-inner, +[type=button]::-moz-focus-inner, +[type=reset]::-moz-focus-inner, +[type=submit]::-moz-focus-inner { + border-style: none; + padding: 0; +} + +/** + * Restore the focus styles unset by the previous rule. + */ +button:-moz-focusring, +[type=button]:-moz-focusring, +[type=reset]:-moz-focusring, +[type=submit]:-moz-focusring { + outline: 1px dotted ButtonText; +} + +/** + * Correct the padding in Firefox. + */ +fieldset { + padding: 0.35em 0.75em 0.625em; +} + +/** + * 1. Correct the text wrapping in Edge and IE. + * 2. Correct the color inheritance from `fieldset` elements in IE. + * 3. Remove the padding so developers are not caught out when they zero out + * `fieldset` elements in all browsers. + */ +legend { + box-sizing: border-box; /* 1 */ + color: inherit; /* 2 */ + display: table; /* 1 */ + max-width: 100%; /* 1 */ + padding: 0; /* 3 */ + white-space: normal; /* 1 */ +} + +/** + * 1. Add the correct display in IE 9-. + * 2. Add the correct vertical alignment in Chrome, Firefox, and Opera. + */ +progress { + display: inline-block; /* 1 */ + vertical-align: baseline; /* 2 */ +} + +/** + * Remove the default vertical scrollbar in IE. + */ +textarea { + overflow: auto; +} + +/** + * 1. Add the correct box sizing in IE 10-. + * 2. Remove the padding in IE 10-. + */ +[type=checkbox], +[type=radio] { + box-sizing: border-box; /* 1 */ + padding: 0; /* 2 */ +} + +/** + * Correct the cursor style of increment and decrement buttons in Chrome. + */ +[type=number]::-webkit-inner-spin-button, +[type=number]::-webkit-outer-spin-button { + height: auto; +} + +/** + * 1. Correct the odd appearance in Chrome and Safari. + * 2. Correct the outline style in Safari. + */ +[type=search] { + -webkit-appearance: textfield; /* 1 */ + outline-offset: -2px; /* 2 */ +} + +/** + * Remove the inner padding and cancel buttons in Chrome and Safari on macOS. + */ +[type=search]::-webkit-search-cancel-button, +[type=search]::-webkit-search-decoration { + -webkit-appearance: none; +} + +/** + * 1. Correct the inability to style clickable types in iOS and Safari. + * 2. Change font properties to `inherit` in Safari. + */ +::-webkit-file-upload-button { + -webkit-appearance: button; /* 1 */ + font: inherit; /* 2 */ +} + +/* Interactive + ========================================================================== */ +/* + * Add the correct display in IE 9-. + * 1. Add the correct display in Edge, IE, and Firefox. + */ +details, +menu { + display: block; +} + +/* + * Add the correct display in all browsers. + */ +summary { + display: list-item; +} + +/* Scripting + ========================================================================== */ +/** + * Add the correct display in IE 9-. + */ +canvas { + display: inline-block; +} + +/** + * Add the correct display in IE. + */ +template { + display: none; +} + +/* Hidden + ========================================================================== */ +/** + * Add the correct display in IE 10-. + */ +[hidden] { + display: none; +} + +/** + * selectize.css (v0.12.6) + * Copyright (c) 2013–2015 Brian Reavis & contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this + * file except in compliance with the License. You may obtain a copy of the License at: + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under + * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF + * ANY KIND, either express or implied. See the License for the specific language + * governing permissions and limitations under the License. + * + * @author Brian Reavis + */ +.selectize-control.plugin-drag_drop.multi > .selectize-input > div.ui-sortable-placeholder { + visibility: visible !important; + background: #f2f2f2 !important; + background: rgba(0, 0, 0, 0.06) !important; + border: 0 none !important; + -webkit-box-shadow: inset 0 0 12px 4px #fff; + box-shadow: inset 0 0 12px 4px #fff; +} + +.selectize-control.plugin-drag_drop .ui-sortable-placeholder::after { + content: "!"; + visibility: hidden; +} + +.selectize-control.plugin-drag_drop .ui-sortable-helper { + -webkit-box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2); + box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2); +} + +.selectize-dropdown-header { + position: relative; + padding: 5px 8px; + border-bottom: 1px solid #d0d0d0; + background: #f8f8f8; + -webkit-border-radius: 3px 3px 0 0; + -moz-border-radius: 3px 3px 0 0; + border-radius: 3px 3px 0 0; +} + +.selectize-dropdown-header-close { + position: absolute; + right: 8px; + top: 50%; + color: #303030; + opacity: 0.4; + margin-top: -12px; + line-height: 20px; + font-size: 20px !important; +} + +.selectize-dropdown-header-close:hover { + color: #000000; +} + +.selectize-dropdown.plugin-optgroup_columns .optgroup { + border-right: 1px solid #f2f2f2; + border-top: 0 none; + float: left; + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; +} + +.selectize-dropdown.plugin-optgroup_columns .optgroup:last-child { + border-right: 0 none; +} + +.selectize-dropdown.plugin-optgroup_columns .optgroup:before { + display: none; +} + +.selectize-dropdown.plugin-optgroup_columns .optgroup-header { + border-top: 0 none; +} + +.selectize-control.plugin-remove_button [data-value] { + position: relative; + padding-right: 24px !important; +} + +.selectize-control.plugin-remove_button [data-value] .remove { + z-index: 1; + /* fixes ie bug (see #392) */ + position: absolute; + top: 0; + right: 0; + bottom: 0; + width: 17px; + text-align: center; + font-weight: bold; + font-size: 12px; + color: inherit; + text-decoration: none; + vertical-align: middle; + display: inline-block; + padding: 2px 0 0 0; + border-left: 1px solid #d0d0d0; + -webkit-border-radius: 0 2px 2px 0; + -moz-border-radius: 0 2px 2px 0; + border-radius: 0 2px 2px 0; + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; +} + +.selectize-control.plugin-remove_button [data-value] .remove:hover { + background: rgba(0, 0, 0, 0.05); +} + +.selectize-control.plugin-remove_button [data-value].active .remove { + border-left-color: #cacaca; +} + +.selectize-control.plugin-remove_button .disabled [data-value] .remove:hover { + background: none; +} + +.selectize-control.plugin-remove_button .disabled [data-value] .remove { + border-left-color: #ffffff; +} + +.selectize-control.plugin-remove_button .remove-single { + position: absolute; + right: 0; + top: 0; + font-size: 23px; +} + +.selectize-control { + position: relative; +} + +.selectize-dropdown, +.selectize-input, +.selectize-input input { + color: #303030; + font-family: inherit; + font-size: 13px; + line-height: 18px; + -webkit-font-smoothing: inherit; +} + +.selectize-input, +.selectize-control.single .selectize-input.input-active { + background: #fff; + cursor: text; + display: inline-block; +} + +.selectize-input { + border: 1px solid #d0d0d0; + padding: 8px 8px; + display: inline-block; + width: 100%; + overflow: hidden; + position: relative; + z-index: 1; + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.1); + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.1); + -webkit-border-radius: 3px; + -moz-border-radius: 3px; + border-radius: 3px; +} + +.selectize-control.multi .selectize-input.has-items { + padding: 6px 8px 3px; +} + +.selectize-input.full { + background-color: #fff; +} + +.selectize-input.disabled, +.selectize-input.disabled * { + cursor: default !important; +} + +.selectize-input.focus { + -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.15); + box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.15); +} + +.selectize-input.dropdown-active { + -webkit-border-radius: 3px 3px 0 0; + -moz-border-radius: 3px 3px 0 0; + border-radius: 3px 3px 0 0; +} + +.selectize-input > * { + vertical-align: baseline; + display: -moz-inline-stack; + display: inline-block; + zoom: 1; + *display: inline; +} + +.selectize-control.multi .selectize-input > div { + cursor: pointer; + margin: 0 3px 3px 0; + padding: 2px 6px; + background: #f2f2f2; + color: #303030; + border: 0 solid #d0d0d0; +} + +.selectize-control.multi .selectize-input > div.active { + background: #e8e8e8; + color: #303030; + border: 0 solid #cacaca; +} + +.selectize-control.multi .selectize-input.disabled > div, +.selectize-control.multi .selectize-input.disabled > div.active { + color: #7d7d7d; + background: #ffffff; + border: 0 solid #ffffff; +} + +.selectize-input > input { + display: inline-block !important; + padding: 0 !important; + min-height: 0 !important; + max-height: none !important; + max-width: 100% !important; + margin: 0 2px 0 0 !important; + text-indent: 0 !important; + border: 0 none !important; + background: none !important; + line-height: inherit !important; + -webkit-user-select: auto !important; + -webkit-box-shadow: none !important; + box-shadow: none !important; +} + +.selectize-input > input::-ms-clear { + display: none; +} + +.selectize-input > input:focus { + outline: none !important; +} + +.selectize-input::after { + content: " "; + display: block; + clear: left; +} + +.selectize-input.dropdown-active::before { + content: " "; + display: block; + position: absolute; + background: #f0f0f0; + height: 1px; + bottom: 0; + left: 0; + right: 0; +} + +.selectize-dropdown { + position: absolute; + z-index: 10; + border: 1px solid #d0d0d0; + background: #fff; + margin: -1px 0 0 0; + border-top: 0 none; + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; + -webkit-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1); + box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1); + -webkit-border-radius: 0 0 3px 3px; + -moz-border-radius: 0 0 3px 3px; + border-radius: 0 0 3px 3px; +} + +.selectize-dropdown [data-selectable] { + cursor: pointer; + overflow: hidden; +} + +.selectize-dropdown [data-selectable] .highlight { + background: rgba(125, 168, 208, 0.2); + -webkit-border-radius: 1px; + -moz-border-radius: 1px; + border-radius: 1px; +} + +.selectize-dropdown .option, +.selectize-dropdown .optgroup-header { + padding: 5px 8px; +} + +.selectize-dropdown .option, +.selectize-dropdown [data-disabled], +.selectize-dropdown [data-disabled] [data-selectable].option { + cursor: inherit; + opacity: 0.5; +} + +.selectize-dropdown [data-selectable].option { + opacity: 1; +} + +.selectize-dropdown .optgroup:first-child .optgroup-header { + border-top: 0 none; +} + +.selectize-dropdown .optgroup-header { + color: #303030; + background: #fff; + cursor: default; +} + +.selectize-dropdown .active { + background-color: #f5fafd; + color: #495c68; +} + +.selectize-dropdown .active.create { + color: #495c68; +} + +.selectize-dropdown .create { + color: rgba(48, 48, 48, 0.5); +} + +.selectize-dropdown-content { + overflow-y: auto; + overflow-x: hidden; + max-height: 200px; + -webkit-overflow-scrolling: touch; +} + +.selectize-control.single .selectize-input, +.selectize-control.single .selectize-input input { + cursor: pointer; +} + +.selectize-control.single .selectize-input.input-active, +.selectize-control.single .selectize-input.input-active input { + cursor: text; +} + +.selectize-control.single .selectize-input:after { + content: " "; + display: block; + position: absolute; + top: 50%; + right: 15px; + margin-top: -3px; + width: 0; + height: 0; + border-style: solid; + border-width: 5px 5px 0 5px; + border-color: #808080 transparent transparent transparent; +} + +.selectize-control.single .selectize-input.dropdown-active:after { + margin-top: -4px; + border-width: 0 5px 5px 5px; + border-color: transparent transparent #808080 transparent; +} + +.selectize-control.rtl.single .selectize-input:after { + left: 15px; + right: auto; +} + +.selectize-control.rtl .selectize-input > input { + margin: 0 4px 0 -2px !important; +} + +.selectize-control .selectize-input.disabled { + opacity: 0.5; + background-color: #fafafa; +} + +/** + * selectize.default.css (v0.12.6) - Default Theme + * Copyright (c) 2013–2015 Brian Reavis & contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this + * file except in compliance with the License. You may obtain a copy of the License at: + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under + * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF + * ANY KIND, either express or implied. See the License for the specific language + * governing permissions and limitations under the License. + * + * @author Brian Reavis + */ +.selectize-control.plugin-drag_drop.multi > .selectize-input > div.ui-sortable-placeholder { + visibility: visible !important; + background: #f2f2f2 !important; + background: rgba(0, 0, 0, 0.06) !important; + border: 0 none !important; + -webkit-box-shadow: inset 0 0 12px 4px #fff; + box-shadow: inset 0 0 12px 4px #fff; +} + +.selectize-control.plugin-drag_drop .ui-sortable-placeholder::after { + content: "!"; + visibility: hidden; +} + +.selectize-control.plugin-drag_drop .ui-sortable-helper { + -webkit-box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2); + box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2); +} + +.selectize-dropdown-header { + position: relative; + padding: 5px 8px; + border-bottom: 1px solid #d0d0d0; + background: #f8f8f8; + -webkit-border-radius: 3px 3px 0 0; + -moz-border-radius: 3px 3px 0 0; + border-radius: 3px 3px 0 0; +} + +.selectize-dropdown-header-close { + position: absolute; + right: 8px; + top: 50%; + color: #303030; + opacity: 0.4; + margin-top: -12px; + line-height: 20px; + font-size: 20px !important; +} + +.selectize-dropdown-header-close:hover { + color: #000000; +} + +.selectize-dropdown.plugin-optgroup_columns .optgroup { + border-right: 1px solid #f2f2f2; + border-top: 0 none; + float: left; + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; +} + +.selectize-dropdown.plugin-optgroup_columns .optgroup:last-child { + border-right: 0 none; +} + +.selectize-dropdown.plugin-optgroup_columns .optgroup:before { + display: none; +} + +.selectize-dropdown.plugin-optgroup_columns .optgroup-header { + border-top: 0 none; +} + +.selectize-control.plugin-remove_button [data-value] { + position: relative; + padding-right: 24px !important; +} + +.selectize-control.plugin-remove_button [data-value] .remove { + z-index: 1; + /* fixes ie bug (see #392) */ + position: absolute; + top: 0; + right: 0; + bottom: 0; + width: 17px; + text-align: center; + font-weight: bold; + font-size: 12px; + color: inherit; + text-decoration: none; + vertical-align: middle; + display: inline-block; + padding: 2px 0 0 0; + border-left: 1px solid #0073bb; + -webkit-border-radius: 0 2px 2px 0; + -moz-border-radius: 0 2px 2px 0; + border-radius: 0 2px 2px 0; + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; +} + +.selectize-control.plugin-remove_button [data-value] .remove:hover { + background: rgba(0, 0, 0, 0.05); +} + +.selectize-control.plugin-remove_button [data-value].active .remove { + border-left-color: #00578d; +} + +.selectize-control.plugin-remove_button .disabled [data-value] .remove:hover { + background: none; +} + +.selectize-control.plugin-remove_button .disabled [data-value] .remove { + border-left-color: #aaaaaa; +} + +.selectize-control.plugin-remove_button .remove-single { + position: absolute; + right: 0; + top: 0; + font-size: 23px; +} + +.selectize-control { + position: relative; +} + +.selectize-dropdown, +.selectize-input, +.selectize-input input { + color: #303030; + font-family: inherit; + font-size: 13px; + line-height: 18px; + -webkit-font-smoothing: inherit; +} + +.selectize-input, +.selectize-control.single .selectize-input.input-active { + background: #fff; + cursor: text; + display: inline-block; +} + +.selectize-input { + border: 1px solid #d0d0d0; + padding: 8px 8px; + display: inline-block; + width: 100%; + overflow: hidden; + position: relative; + z-index: 1; + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.1); + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.1); + -webkit-border-radius: 3px; + -moz-border-radius: 3px; + border-radius: 3px; +} + +.selectize-control.multi .selectize-input.has-items { + padding: 5px 8px 2px; +} + +.selectize-input.full { + background-color: #fff; +} + +.selectize-input.disabled, +.selectize-input.disabled * { + cursor: default !important; +} + +.selectize-input.focus { + -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.15); + box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.15); +} + +.selectize-input.dropdown-active { + -webkit-border-radius: 3px 3px 0 0; + -moz-border-radius: 3px 3px 0 0; + border-radius: 3px 3px 0 0; +} + +.selectize-input > * { + vertical-align: baseline; + display: -moz-inline-stack; + display: inline-block; + zoom: 1; + *display: inline; +} + +.selectize-control.multi .selectize-input > div { + cursor: pointer; + margin: 0 3px 3px 0; + padding: 2px 6px; + background: #1da7ee; + color: #fff; + border: 1px solid #0073bb; +} + +.selectize-control.multi .selectize-input > div.active { + background: #92c836; + color: #fff; + border: 1px solid #00578d; +} + +.selectize-control.multi .selectize-input.disabled > div, +.selectize-control.multi .selectize-input.disabled > div.active { + color: #ffffff; + background: #d2d2d2; + border: 1px solid #aaaaaa; +} + +.selectize-input > input { + display: inline-block !important; + padding: 0 !important; + min-height: 0 !important; + max-height: none !important; + max-width: 100% !important; + margin: 0 1px !important; + text-indent: 0 !important; + border: 0 none !important; + background: none !important; + line-height: inherit !important; + -webkit-user-select: auto !important; + -webkit-box-shadow: none !important; + box-shadow: none !important; +} + +.selectize-input > input::-ms-clear { + display: none; +} + +.selectize-input > input:focus { + outline: none !important; +} + +.selectize-input::after { + content: " "; + display: block; + clear: left; +} + +.selectize-input.dropdown-active::before { + content: " "; + display: block; + position: absolute; + background: #f0f0f0; + height: 1px; + bottom: 0; + left: 0; + right: 0; +} + +.selectize-dropdown { + position: absolute; + z-index: 10; + border: 1px solid #d0d0d0; + background: #fff; + margin: -1px 0 0 0; + border-top: 0 none; + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; + -webkit-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1); + box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1); + -webkit-border-radius: 0 0 3px 3px; + -moz-border-radius: 0 0 3px 3px; + border-radius: 0 0 3px 3px; +} + +.selectize-dropdown [data-selectable] { + cursor: pointer; + overflow: hidden; +} + +.selectize-dropdown [data-selectable] .highlight { + background: rgba(125, 168, 208, 0.2); + -webkit-border-radius: 1px; + -moz-border-radius: 1px; + border-radius: 1px; +} + +.selectize-dropdown .option, +.selectize-dropdown .optgroup-header { + padding: 5px 8px; +} + +.selectize-dropdown .option, +.selectize-dropdown [data-disabled], +.selectize-dropdown [data-disabled] [data-selectable].option { + cursor: inherit; + opacity: 0.5; +} + +.selectize-dropdown [data-selectable].option { + opacity: 1; +} + +.selectize-dropdown .optgroup:first-child .optgroup-header { + border-top: 0 none; +} + +.selectize-dropdown .optgroup-header { + color: #303030; + background: #fff; + cursor: default; +} + +.selectize-dropdown .active { + background-color: #f5fafd; + color: #495c68; +} + +.selectize-dropdown .active.create { + color: #495c68; +} + +.selectize-dropdown .create { + color: rgba(48, 48, 48, 0.5); +} + +.selectize-dropdown-content { + overflow-y: auto; + overflow-x: hidden; + max-height: 200px; + -webkit-overflow-scrolling: touch; +} + +.selectize-control.single .selectize-input, +.selectize-control.single .selectize-input input { + cursor: pointer; +} + +.selectize-control.single .selectize-input.input-active, +.selectize-control.single .selectize-input.input-active input { + cursor: text; +} + +.selectize-control.single .selectize-input:after { + content: " "; + display: block; + position: absolute; + top: 50%; + right: 15px; + margin-top: -3px; + width: 0; + height: 0; + border-style: solid; + border-width: 5px 5px 0 5px; + border-color: #808080 transparent transparent transparent; +} + +.selectize-control.single .selectize-input.dropdown-active:after { + margin-top: -4px; + border-width: 0 5px 5px 5px; + border-color: transparent transparent #808080 transparent; +} + +.selectize-control.rtl.single .selectize-input:after { + left: 15px; + right: auto; +} + +.selectize-control.rtl .selectize-input > input { + margin: 0 4px 0 -2px !important; +} + +.selectize-control .selectize-input.disabled { + opacity: 0.5; + background-color: #fafafa; +} + +.selectize-control.multi .selectize-input.has-items { + padding-left: 5px; + padding-right: 5px; +} + +.selectize-control.multi .selectize-input.disabled [data-value] { + color: #999; + text-shadow: none; + background: none; + -webkit-box-shadow: none; + box-shadow: none; +} + +.selectize-control.multi .selectize-input.disabled [data-value], +.selectize-control.multi .selectize-input.disabled [data-value] .remove { + border-color: #e6e6e6; +} + +.selectize-control.multi .selectize-input.disabled [data-value] .remove { + background: none; +} + +.selectize-control.multi .selectize-input [data-value] { + text-shadow: 0 1px 0 rgba(0, 51, 83, 0.3); + -webkit-border-radius: 3px; + -moz-border-radius: 3px; + border-radius: 3px; + background-color: #1b9dec; + background-image: -moz-linear-gradient(top, #1da7ee, #178ee9); + background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#1da7ee), to(#178ee9)); + background-image: -webkit-linear-gradient(top, #1da7ee, #178ee9); + background-image: -o-linear-gradient(top, #1da7ee, #178ee9); + background-image: linear-gradient(to bottom, #1da7ee, #178ee9); + background-repeat: repeat-x; + filter: progid:DXImageTransform.Microsoft.gradient(startColorstr="#ff1da7ee", endColorstr="#ff178ee9", GradientType=0); + -webkit-box-shadow: 0 1px 0 rgba(0, 0, 0, 0.2), inset 0 1px rgba(255, 255, 255, 0.03); + box-shadow: 0 1px 0 rgba(0, 0, 0, 0.2), inset 0 1px rgba(255, 255, 255, 0.03); +} + +.selectize-control.multi .selectize-input [data-value].active { + background-color: #0085d4; + background-image: -moz-linear-gradient(top, #008fd8, #0075cf); + background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#008fd8), to(#0075cf)); + background-image: -webkit-linear-gradient(top, #008fd8, #0075cf); + background-image: -o-linear-gradient(top, #008fd8, #0075cf); + background-image: linear-gradient(to bottom, #008fd8, #0075cf); + background-repeat: repeat-x; + filter: progid:DXImageTransform.Microsoft.gradient(startColorstr="#ff008fd8", endColorstr="#ff0075cf", GradientType=0); +} + +.selectize-control.single .selectize-input { + -webkit-box-shadow: 0 1px 0 rgba(0, 0, 0, 0.05), inset 0 1px 0 rgba(255, 255, 255, 0.8); + box-shadow: 0 1px 0 rgba(0, 0, 0, 0.05), inset 0 1px 0 rgba(255, 255, 255, 0.8); + background-color: #f9f9f9; + background-image: -moz-linear-gradient(top, #fefefe, #f2f2f2); + background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#fefefe), to(#f2f2f2)); + background-image: -webkit-linear-gradient(top, #fefefe, #f2f2f2); + background-image: -o-linear-gradient(top, #fefefe, #f2f2f2); + background-image: linear-gradient(to bottom, #fefefe, #f2f2f2); + background-repeat: repeat-x; + filter: progid:DXImageTransform.Microsoft.gradient(startColorstr="#fffefefe", endColorstr="#fff2f2f2", GradientType=0); +} + +.selectize-control.single .selectize-input, +.selectize-dropdown.single { + border-color: #b8b8b8; +} + +.selectize-dropdown .optgroup-header { + padding-top: 7px; + font-weight: bold; + font-size: 0.85em; +} + +.selectize-dropdown .optgroup { + border-top: 1px solid #f0f0f0; +} + +.selectize-dropdown .optgroup:first-child { + border-top: 0 none; +} + +/* stylelint-disable scss/dollar-variable-empty-line-before */ +/* stylelint-enable scss/dollar-variable-empty-line-before */ +fieldset { + background-color: transparent; + border: 0; + margin: 0; + padding: 0; +} + +legend { + font-weight: 700; + margin: 0; + padding: 0; +} + +label { + display: block; + font-weight: 700; + margin: 0; +} + +input, +select { + display: block; + font-family: -apple-system, blinkmacsystemfont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif; + font-size: 1em; +} + +input, +select, +textarea { + display: block; + font-family: -apple-system, blinkmacsystemfont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif; + font-size: 16px; +} + +textarea { + resize: vertical; +} + +[type=color], +[type=date], +[type=datetime-local], +[type=email], +[type=month], +[type=number], +[type=password], +[type=search], +[type=tel], +[type=text], +[type=time], +[type=url], +[type=week], +input:not([type]), +textarea { + appearance: none; + background-color: #ffffff; + border: 1px solid #dfe0e1; + border-radius: 4px; + padding: 0.5em; + transition: border-color 250ms ease-in-out; + width: 100%; +} +[type=color]:hover, +[type=date]:hover, +[type=datetime-local]:hover, +[type=email]:hover, +[type=month]:hover, +[type=number]:hover, +[type=password]:hover, +[type=search]:hover, +[type=tel]:hover, +[type=text]:hover, +[type=time]:hover, +[type=url]:hover, +[type=week]:hover, +input:not([type]):hover, +textarea:hover { + border-color: #b2b3b4; +} +[type=color]:focus, +[type=date]:focus, +[type=datetime-local]:focus, +[type=email]:focus, +[type=month]:focus, +[type=number]:focus, +[type=password]:focus, +[type=search]:focus, +[type=tel]:focus, +[type=text]:focus, +[type=time]:focus, +[type=url]:focus, +[type=week]:focus, +input:not([type]):focus, +textarea:focus { + border-color: #1976d2; + outline: none; +} +[type=color]:disabled, +[type=date]:disabled, +[type=datetime-local]:disabled, +[type=email]:disabled, +[type=month]:disabled, +[type=number]:disabled, +[type=password]:disabled, +[type=search]:disabled, +[type=tel]:disabled, +[type=text]:disabled, +[type=time]:disabled, +[type=url]:disabled, +[type=week]:disabled, +input:not([type]):disabled, +textarea:disabled { + background-color: #f2f2f2; + cursor: not-allowed; +} +[type=color]:disabled:hover, +[type=date]:disabled:hover, +[type=datetime-local]:disabled:hover, +[type=email]:disabled:hover, +[type=month]:disabled:hover, +[type=number]:disabled:hover, +[type=password]:disabled:hover, +[type=search]:disabled:hover, +[type=tel]:disabled:hover, +[type=text]:disabled:hover, +[type=time]:disabled:hover, +[type=url]:disabled:hover, +[type=week]:disabled:hover, +input:not([type]):disabled:hover, +textarea:disabled:hover { + border: 1px solid #dfe0e1; +} +[type=color]::placeholder, +[type=date]::placeholder, +[type=datetime-local]::placeholder, +[type=email]::placeholder, +[type=month]::placeholder, +[type=number]::placeholder, +[type=password]::placeholder, +[type=search]::placeholder, +[type=tel]::placeholder, +[type=text]::placeholder, +[type=time]::placeholder, +[type=url]::placeholder, +[type=week]::placeholder, +input:not([type])::placeholder, +textarea::placeholder { + font-style: italic; +} + +[type=checkbox], +[type=radio] { + display: inline; + margin-right: 0.375em; +} + +[type=file] { + width: 100%; +} + +select { + width: 100%; +} + +[type=checkbox]:focus, +[type=radio]:focus, +[type=file]:focus, +select:focus { + outline: 3px solid rgba(25, 118, 210, 0.6); + outline-offset: 1px; +} + +html { + background-color: #f6f7f7; + box-sizing: border-box; +} + +*, +*::before, +*::after { + box-sizing: inherit; +} + +figure { + margin: 0; +} + +img, +picture { + margin: 0; + max-width: 100%; +} + +ul, +ol { + list-style-type: none; + margin: 0; + padding: 0; +} + +dl { + margin-bottom: 0.75em; +} +dl dt { + font-weight: 700; + margin-top: 0.75em; +} +dl dd { + margin: 0; +} + +table { + border-collapse: collapse; + font-size: 0.9em; + text-align: left; + width: 100%; +} +table a { + color: inherit; + text-decoration: none; +} + +thead { + font-weight: 700; +} + +tr { + border-bottom: 1px solid #dfe0e1; +} + +tbody tr:hover { + background-color: #f6f7f7; +} +tbody tr [role=link] { + cursor: pointer; +} +tbody tr:focus { + outline: 3px solid rgba(25, 118, 210, 0.6); + outline-offset: -3px; +} + +td, +th { + font-feature-settings: "kern", "liga", "clig", "calt", "lnum", "tnum"; + font-kerning: normal; + font-variant-ligatures: common-ligatures, contextual; + font-variant-numeric: lining-nums, tabular-nums; + padding: 0.75rem; + vertical-align: middle; +} + +td:first-child, +th:first-child { + padding-left: 2rem; +} + +td:last-child, +th:last-child { + padding-right: 2rem; +} + +td img { + max-height: 2rem; +} + +body { + color: #293f54; + font-family: -apple-system, blinkmacsystemfont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif; + font-size: 1em; + line-height: 1.5; +} + +h1, +h2, +h3, +h4, +h5, +h6 { + font-family: -apple-system, blinkmacsystemfont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif; + font-size: 1em; + line-height: 1.2; + margin: 0; +} + +p { + margin: 0 0 0.75em; +} + +a { + color: #1976d2; + text-decoration-skip-ink: auto; + transition: color 250ms ease-in-out; +} +a:hover { + color: #13599e; +} +a:focus { + outline: 3px solid rgba(25, 118, 210, 0.6); + outline-offset: 1px; +} + +hr { + border-bottom: 1px solid #dfe0e1; + border-left: 0; + border-right: 0; + border-top: 0; + margin: 1.5em 0; +} + +.app-container { + align-items: stretch; + display: flex; + margin-left: auto; + margin-right: auto; + max-width: 100rem; + min-height: 100vh; + padding: 1.5em; +} + +.attribute-label { + color: #7b808c; + font-size: 0.8em; + font-weight: 400; + letter-spacing: 0.0357em; + position: relative; + text-transform: uppercase; + clear: left; + float: left; + margin-bottom: 1.5em; + margin-top: 0.25em; + text-align: right; + width: calc(20% - 1rem); +} + +.preserve-whitespace { + white-space: pre-wrap; + word-wrap: break-word; +} + +.attribute-data { + float: left; + margin-bottom: 1.5em; + margin-left: 2rem; + width: calc(80% - 1rem); + word-break: break-word; +} + +.attribute--nested { + border: 1px solid #dfe0e1; + padding: 0.75em; +} + +button, +input, +.button { + appearance: none; + background-color: #1976d2; + border: 0; + border-radius: 4px; + color: #ffffff; + cursor: pointer; + display: inline-block; + font-family: -apple-system, blinkmacsystemfont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif; + font-size: 1em; + -webkit-font-smoothing: antialiased; + font-weight: 700; + line-height: 1; + padding: 0.75em 1.5em; + text-decoration: none; + transition: background-color 250ms ease-in-out; + user-select: none; + vertical-align: middle; + white-space: nowrap; +} +button:hover, +input:hover, +.button:hover { + background-color: #145ea8; + color: #ffffff; +} +button:focus, +input:focus, +.button:focus { + outline: 3px solid rgba(25, 118, 210, 0.6); + outline-offset: 1px; +} +button:disabled, +input:disabled, +.button:disabled { + cursor: not-allowed; + opacity: 0.5; +} +button:disabled:hover, +input:disabled:hover, +.button:disabled:hover { + background-color: #1976d2; +} + +.button--alt { + background-color: transparent; + border: 1px solid #dfe0e1; + border-color: #1976d2; + color: #1976d2; +} + +.button--danger { + background-color: #d32f2f; +} +.button--danger:hover { + background-color: #a92626; + color: #ffffff; +} + +.button--nav { + margin-bottom: 1.5em; +} + +.cell-label__sort-indicator { + float: right; + margin-left: 5px; +} +.cell-label__sort-indicator svg { + fill: #7b808c; + height: 13px; + transition: transform 250ms ease-in-out; + width: 13px; +} + +.cell-label { + padding-top: 0.15em; +} +.cell-label a { + color: inherit; + display: inline-block; + transition: color 250ms ease-in-out; + width: 100%; +} +.cell-label:hover a { + color: #1976d2; +} +.cell-label:hover svg { + fill: #1976d2; + transform: rotate(180deg); +} + +.cell-label--asc, +.cell-label--desc { + font-weight: 700; +} + +.cell-label__sort-indicator--desc { + transform: rotate(180deg); +} + +.cell-data--number, +.cell-label--number { + text-align: right; +} + +.field-unit { + align-items: center; + display: flex; + flex-wrap: wrap; + margin-bottom: 1.5em; + position: relative; + width: 100%; +} +.field-unit::after { + clear: both; + content: ""; + display: block; +} + +.field-unit__label { + float: left; + margin-left: 1rem; + text-align: right; + width: calc(15% - 1rem); +} + +.field-unit__field { + float: left; + margin-left: 2rem; + max-width: 50rem; + width: 100%; +} +.field-unit__field .optgroup-header { + font-weight: 700; +} + +.field-unit__hint { + font-size: 90%; + margin-left: calc(15% + 2rem); + width: 100%; +} + +.field-unit--nested { + border: 1px solid #dfe0e1; + margin-left: 7.5%; + max-width: 60rem; + padding: 0.75em; + width: 100%; +} +.field-unit--nested .field-unit__field { + width: 100%; +} +.field-unit--nested .field-unit__label { + width: 10rem; +} + +.field-unit--required label::after { + color: #d32f2f; + content: " *"; +} + +.flash-alert { + background-color: #fff6bf; + color: #66624c; + display: block; + margin-bottom: 0.75em; + padding: 0.75em; + text-align: center; +} +.flash-alert a { + color: #4d4a39; + text-decoration: underline; +} +.flash-alert a:focus, .flash-alert a:hover { + color: #1a1913; +} + +.flash-error { + background-color: #fbe3e4; + color: #645b5b; + display: block; + margin-bottom: 0.75em; + padding: 0.75em; + text-align: center; +} +.flash-error a { + color: #4b4444; + text-decoration: underline; +} +.flash-error a:focus, .flash-error a:hover { + color: #191717; +} + +.flash-notice { + background-color: #e5edf8; + color: #5c5f63; + display: block; + margin-bottom: 0.75em; + padding: 0.75em; + text-align: center; +} +.flash-notice a { + color: #45474a; + text-decoration: underline; +} +.flash-notice a:focus, .flash-notice a:hover { + color: #171819; +} + +.flash-success { + background-color: #e6efc2; + color: #5c604e; + display: block; + margin-bottom: 0.75em; + padding: 0.75em; + text-align: center; +} +.flash-success a { + color: #45483a; + text-decoration: underline; +} +.flash-success a:focus, .flash-success a:hover { + color: #171813; +} + +.form-actions { + margin-left: calc(15% + 2rem); +} + +.main-content { + background-color: #ffffff; + border-radius: 4px; + box-shadow: 0 0 6px 0 rgba(0, 0, 0, 0.12), 0 2px 2px rgba(0, 0, 0, 0.2); + flex: 1 1 100%; + min-width: 800px; + padding-bottom: 10vh; +} + +.main-content__header, +.main-content__body { + padding: 1rem 2rem; +} + +.main-content__body--flush { + padding-left: 0; + padding-right: 0; +} + +.main-content__header { + align-items: center; + border-bottom: 1px solid #dfe0e1; + display: flex; +} + +.main-content__page-title { + font-size: 1.6em; + margin-right: auto; +} + +.navigation { + flex: 1 0 10rem; + padding: 1.5em; + padding-left: 0; +} + +.navigation__link { + background-color: transparent; + color: #293f54; + display: block; + line-height: 1; + margin-left: -0.6em; + padding: 0.6em; + transition: background-color 250ms ease-in-out, color 250ms ease-in-out; +} +.navigation__link:not(:last-of-type) { + margin-bottom: 0.75em; +} +.navigation__link:hover { + background-color: #eaebeb; + border-radius: 4px; + color: #293f54; +} + +.navigation__link--active { + font-weight: 700; +} + +.pagination { + margin-top: 1.5em; + padding-left: 1.5em; + padding-right: 1.5em; + text-align: center; +} +.pagination .first, +.pagination .prev, +.pagination .page, +.pagination .next, +.pagination .last { + margin: 0.75em; +} +.pagination .current { + font-weight: 700; +} + +.search { + margin-left: auto; + margin-right: 2rem; + max-width: 20rem; + position: relative; + width: 100%; +} + +.search__input { + border-radius: 100rem; + padding-left: 2.5rem; + padding-right: 2.5rem; +} + +.search__eyeglass-icon { + fill: #293f54; + height: 1rem; + left: 1rem; + position: absolute; + top: 50%; + transform: translateY(-50%); + width: 1rem; +} + +.search__clear-link { + height: 1rem; + position: absolute; + right: 0.75rem; + top: 50%; + transform: translateY(-50%); + width: 1rem; +} + +.search__clear-icon { + fill: #adb5bd; + height: 1rem; + position: absolute; + transition: fill 250ms ease-in-out; + width: 1rem; +} +.search__clear-icon:hover { + fill: #1976d2; +} + +.text-color-red { + color: #d32f2f; +} + +/*# sourceMappingURL=application.css.map */ diff --git a/app/assets/builds/administrate/application.css.map b/app/assets/builds/administrate/application.css.map new file mode 100644 index 0000000000..a951e0b49c --- /dev/null +++ b/app/assets/builds/administrate/application.css.map @@ -0,0 +1 @@ +{"version":3,"sourceRoot":"","sources":["../../stylesheets/administrate/reset/_normalize.scss","../../../../node_modules/selectize/dist/css/selectize.css","../../../../node_modules/selectize/dist/css/selectize.default.css","../../stylesheets/administrate/library/_variables.scss","../../stylesheets/administrate/base/_forms.scss","../../stylesheets/administrate/base/_layout.scss","../../stylesheets/administrate/base/_lists.scss","../../stylesheets/administrate/base/_tables.scss","../../stylesheets/administrate/base/_typography.scss","../../stylesheets/administrate/components/_app-container.scss","../../stylesheets/administrate/components/_attributes.scss","../../stylesheets/administrate/library/_data-label.scss","../../stylesheets/administrate/components/_buttons.scss","../../stylesheets/administrate/components/_cells.scss","../../stylesheets/administrate/components/_field-unit.scss","../../stylesheets/administrate/library/_clearfix.scss","../../stylesheets/administrate/components/_flashes.scss","../../stylesheets/administrate/components/_form-actions.scss","../../stylesheets/administrate/components/_main-content.scss","../../stylesheets/administrate/components/_navigation.scss","../../stylesheets/administrate/components/_pagination.scss","../../stylesheets/administrate/components/_search.scss","../../stylesheets/administrate/utilities/_text-color.scss"],"names":[],"mappings":";AAAA;AAEA;AAAA;AAGA;AAAA;AAAA;AAAA;AAAA;AAMA;EACE;EACA;EACA;;;AAGF;AAAA;AAGA;AAAA;AAAA;AAIA;EACE;;;AAGF;AAAA;AAAA;AAIA;AAAA;AAAA;AAAA;AAAA;AAAA;EAME;;;AAGF;AAAA;AAAA;AAAA;AAKA;EACE;EACA;;;AAGF;AAAA;AAGA;AAAA;AAAA;AAAA;AAKA;AAAA;AAAA,OAEO;EACL;;;AAGF;AAAA;AAAA;AAIA;EACE;;;AAGF;AAAA;AAAA;AAAA;AAKA;EACE;EACA;EACA;;;AAGF;AAAA;AAAA;AAAA;AAKA;EACE;EACA;;;AAGF;AAAA;AAGA;AAAA;AAAA;AAAA;AAKA;EACE;EACA;;;AAGF;AAAA;AAAA;AAAA;AAKA;EACE;EACA;EACA;;;AAGF;AAAA;AAAA;AAIA;AAAA;EAEE;;;AAGF;AAAA;AAAA;AAIA;AAAA;EAEE;;;AAGF;AAAA;AAAA;AAAA;AAKA;AAAA;AAAA;EAGE;EACA;;;AAGF;AAAA;AAAA;AAIA;EACE;;;AAGF;AAAA;AAAA;AAIA;EACE;EACA;;;AAGF;AAAA;AAAA;AAIA;EACE;;;AAGF;AAAA;AAAA;AAAA;AAKA;AAAA;EAEE;EACA;EACA;EACA;;;AAGF;EACE;;;AAGF;EACE;;;AAGF;AAAA;AAGA;AAAA;AAAA;AAIA;AAAA;EAEE;;;AAGF;AAAA;AAAA;AAIA;EACE;EACA;;;AAGF;AAAA;AAAA;AAIA;EACE;;;AAGF;AAAA;AAAA;AAIA;EACE;;;AAGF;AAAA;AAGA;AAAA;AAAA;AAAA;AAKA;AAAA;AAAA;AAAA;AAAA;EAKE;EACA;EACA;EACA;;;AAGF;AAAA;AAAA;AAAA;AAKA;AAAA,QACQ;EACN;;;AAGF;AAAA;AAAA;AAAA;AAKA;AAAA,SACS;EACP;;;AAGF;AAAA;AAAA;AAAA;AAAA;AAMA;AAAA;AAAA;AAAA;EAIE;;;AAGF;AAAA;AAAA;AAIA;AAAA;AAAA;AAAA;EAIE;EACA;;;AAGF;AAAA;AAAA;AAIA;AAAA;AAAA;AAAA;EAIE;;;AAGF;AAAA;AAAA;AAIA;EACE;;;AAGF;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA;EACE;EACA;EACA;EACA;EACA;EACA;;;AAGF;AAAA;AAAA;AAAA;AAKA;EACE;EACA;;;AAGF;AAAA;AAAA;AAIA;EACE;;;AAGF;AAAA;AAAA;AAAA;AAKA;AAAA;EAEE;EACA;;;AAGF;AAAA;AAAA;AAIA;AAAA;EAEE;;;AAGF;AAAA;AAAA;AAAA;AAKA;EACE;EACA;;;AAGF;AAAA;AAAA;AAIA;AAAA;EAEE;;;AAGF;AAAA;AAAA;AAAA;AAKA;EACE;EACA;;;AAGF;AAAA;AAGA;AAAA;AAAA;AAAA;AAKA;AAAA;EAEE;;;AAGF;AAAA;AAAA;AAIA;EACE;;;AAGF;AAAA;AAGA;AAAA;AAAA;AAIA;EACE;;;AAGF;AAAA;AAAA;AAIA;EACE;;;AAGF;AAAA;AAGA;AAAA;AAAA;AAIA;EACE;;;AC7bF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA;EACE;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;;;AAEF;EACE;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;EACA;;;AAEF;EACE;AACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;EACA;EACA;EACA;;;AAEF;EACE;;;AAEF;AAAA;AAAA;EAGE;EACA;EACA;EACA;EACA;;;AAEF;AAAA;EAEE;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;AAAA;EAEE;;;AAEF;EACE;EACA;;;AAEF;EACE;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;;;AAEF;AAAA;EAEE;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;;;AAEF;EACE;EACA;EACA;EACA;;;AAEF;AAAA;EAEE;;;AAEF;AAAA;AAAA;EAGE;EACA;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;EACA;EACA;;;AAEF;EACE;EACA;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;EACA;EACA;EACA;;;AAEF;AAAA;EAEE;;;AAEF;AAAA;EAEE;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;;;AAEF;EACE;EACA;;;AAEF;EACE;;;AAEF;EACE;EACA;;;AC3UF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAeA;EACE;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;;;AAEF;EACE;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;EACA;;;AAEF;EACE;AACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;EACA;EACA;EACA;;;AAEF;EACE;;;AAEF;AAAA;AAAA;EAGE;EACA;EACA;EACA;EACA;;;AAEF;AAAA;EAEE;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;AAAA;EAEE;;;AAEF;EACE;EACA;;;AAEF;EACE;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;;;AAEF;AAAA;EAEE;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;;;AAEF;EACE;EACA;EACA;EACA;;;AAEF;AAAA;EAEE;;;AAEF;AAAA;AAAA;EAGE;EACA;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;EACA;EACA;;;AAEF;EACE;EACA;;;AAEF;EACE;;;AAEF;EACE;;;AAEF;EACE;EACA;EACA;EACA;;;AAEF;AAAA;EAEE;;;AAEF;AAAA;EAEE;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;;;AAEF;EACE;EACA;;;AAEF;EACE;;;AAEF;EACE;EACA;;;AAEF;EACE;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;;;AAEF;AAAA;EAEE;;;AAEF;EACE;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAEF;AAAA;EAEE;;;AAEF;EACE;EACA;EACA;;;AAEF;EACE;;;AAEF;EACE;;;ACjZF;AAoEA;ACpEA;EACE;EACA;EACA;EACA;;;AAGF;EACE,aDEiB;ECDjB;EACA;;;AAGF;EACE;EACA,aDLiB;ECMjB;;;AAGF;AAAA;EAEE;EACA,aDnBiB;ECoBjB,WDfe;;;ACkBjB;AAAA;AAAA;EAGE;EACA,aD3BiB;EC4BjB;;;AAGF;EACE;;;AAGF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAeE;EACA,kBDjCM;ECkCN,QDOY;ECNZ,eDxCmB;ECyCnB;EACA;EACA;;AAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EACE;;AAGF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EACE,cD1CG;EC2CH;;AAGF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EACE;EACA;;AAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EACE,QDbQ;;ACiBZ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EACE;;;AAIJ;AAAA;EAEE;EACA;;;AAGF;EACE;;;AAGF;EACE;;;AAOA;AAAA;AAAA;AAAA;EACE,SDtDY;ECuDZ,gBDtDmB;;;AElDvB;EACE,kBF8BO;EE7BP;;;AAGF;AAAA;AAAA;EAGE;;;AAGF;EACE;;;AAGF;AAAA;EAEE;EACA;;;AClBF;AAAA;EAEE;EACA;EACA;;;AAGF;EACE,eHUc;;AGRd;EACE,aHDe;EGEf,YHMY;;AGHd;EACE;;;AChBJ;EACE;EACA;EACA;EACA;;AAEA;EACE;EACA;;;AAIJ;EACE,aJHiB;;;AIMnB;EACE,eJ6CY;;;AIzCZ;EACE,kBJSK;;AINP;EACE;;AAGF;EACE,SJmBY;EIlBZ;;;AAIJ;AAAA;EAEE;EACA;EACA;EACA;EACA;EACA;;;AAGF;AAAA;EAEE;;;AAGF;AAAA;EAEE;;;AAGF;EACE;;;ACxDF;EACE,OLkCO;EKjCP,aLCiB;EKAjB,WLKe;EKJf,aLQiB;;;AKLnB;AAAA;AAAA;AAAA;AAAA;AAAA;EAME,aLViB;EKWjB,WLNe;EKOf,aLFoB;EKGpB;;;AAGF;EACE;;;AAGF;EACE;EACA;EACA;;AAEA;EACE;;AAGF;EACE,SLgBY;EKfZ,gBLgBmB;;;AKZvB;EACE,eLuBY;EKtBZ;EACA;EACA;EACA;;;AC3CF;EACE;EACA;EACA;EACA;EACA;EACA;EACA,SNUa;;;AOjBf;ECCE,ORoCU;EQnCV;EACA;EACA;EACA;EACA;EDHA;EACA;EACA,ePYa;EOXb;EACA;EACA;;;AAGF;EACE;EACA;;;AAGF;EACE;EACA,ePDa;EOEb;EACA;EACA;;;AAGF;EACE,QPqCY;EOpCZ,SPRc;;;ASlBhB;AAAA;AAAA;EAGE;EACA,kBToBK;ESnBL;EACA,eTUmB;ESTnB,OTcM;ESbN;EACA;EACA,aTPiB;ESQjB,WTHe;ESIf;EACA,aTHiB;ESIjB;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;AAAA;AAAA;EACE;EACA,OTHI;;ASMN;AAAA;AAAA;EACE,STqBY;ESpBZ,gBTqBmB;;ASlBrB;AAAA;AAAA;EACE;EACA;;AAEA;AAAA;AAAA;EACE,kBTbC;;;ASkBP;EACE;EACA,QTkBY;ESjBZ,cTrBK;ESsBL,OTtBK;;;ASyBP;EACE,kBTzBI;;AS2BJ;EACE;EACA,OTjCI;;;ASqCR;EACE,eT1Ca;;;AUjBf;EACE;EACA;;AAEA;EACE,MVgCQ;EU/BR;EACA;EACA;;;AAIJ;EACE;;AAEA;EACE;EACA;EACA;EACA;;AAIA;EACE;;AAGF;EACE,MVJC;EUKD;;;AAKN;AAAA;EAEE,aV1BiB;;;AU6BnB;EACE;;;AAGF;AAAA;EAEE;;;AC7CF;EAGE;EACA;EACA;EACA,eXWa;EWVb;EACA;;ACPA;EACE;EACA;EACA;;;ADOJ;EACE;EACA;EACA;EACA;;;AAGF;EACE;EACA;EACA;EACA;;AAEA;EACE,aXfe;;;AWmBnB;EACE;EACA;EACA;;;AAGF;EACE,QX0BY;EWzBZ;EACA;EACA,SXrBc;EWsBd;;AAEA;EACE;;AAGF;EACE;;;AAKF;EACE,OX5BE;EW6BF;;;AErDF;EACE,kBbmDM;EalDN;EACA;EACA;EACA;EACA;;AAEA;EACE;EACA;;AAEA;EAEE;;;AAdN;EACE,kBbmDM;EalDN;EACA;EACA;EACA;EACA;;AAEA;EACE;EACA;;AAEA;EAEE;;;AAdN;EACE,kBbmDM;EalDN;EACA;EACA;EACA;EACA;;AAEA;EACE;EACA;;AAEA;EAEE;;;AAdN;EACE,kBbmDM;EalDN;EACA;EACA;EACA;EACA;;AAEA;EACE;EACA;;AAEA;EAEE;;;ACfR;EACE;;;ACDF;EACE,kBfoBM;EenBN,efcmB;EebnB;EAEA;EACA;EACA;;;AAGF;AAAA;EAEE;;;AAGF;EACE;EACA;;;AAGF;EACE;EACA,efwCY;EevCZ;;;AAGF;EACE;EACA;;;AC1BF;EACE;EACA,ShBaa;EgBZb;;;AAGF;EACE;EACA,OhByBO;EgBxBP;EACA;EACA;EACA,SAdwB;EAexB;;AAGA;EACE,ehBDY;;AgBId;EACE;EACA,ehBRiB;EgBSjB,OhBUK;;;AgBNT;EACE,ahBpBiB;;;AiBVnB;EACE,YjBgBa;EiBfb,cjBea;EiBdb,ejBca;EiBbb;;AAEA;AAAA;AAAA;AAAA;AAAA;EAKE,QjBOY;;AiBJd;EACE,ajBLe;;;AkBRnB;EACE;EACA;EACA;EACA;EACA;;;AAGF;EACE;EACA;EACA;;;AAGF;EACE,MlBkBO;EkBjBP,QAlBiB;EAmBjB,MAnBiB;EAoBjB;EACA;EACA;EACA,OAvBiB;;;AA0BnB;EACE,QA3BiB;EA4BjB;EACA;EACA;EACA;EACA,OAhCiB;;;AAmCnB;EACE,MlBFO;EkBGP,QArCiB;EAsCjB;EACA;EACA,OAxCiB;;AA0CjB;EACE,MlBnBG;;;AmBxBP;EACE,OnBwBI","file":"application.css"} \ No newline at end of file diff --git a/app/assets/builds/administrate/application.js b/app/assets/builds/administrate/application.js new file mode 100644 index 0000000000..06c480338d --- /dev/null +++ b/app/assets/builds/administrate/application.js @@ -0,0 +1,8110 @@ +(() => { + var __create = Object.create; + var __defProp = Object.defineProperty; + var __getOwnPropDesc = Object.getOwnPropertyDescriptor; + var __getOwnPropNames = Object.getOwnPropertyNames; + var __getProtoOf = Object.getPrototypeOf; + var __hasOwnProp = Object.prototype.hasOwnProperty; + var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; + }; + var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; + }; + var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod + )); + + // node_modules/jquery/dist/jquery.js + var require_jquery = __commonJS({ + "node_modules/jquery/dist/jquery.js"(exports, module) { + (function(global, factory) { + "use strict"; + if (typeof module === "object" && typeof module.exports === "object") { + module.exports = global.document ? factory(global, true) : function(w) { + if (!w.document) { + throw new Error("jQuery requires a window with a document"); + } + return factory(w); + }; + } else { + factory(global); + } + })(typeof window !== "undefined" ? window : exports, function(window2, noGlobal) { + "use strict"; + var arr = []; + var getProto = Object.getPrototypeOf; + var slice = arr.slice; + var flat = arr.flat ? function(array) { + return arr.flat.call(array); + } : function(array) { + return arr.concat.apply([], array); + }; + var push = arr.push; + var indexOf = arr.indexOf; + var class2type = {}; + var toString = class2type.toString; + var hasOwn = class2type.hasOwnProperty; + var fnToString = hasOwn.toString; + var ObjectFunctionString = fnToString.call(Object); + var support = {}; + var isFunction = function isFunction2(obj) { + return typeof obj === "function" && typeof obj.nodeType !== "number" && typeof obj.item !== "function"; + }; + var isWindow = function isWindow2(obj) { + return obj != null && obj === obj.window; + }; + var document2 = window2.document; + var preservedScriptAttributes = { + type: true, + src: true, + nonce: true, + noModule: true + }; + function DOMEval(code, node, doc) { + doc = doc || document2; + var i, val, script = doc.createElement("script"); + script.text = code; + if (node) { + for (i in preservedScriptAttributes) { + val = node[i] || node.getAttribute && node.getAttribute(i); + if (val) { + script.setAttribute(i, val); + } + } + } + doc.head.appendChild(script).parentNode.removeChild(script); + } + function toType(obj) { + if (obj == null) { + return obj + ""; + } + return typeof obj === "object" || typeof obj === "function" ? class2type[toString.call(obj)] || "object" : typeof obj; + } + var version = "3.7.0", rhtmlSuffix = /HTML$/i, jQuery2 = function(selector, context) { + return new jQuery2.fn.init(selector, context); + }; + jQuery2.fn = jQuery2.prototype = { + // The current version of jQuery being used + jquery: version, + constructor: jQuery2, + // The default length of a jQuery object is 0 + length: 0, + toArray: function() { + return slice.call(this); + }, + // Get the Nth element in the matched element set OR + // Get the whole matched element set as a clean array + get: function(num) { + if (num == null) { + return slice.call(this); + } + return num < 0 ? this[num + this.length] : this[num]; + }, + // Take an array of elements and push it onto the stack + // (returning the new matched element set) + pushStack: function(elems) { + var ret = jQuery2.merge(this.constructor(), elems); + ret.prevObject = this; + return ret; + }, + // Execute a callback for every element in the matched set. + each: function(callback) { + return jQuery2.each(this, callback); + }, + map: function(callback) { + return this.pushStack(jQuery2.map(this, function(elem, i) { + return callback.call(elem, i, elem); + })); + }, + slice: function() { + return this.pushStack(slice.apply(this, arguments)); + }, + first: function() { + return this.eq(0); + }, + last: function() { + return this.eq(-1); + }, + even: function() { + return this.pushStack(jQuery2.grep(this, function(_elem, i) { + return (i + 1) % 2; + })); + }, + odd: function() { + return this.pushStack(jQuery2.grep(this, function(_elem, i) { + return i % 2; + })); + }, + eq: function(i) { + var len = this.length, j = +i + (i < 0 ? len : 0); + return this.pushStack(j >= 0 && j < len ? [this[j]] : []); + }, + end: function() { + return this.prevObject || this.constructor(); + }, + // For internal use only. + // Behaves like an Array's method, not like a jQuery method. + push, + sort: arr.sort, + splice: arr.splice + }; + jQuery2.extend = jQuery2.fn.extend = function() { + var options, name, src, copy, copyIsArray, clone, target = arguments[0] || {}, i = 1, length = arguments.length, deep = false; + if (typeof target === "boolean") { + deep = target; + target = arguments[i] || {}; + i++; + } + if (typeof target !== "object" && !isFunction(target)) { + target = {}; + } + if (i === length) { + target = this; + i--; + } + for (; i < length; i++) { + if ((options = arguments[i]) != null) { + for (name in options) { + copy = options[name]; + if (name === "__proto__" || target === copy) { + continue; + } + if (deep && copy && (jQuery2.isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) { + src = target[name]; + if (copyIsArray && !Array.isArray(src)) { + clone = []; + } else if (!copyIsArray && !jQuery2.isPlainObject(src)) { + clone = {}; + } else { + clone = src; + } + copyIsArray = false; + target[name] = jQuery2.extend(deep, clone, copy); + } else if (copy !== void 0) { + target[name] = copy; + } + } + } + } + return target; + }; + jQuery2.extend({ + // Unique for each copy of jQuery on the page + expando: "jQuery" + (version + Math.random()).replace(/\D/g, ""), + // Assume jQuery is ready without the ready module + isReady: true, + error: function(msg) { + throw new Error(msg); + }, + noop: function() { + }, + isPlainObject: function(obj) { + var proto, Ctor; + if (!obj || toString.call(obj) !== "[object Object]") { + return false; + } + proto = getProto(obj); + if (!proto) { + return true; + } + Ctor = hasOwn.call(proto, "constructor") && proto.constructor; + return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString; + }, + isEmptyObject: function(obj) { + var name; + for (name in obj) { + return false; + } + return true; + }, + // Evaluates a script in a provided context; falls back to the global one + // if not specified. + globalEval: function(code, options, doc) { + DOMEval(code, { nonce: options && options.nonce }, doc); + }, + each: function(obj, callback) { + var length, i = 0; + if (isArrayLike(obj)) { + length = obj.length; + for (; i < length; i++) { + if (callback.call(obj[i], i, obj[i]) === false) { + break; + } + } + } else { + for (i in obj) { + if (callback.call(obj[i], i, obj[i]) === false) { + break; + } + } + } + return obj; + }, + // Retrieve the text value of an array of DOM nodes + text: function(elem) { + var node, ret = "", i = 0, nodeType = elem.nodeType; + if (!nodeType) { + while (node = elem[i++]) { + ret += jQuery2.text(node); + } + } else if (nodeType === 1 || nodeType === 9 || nodeType === 11) { + return elem.textContent; + } else if (nodeType === 3 || nodeType === 4) { + return elem.nodeValue; + } + return ret; + }, + // results is for internal usage only + makeArray: function(arr2, results) { + var ret = results || []; + if (arr2 != null) { + if (isArrayLike(Object(arr2))) { + jQuery2.merge( + ret, + typeof arr2 === "string" ? [arr2] : arr2 + ); + } else { + push.call(ret, arr2); + } + } + return ret; + }, + inArray: function(elem, arr2, i) { + return arr2 == null ? -1 : indexOf.call(arr2, elem, i); + }, + isXMLDoc: function(elem) { + var namespace = elem && elem.namespaceURI, docElem = elem && (elem.ownerDocument || elem).documentElement; + return !rhtmlSuffix.test(namespace || docElem && docElem.nodeName || "HTML"); + }, + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + merge: function(first, second) { + var len = +second.length, j = 0, i = first.length; + for (; j < len; j++) { + first[i++] = second[j]; + } + first.length = i; + return first; + }, + grep: function(elems, callback, invert) { + var callbackInverse, matches = [], i = 0, length = elems.length, callbackExpect = !invert; + for (; i < length; i++) { + callbackInverse = !callback(elems[i], i); + if (callbackInverse !== callbackExpect) { + matches.push(elems[i]); + } + } + return matches; + }, + // arg is for internal usage only + map: function(elems, callback, arg) { + var length, value, i = 0, ret = []; + if (isArrayLike(elems)) { + length = elems.length; + for (; i < length; i++) { + value = callback(elems[i], i, arg); + if (value != null) { + ret.push(value); + } + } + } else { + for (i in elems) { + value = callback(elems[i], i, arg); + if (value != null) { + ret.push(value); + } + } + } + return flat(ret); + }, + // A global GUID counter for objects + guid: 1, + // jQuery.support is not used in Core but other projects attach their + // properties to it so it needs to exist. + support + }); + if (typeof Symbol === "function") { + jQuery2.fn[Symbol.iterator] = arr[Symbol.iterator]; + } + jQuery2.each( + "Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), + function(_i, name) { + class2type["[object " + name + "]"] = name.toLowerCase(); + } + ); + function isArrayLike(obj) { + var length = !!obj && "length" in obj && obj.length, type = toType(obj); + if (isFunction(obj) || isWindow(obj)) { + return false; + } + return type === "array" || length === 0 || typeof length === "number" && length > 0 && length - 1 in obj; + } + function nodeName(elem, name) { + return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); + } + var pop = arr.pop; + var sort = arr.sort; + var splice = arr.splice; + var whitespace = "[\\x20\\t\\r\\n\\f]"; + var rtrimCSS = new RegExp( + "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", + "g" + ); + jQuery2.contains = function(a, b) { + var bup = b && b.parentNode; + return a === bup || !!(bup && bup.nodeType === 1 && // Support: IE 9 - 11+ + // IE doesn't have `contains` on SVG. + (a.contains ? a.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16)); + }; + var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g; + function fcssescape(ch, asCodePoint) { + if (asCodePoint) { + if (ch === "\0") { + return "\uFFFD"; + } + return ch.slice(0, -1) + "\\" + ch.charCodeAt(ch.length - 1).toString(16) + " "; + } + return "\\" + ch; + } + jQuery2.escapeSelector = function(sel) { + return (sel + "").replace(rcssescape, fcssescape); + }; + var preferredDoc = document2, pushNative = push; + (function() { + var i, Expr, outermostContext, sortInput, hasDuplicate, push2 = pushNative, document3, documentElement2, documentIsHTML, rbuggyQSA, matches, expando = jQuery2.expando, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), nonnativeSelectorCache = createCache(), sortOrder = function(a, b) { + if (a === b) { + hasDuplicate = true; + } + return 0; + }, booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+", attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + // Operator (capture 2) + "*([*^$|!~]?=)" + whitespace + // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" + `*(?:'((?:\\\\.|[^\\\\'])*)'|"((?:\\\\.|[^\\\\"])*)"|(` + identifier + "))|)" + whitespace + "*\\]", pseudos = ":(" + identifier + `)(?:\\((('((?:\\\\.|[^\\\\'])*)'|"((?:\\\\.|[^\\\\"])*)")|((?:\\\\.|[^\\\\()[\\]]|` + attributes + ")*)|.*)\\)|)", rwhitespace = new RegExp(whitespace + "+", "g"), rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"), rleadingCombinator = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"), rdescend = new RegExp(whitespace + "|>"), rpseudo = new RegExp(pseudos), ridentifier = new RegExp("^" + identifier + "$"), matchExpr = { + ID: new RegExp("^#(" + identifier + ")"), + CLASS: new RegExp("^\\.(" + identifier + ")"), + TAG: new RegExp("^(" + identifier + "|[*])"), + ATTR: new RegExp("^" + attributes), + PSEUDO: new RegExp("^" + pseudos), + CHILD: new RegExp( + "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", + "i" + ), + bool: new RegExp("^(?:" + booleans + ")$", "i"), + // For use in libraries implementing .is() + // We use this for POS matching in `select` + needsContext: new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i") + }, rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, rquickExpr2 = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, rsibling = /[+~]/, runescape = new RegExp("\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g"), funescape = function(escape, nonHex) { + var high = "0x" + escape.slice(1) - 65536; + if (nonHex) { + return nonHex; + } + return high < 0 ? String.fromCharCode(high + 65536) : String.fromCharCode(high >> 10 | 55296, high & 1023 | 56320); + }, unloadHandler = function() { + setDocument(); + }, inDisabledFieldset = addCombinator( + function(elem) { + return elem.disabled === true && nodeName(elem, "fieldset"); + }, + { dir: "parentNode", next: "legend" } + ); + function safeActiveElement() { + try { + return document3.activeElement; + } catch (err) { + } + } + try { + push2.apply( + arr = slice.call(preferredDoc.childNodes), + preferredDoc.childNodes + ); + arr[preferredDoc.childNodes.length].nodeType; + } catch (e) { + push2 = { + apply: function(target, els) { + pushNative.apply(target, slice.call(els)); + }, + call: function(target) { + pushNative.apply(target, slice.call(arguments, 1)); + } + }; + } + function find(selector, context, results, seed) { + var m, i2, elem, nid, match, groups, newSelector, newContext = context && context.ownerDocument, nodeType = context ? context.nodeType : 9; + results = results || []; + if (typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) { + return results; + } + if (!seed) { + setDocument(context); + context = context || document3; + if (documentIsHTML) { + if (nodeType !== 11 && (match = rquickExpr2.exec(selector))) { + if (m = match[1]) { + if (nodeType === 9) { + if (elem = context.getElementById(m)) { + if (elem.id === m) { + push2.call(results, elem); + return results; + } + } else { + return results; + } + } else { + if (newContext && (elem = newContext.getElementById(m)) && find.contains(context, elem) && elem.id === m) { + push2.call(results, elem); + return results; + } + } + } else if (match[2]) { + push2.apply(results, context.getElementsByTagName(selector)); + return results; + } else if ((m = match[3]) && context.getElementsByClassName) { + push2.apply(results, context.getElementsByClassName(m)); + return results; + } + } + if (!nonnativeSelectorCache[selector + " "] && (!rbuggyQSA || !rbuggyQSA.test(selector))) { + newSelector = selector; + newContext = context; + if (nodeType === 1 && (rdescend.test(selector) || rleadingCombinator.test(selector))) { + newContext = rsibling.test(selector) && testContext(context.parentNode) || context; + if (newContext != context || !support.scope) { + if (nid = context.getAttribute("id")) { + nid = jQuery2.escapeSelector(nid); + } else { + context.setAttribute("id", nid = expando); + } + } + groups = tokenize(selector); + i2 = groups.length; + while (i2--) { + groups[i2] = (nid ? "#" + nid : ":scope") + " " + toSelector(groups[i2]); + } + newSelector = groups.join(","); + } + try { + push2.apply( + results, + newContext.querySelectorAll(newSelector) + ); + return results; + } catch (qsaError) { + nonnativeSelectorCache(selector, true); + } finally { + if (nid === expando) { + context.removeAttribute("id"); + } + } + } + } + } + return select(selector.replace(rtrimCSS, "$1"), context, results, seed); + } + function createCache() { + var keys = []; + function cache(key, value) { + if (keys.push(key + " ") > Expr.cacheLength) { + delete cache[keys.shift()]; + } + return cache[key + " "] = value; + } + return cache; + } + function markFunction(fn) { + fn[expando] = true; + return fn; + } + function assert(fn) { + var el = document3.createElement("fieldset"); + try { + return !!fn(el); + } catch (e) { + return false; + } finally { + if (el.parentNode) { + el.parentNode.removeChild(el); + } + el = null; + } + } + function createInputPseudo(type) { + return function(elem) { + return nodeName(elem, "input") && elem.type === type; + }; + } + function createButtonPseudo(type) { + return function(elem) { + return (nodeName(elem, "input") || nodeName(elem, "button")) && elem.type === type; + }; + } + function createDisabledPseudo(disabled) { + return function(elem) { + if ("form" in elem) { + if (elem.parentNode && elem.disabled === false) { + if ("label" in elem) { + if ("label" in elem.parentNode) { + return elem.parentNode.disabled === disabled; + } else { + return elem.disabled === disabled; + } + } + return elem.isDisabled === disabled || // Where there is no isDisabled, check manually + elem.isDisabled !== !disabled && inDisabledFieldset(elem) === disabled; + } + return elem.disabled === disabled; + } else if ("label" in elem) { + return elem.disabled === disabled; + } + return false; + }; + } + function createPositionalPseudo(fn) { + return markFunction(function(argument) { + argument = +argument; + return markFunction(function(seed, matches2) { + var j, matchIndexes = fn([], seed.length, argument), i2 = matchIndexes.length; + while (i2--) { + if (seed[j = matchIndexes[i2]]) { + seed[j] = !(matches2[j] = seed[j]); + } + } + }); + }); + } + function testContext(context) { + return context && typeof context.getElementsByTagName !== "undefined" && context; + } + function setDocument(node) { + var subWindow, doc = node ? node.ownerDocument || node : preferredDoc; + if (doc == document3 || doc.nodeType !== 9 || !doc.documentElement) { + return document3; + } + document3 = doc; + documentElement2 = document3.documentElement; + documentIsHTML = !jQuery2.isXMLDoc(document3); + matches = documentElement2.matches || documentElement2.webkitMatchesSelector || documentElement2.msMatchesSelector; + if (preferredDoc != document3 && (subWindow = document3.defaultView) && subWindow.top !== subWindow) { + subWindow.addEventListener("unload", unloadHandler); + } + support.getById = assert(function(el) { + documentElement2.appendChild(el).id = jQuery2.expando; + return !document3.getElementsByName || !document3.getElementsByName(jQuery2.expando).length; + }); + support.disconnectedMatch = assert(function(el) { + return matches.call(el, "*"); + }); + support.scope = assert(function() { + return document3.querySelectorAll(":scope"); + }); + support.cssHas = assert(function() { + try { + document3.querySelector(":has(*,:jqfake)"); + return false; + } catch (e) { + return true; + } + }); + if (support.getById) { + Expr.filter.ID = function(id) { + var attrId = id.replace(runescape, funescape); + return function(elem) { + return elem.getAttribute("id") === attrId; + }; + }; + Expr.find.ID = function(id, context) { + if (typeof context.getElementById !== "undefined" && documentIsHTML) { + var elem = context.getElementById(id); + return elem ? [elem] : []; + } + }; + } else { + Expr.filter.ID = function(id) { + var attrId = id.replace(runescape, funescape); + return function(elem) { + var node2 = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); + return node2 && node2.value === attrId; + }; + }; + Expr.find.ID = function(id, context) { + if (typeof context.getElementById !== "undefined" && documentIsHTML) { + var node2, i2, elems, elem = context.getElementById(id); + if (elem) { + node2 = elem.getAttributeNode("id"); + if (node2 && node2.value === id) { + return [elem]; + } + elems = context.getElementsByName(id); + i2 = 0; + while (elem = elems[i2++]) { + node2 = elem.getAttributeNode("id"); + if (node2 && node2.value === id) { + return [elem]; + } + } + } + return []; + } + }; + } + Expr.find.TAG = function(tag, context) { + if (typeof context.getElementsByTagName !== "undefined") { + return context.getElementsByTagName(tag); + } else { + return context.querySelectorAll(tag); + } + }; + Expr.find.CLASS = function(className, context) { + if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) { + return context.getElementsByClassName(className); + } + }; + rbuggyQSA = []; + assert(function(el) { + var input; + documentElement2.appendChild(el).innerHTML = ""; + if (!el.querySelectorAll("[selected]").length) { + rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")"); + } + if (!el.querySelectorAll("[id~=" + expando + "-]").length) { + rbuggyQSA.push("~="); + } + if (!el.querySelectorAll("a#" + expando + "+*").length) { + rbuggyQSA.push(".#.+[+~]"); + } + if (!el.querySelectorAll(":checked").length) { + rbuggyQSA.push(":checked"); + } + input = document3.createElement("input"); + input.setAttribute("type", "hidden"); + el.appendChild(input).setAttribute("name", "D"); + documentElement2.appendChild(el).disabled = true; + if (el.querySelectorAll(":disabled").length !== 2) { + rbuggyQSA.push(":enabled", ":disabled"); + } + input = document3.createElement("input"); + input.setAttribute("name", ""); + el.appendChild(input); + if (!el.querySelectorAll("[name='']").length) { + rbuggyQSA.push("\\[" + whitespace + "*name" + whitespace + "*=" + whitespace + `*(?:''|"")`); + } + }); + if (!support.cssHas) { + rbuggyQSA.push(":has"); + } + rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|")); + sortOrder = function(a, b) { + if (a === b) { + hasDuplicate = true; + return 0; + } + var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; + if (compare) { + return compare; + } + compare = (a.ownerDocument || a) == (b.ownerDocument || b) ? a.compareDocumentPosition(b) : ( + // Otherwise we know they are disconnected + 1 + ); + if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) { + if (a === document3 || a.ownerDocument == preferredDoc && find.contains(preferredDoc, a)) { + return -1; + } + if (b === document3 || b.ownerDocument == preferredDoc && find.contains(preferredDoc, b)) { + return 1; + } + return sortInput ? indexOf.call(sortInput, a) - indexOf.call(sortInput, b) : 0; + } + return compare & 4 ? -1 : 1; + }; + return document3; + } + find.matches = function(expr, elements) { + return find(expr, null, null, elements); + }; + find.matchesSelector = function(elem, expr) { + setDocument(elem); + if (documentIsHTML && !nonnativeSelectorCache[expr + " "] && (!rbuggyQSA || !rbuggyQSA.test(expr))) { + try { + var ret = matches.call(elem, expr); + if (ret || support.disconnectedMatch || // As well, disconnected nodes are said to be in a document + // fragment in IE 9 + elem.document && elem.document.nodeType !== 11) { + return ret; + } + } catch (e) { + nonnativeSelectorCache(expr, true); + } + } + return find(expr, document3, null, [elem]).length > 0; + }; + find.contains = function(context, elem) { + if ((context.ownerDocument || context) != document3) { + setDocument(context); + } + return jQuery2.contains(context, elem); + }; + find.attr = function(elem, name) { + if ((elem.ownerDocument || elem) != document3) { + setDocument(elem); + } + var fn = Expr.attrHandle[name.toLowerCase()], val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : void 0; + if (val !== void 0) { + return val; + } + return elem.getAttribute(name); + }; + find.error = function(msg) { + throw new Error("Syntax error, unrecognized expression: " + msg); + }; + jQuery2.uniqueSort = function(results) { + var elem, duplicates = [], j = 0, i2 = 0; + hasDuplicate = !support.sortStable; + sortInput = !support.sortStable && slice.call(results, 0); + sort.call(results, sortOrder); + if (hasDuplicate) { + while (elem = results[i2++]) { + if (elem === results[i2]) { + j = duplicates.push(i2); + } + } + while (j--) { + splice.call(results, duplicates[j], 1); + } + } + sortInput = null; + return results; + }; + jQuery2.fn.uniqueSort = function() { + return this.pushStack(jQuery2.uniqueSort(slice.apply(this))); + }; + Expr = jQuery2.expr = { + // Can be adjusted by the user + cacheLength: 50, + createPseudo: markFunction, + match: matchExpr, + attrHandle: {}, + find: {}, + relative: { + ">": { dir: "parentNode", first: true }, + " ": { dir: "parentNode" }, + "+": { dir: "previousSibling", first: true }, + "~": { dir: "previousSibling" } + }, + preFilter: { + ATTR: function(match) { + match[1] = match[1].replace(runescape, funescape); + match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape); + if (match[2] === "~=") { + match[3] = " " + match[3] + " "; + } + return match.slice(0, 4); + }, + CHILD: function(match) { + match[1] = match[1].toLowerCase(); + if (match[1].slice(0, 3) === "nth") { + if (!match[3]) { + find.error(match[0]); + } + match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd")); + match[5] = +(match[7] + match[8] || match[3] === "odd"); + } else if (match[3]) { + find.error(match[0]); + } + return match; + }, + PSEUDO: function(match) { + var excess, unquoted = !match[6] && match[2]; + if (matchExpr.CHILD.test(match[0])) { + return null; + } + if (match[3]) { + match[2] = match[4] || match[5] || ""; + } else if (unquoted && rpseudo.test(unquoted) && // Get excess from tokenize (recursively) + (excess = tokenize(unquoted, true)) && // advance to the next closing parenthesis + (excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) { + match[0] = match[0].slice(0, excess); + match[2] = unquoted.slice(0, excess); + } + return match.slice(0, 3); + } + }, + filter: { + TAG: function(nodeNameSelector) { + var expectedNodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase(); + return nodeNameSelector === "*" ? function() { + return true; + } : function(elem) { + return nodeName(elem, expectedNodeName); + }; + }, + CLASS: function(className) { + var pattern = classCache[className + " "]; + return pattern || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) && classCache(className, function(elem) { + return pattern.test( + typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" + ); + }); + }, + ATTR: function(name, operator, check) { + return function(elem) { + var result = find.attr(elem, name); + if (result == null) { + return operator === "!="; + } + if (!operator) { + return true; + } + result += ""; + if (operator === "=") { + return result === check; + } + if (operator === "!=") { + return result !== check; + } + if (operator === "^=") { + return check && result.indexOf(check) === 0; + } + if (operator === "*=") { + return check && result.indexOf(check) > -1; + } + if (operator === "$=") { + return check && result.slice(-check.length) === check; + } + if (operator === "~=") { + return (" " + result.replace(rwhitespace, " ") + " ").indexOf(check) > -1; + } + if (operator === "|=") { + return result === check || result.slice(0, check.length + 1) === check + "-"; + } + return false; + }; + }, + CHILD: function(type, what, _argument, first, last) { + var simple = type.slice(0, 3) !== "nth", forward = type.slice(-4) !== "last", ofType = what === "of-type"; + return first === 1 && last === 0 ? ( + // Shortcut for :nth-*(n) + function(elem) { + return !!elem.parentNode; + } + ) : function(elem, _context, xml) { + var cache, outerCache, node, nodeIndex, start, dir2 = simple !== forward ? "nextSibling" : "previousSibling", parent = elem.parentNode, name = ofType && elem.nodeName.toLowerCase(), useCache = !xml && !ofType, diff = false; + if (parent) { + if (simple) { + while (dir2) { + node = elem; + while (node = node[dir2]) { + if (ofType ? nodeName(node, name) : node.nodeType === 1) { + return false; + } + } + start = dir2 = type === "only" && !start && "nextSibling"; + } + return true; + } + start = [forward ? parent.firstChild : parent.lastChild]; + if (forward && useCache) { + outerCache = parent[expando] || (parent[expando] = {}); + cache = outerCache[type] || []; + nodeIndex = cache[0] === dirruns && cache[1]; + diff = nodeIndex && cache[2]; + node = nodeIndex && parent.childNodes[nodeIndex]; + while (node = ++nodeIndex && node && node[dir2] || // Fallback to seeking `elem` from the start + (diff = nodeIndex = 0) || start.pop()) { + if (node.nodeType === 1 && ++diff && node === elem) { + outerCache[type] = [dirruns, nodeIndex, diff]; + break; + } + } + } else { + if (useCache) { + outerCache = elem[expando] || (elem[expando] = {}); + cache = outerCache[type] || []; + nodeIndex = cache[0] === dirruns && cache[1]; + diff = nodeIndex; + } + if (diff === false) { + while (node = ++nodeIndex && node && node[dir2] || (diff = nodeIndex = 0) || start.pop()) { + if ((ofType ? nodeName(node, name) : node.nodeType === 1) && ++diff) { + if (useCache) { + outerCache = node[expando] || (node[expando] = {}); + outerCache[type] = [dirruns, diff]; + } + if (node === elem) { + break; + } + } + } + } + } + diff -= last; + return diff === first || diff % first === 0 && diff / first >= 0; + } + }; + }, + PSEUDO: function(pseudo, argument) { + var args, fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || find.error("unsupported pseudo: " + pseudo); + if (fn[expando]) { + return fn(argument); + } + if (fn.length > 1) { + args = [pseudo, pseudo, "", argument]; + return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function(seed, matches2) { + var idx, matched = fn(seed, argument), i2 = matched.length; + while (i2--) { + idx = indexOf.call(seed, matched[i2]); + seed[idx] = !(matches2[idx] = matched[i2]); + } + }) : function(elem) { + return fn(elem, 0, args); + }; + } + return fn; + } + }, + pseudos: { + // Potentially complex pseudos + not: markFunction(function(selector) { + var input = [], results = [], matcher = compile(selector.replace(rtrimCSS, "$1")); + return matcher[expando] ? markFunction(function(seed, matches2, _context, xml) { + var elem, unmatched = matcher(seed, null, xml, []), i2 = seed.length; + while (i2--) { + if (elem = unmatched[i2]) { + seed[i2] = !(matches2[i2] = elem); + } + } + }) : function(elem, _context, xml) { + input[0] = elem; + matcher(input, null, xml, results); + input[0] = null; + return !results.pop(); + }; + }), + has: markFunction(function(selector) { + return function(elem) { + return find(selector, elem).length > 0; + }; + }), + contains: markFunction(function(text) { + text = text.replace(runescape, funescape); + return function(elem) { + return (elem.textContent || jQuery2.text(elem)).indexOf(text) > -1; + }; + }), + // "Whether an element is represented by a :lang() selector + // is based solely on the element's language value + // being equal to the identifier C, + // or beginning with the identifier C immediately followed by "-". + // The matching of C against the element's language value is performed case-insensitively. + // The identifier C does not have to be a valid language name." + // https://www.w3.org/TR/selectors/#lang-pseudo + lang: markFunction(function(lang) { + if (!ridentifier.test(lang || "")) { + find.error("unsupported lang: " + lang); + } + lang = lang.replace(runescape, funescape).toLowerCase(); + return function(elem) { + var elemLang; + do { + if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) { + elemLang = elemLang.toLowerCase(); + return elemLang === lang || elemLang.indexOf(lang + "-") === 0; + } + } while ((elem = elem.parentNode) && elem.nodeType === 1); + return false; + }; + }), + // Miscellaneous + target: function(elem) { + var hash = window2.location && window2.location.hash; + return hash && hash.slice(1) === elem.id; + }, + root: function(elem) { + return elem === documentElement2; + }, + focus: function(elem) { + return elem === safeActiveElement() && document3.hasFocus() && !!(elem.type || elem.href || ~elem.tabIndex); + }, + // Boolean properties + enabled: createDisabledPseudo(false), + disabled: createDisabledPseudo(true), + checked: function(elem) { + return nodeName(elem, "input") && !!elem.checked || nodeName(elem, "option") && !!elem.selected; + }, + selected: function(elem) { + if (elem.parentNode) { + elem.parentNode.selectedIndex; + } + return elem.selected === true; + }, + // Contents + empty: function(elem) { + for (elem = elem.firstChild; elem; elem = elem.nextSibling) { + if (elem.nodeType < 6) { + return false; + } + } + return true; + }, + parent: function(elem) { + return !Expr.pseudos.empty(elem); + }, + // Element/input types + header: function(elem) { + return rheader.test(elem.nodeName); + }, + input: function(elem) { + return rinputs.test(elem.nodeName); + }, + button: function(elem) { + return nodeName(elem, "input") && elem.type === "button" || nodeName(elem, "button"); + }, + text: function(elem) { + var attr; + return nodeName(elem, "input") && elem.type === "text" && // Support: IE <10 only + // New HTML5 attribute values (e.g., "search") appear + // with elem.type === "text" + ((attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text"); + }, + // Position-in-collection + first: createPositionalPseudo(function() { + return [0]; + }), + last: createPositionalPseudo(function(_matchIndexes, length) { + return [length - 1]; + }), + eq: createPositionalPseudo(function(_matchIndexes, length, argument) { + return [argument < 0 ? argument + length : argument]; + }), + even: createPositionalPseudo(function(matchIndexes, length) { + var i2 = 0; + for (; i2 < length; i2 += 2) { + matchIndexes.push(i2); + } + return matchIndexes; + }), + odd: createPositionalPseudo(function(matchIndexes, length) { + var i2 = 1; + for (; i2 < length; i2 += 2) { + matchIndexes.push(i2); + } + return matchIndexes; + }), + lt: createPositionalPseudo(function(matchIndexes, length, argument) { + var i2; + if (argument < 0) { + i2 = argument + length; + } else if (argument > length) { + i2 = length; + } else { + i2 = argument; + } + for (; --i2 >= 0; ) { + matchIndexes.push(i2); + } + return matchIndexes; + }), + gt: createPositionalPseudo(function(matchIndexes, length, argument) { + var i2 = argument < 0 ? argument + length : argument; + for (; ++i2 < length; ) { + matchIndexes.push(i2); + } + return matchIndexes; + }) + } + }; + Expr.pseudos.nth = Expr.pseudos.eq; + for (i in { radio: true, checkbox: true, file: true, password: true, image: true }) { + Expr.pseudos[i] = createInputPseudo(i); + } + for (i in { submit: true, reset: true }) { + Expr.pseudos[i] = createButtonPseudo(i); + } + function setFilters() { + } + setFilters.prototype = Expr.filters = Expr.pseudos; + Expr.setFilters = new setFilters(); + function tokenize(selector, parseOnly) { + var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[selector + " "]; + if (cached) { + return parseOnly ? 0 : cached.slice(0); + } + soFar = selector; + groups = []; + preFilters = Expr.preFilter; + while (soFar) { + if (!matched || (match = rcomma.exec(soFar))) { + if (match) { + soFar = soFar.slice(match[0].length) || soFar; + } + groups.push(tokens = []); + } + matched = false; + if (match = rleadingCombinator.exec(soFar)) { + matched = match.shift(); + tokens.push({ + value: matched, + // Cast descendant combinators to space + type: match[0].replace(rtrimCSS, " ") + }); + soFar = soFar.slice(matched.length); + } + for (type in Expr.filter) { + if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) { + matched = match.shift(); + tokens.push({ + value: matched, + type, + matches: match + }); + soFar = soFar.slice(matched.length); + } + } + if (!matched) { + break; + } + } + if (parseOnly) { + return soFar.length; + } + return soFar ? find.error(selector) : ( + // Cache the tokens + tokenCache(selector, groups).slice(0) + ); + } + function toSelector(tokens) { + var i2 = 0, len = tokens.length, selector = ""; + for (; i2 < len; i2++) { + selector += tokens[i2].value; + } + return selector; + } + function addCombinator(matcher, combinator, base) { + var dir2 = combinator.dir, skip = combinator.next, key = skip || dir2, checkNonElements = base && key === "parentNode", doneName = done++; + return combinator.first ? ( + // Check against closest ancestor/preceding element + function(elem, context, xml) { + while (elem = elem[dir2]) { + if (elem.nodeType === 1 || checkNonElements) { + return matcher(elem, context, xml); + } + } + return false; + } + ) : ( + // Check against all ancestor/preceding elements + function(elem, context, xml) { + var oldCache, outerCache, newCache = [dirruns, doneName]; + if (xml) { + while (elem = elem[dir2]) { + if (elem.nodeType === 1 || checkNonElements) { + if (matcher(elem, context, xml)) { + return true; + } + } + } + } else { + while (elem = elem[dir2]) { + if (elem.nodeType === 1 || checkNonElements) { + outerCache = elem[expando] || (elem[expando] = {}); + if (skip && nodeName(elem, skip)) { + elem = elem[dir2] || elem; + } else if ((oldCache = outerCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) { + return newCache[2] = oldCache[2]; + } else { + outerCache[key] = newCache; + if (newCache[2] = matcher(elem, context, xml)) { + return true; + } + } + } + } + } + return false; + } + ); + } + function elementMatcher(matchers) { + return matchers.length > 1 ? function(elem, context, xml) { + var i2 = matchers.length; + while (i2--) { + if (!matchers[i2](elem, context, xml)) { + return false; + } + } + return true; + } : matchers[0]; + } + function multipleContexts(selector, contexts, results) { + var i2 = 0, len = contexts.length; + for (; i2 < len; i2++) { + find(selector, contexts[i2], results); + } + return results; + } + function condense(unmatched, map, filter, context, xml) { + var elem, newUnmatched = [], i2 = 0, len = unmatched.length, mapped = map != null; + for (; i2 < len; i2++) { + if (elem = unmatched[i2]) { + if (!filter || filter(elem, context, xml)) { + newUnmatched.push(elem); + if (mapped) { + map.push(i2); + } + } + } + } + return newUnmatched; + } + function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) { + if (postFilter && !postFilter[expando]) { + postFilter = setMatcher(postFilter); + } + if (postFinder && !postFinder[expando]) { + postFinder = setMatcher(postFinder, postSelector); + } + return markFunction(function(seed, results, context, xml) { + var temp, i2, elem, matcherOut, preMap = [], postMap = [], preexisting = results.length, elems = seed || multipleContexts( + selector || "*", + context.nodeType ? [context] : context, + [] + ), matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems; + if (matcher) { + matcherOut = postFinder || (seed ? preFilter : preexisting || postFilter) ? ( + // ...intermediate processing is necessary + [] + ) : ( + // ...otherwise use results directly + results + ); + matcher(matcherIn, matcherOut, context, xml); + } else { + matcherOut = matcherIn; + } + if (postFilter) { + temp = condense(matcherOut, postMap); + postFilter(temp, [], context, xml); + i2 = temp.length; + while (i2--) { + if (elem = temp[i2]) { + matcherOut[postMap[i2]] = !(matcherIn[postMap[i2]] = elem); + } + } + } + if (seed) { + if (postFinder || preFilter) { + if (postFinder) { + temp = []; + i2 = matcherOut.length; + while (i2--) { + if (elem = matcherOut[i2]) { + temp.push(matcherIn[i2] = elem); + } + } + postFinder(null, matcherOut = [], temp, xml); + } + i2 = matcherOut.length; + while (i2--) { + if ((elem = matcherOut[i2]) && (temp = postFinder ? indexOf.call(seed, elem) : preMap[i2]) > -1) { + seed[temp] = !(results[temp] = elem); + } + } + } + } else { + matcherOut = condense( + matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut + ); + if (postFinder) { + postFinder(null, results, matcherOut, xml); + } else { + push2.apply(results, matcherOut); + } + } + }); + } + function matcherFromTokens(tokens) { + var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[tokens[0].type], implicitRelative = leadingRelative || Expr.relative[" "], i2 = leadingRelative ? 1 : 0, matchContext = addCombinator(function(elem) { + return elem === checkContext; + }, implicitRelative, true), matchAnyContext = addCombinator(function(elem) { + return indexOf.call(checkContext, elem) > -1; + }, implicitRelative, true), matchers = [function(elem, context, xml) { + var ret = !leadingRelative && (xml || context != outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml)); + checkContext = null; + return ret; + }]; + for (; i2 < len; i2++) { + if (matcher = Expr.relative[tokens[i2].type]) { + matchers = [addCombinator(elementMatcher(matchers), matcher)]; + } else { + matcher = Expr.filter[tokens[i2].type].apply(null, tokens[i2].matches); + if (matcher[expando]) { + j = ++i2; + for (; j < len; j++) { + if (Expr.relative[tokens[j].type]) { + break; + } + } + return setMatcher( + i2 > 1 && elementMatcher(matchers), + i2 > 1 && toSelector( + // If the preceding token was a descendant combinator, insert an implicit any-element `*` + tokens.slice(0, i2 - 1).concat({ value: tokens[i2 - 2].type === " " ? "*" : "" }) + ).replace(rtrimCSS, "$1"), + matcher, + i2 < j && matcherFromTokens(tokens.slice(i2, j)), + j < len && matcherFromTokens(tokens = tokens.slice(j)), + j < len && toSelector(tokens) + ); + } + matchers.push(matcher); + } + } + return elementMatcher(matchers); + } + function matcherFromGroupMatchers(elementMatchers, setMatchers) { + var bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function(seed, context, xml, results, outermost) { + var elem, j, matcher, matchedCount = 0, i2 = "0", unmatched = seed && [], setMatched = [], contextBackup = outermostContext, elems = seed || byElement && Expr.find.TAG("*", outermost), dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1, len = elems.length; + if (outermost) { + outermostContext = context == document3 || context || outermost; + } + for (; i2 !== len && (elem = elems[i2]) != null; i2++) { + if (byElement && elem) { + j = 0; + if (!context && elem.ownerDocument != document3) { + setDocument(elem); + xml = !documentIsHTML; + } + while (matcher = elementMatchers[j++]) { + if (matcher(elem, context || document3, xml)) { + push2.call(results, elem); + break; + } + } + if (outermost) { + dirruns = dirrunsUnique; + } + } + if (bySet) { + if (elem = !matcher && elem) { + matchedCount--; + } + if (seed) { + unmatched.push(elem); + } + } + } + matchedCount += i2; + if (bySet && i2 !== matchedCount) { + j = 0; + while (matcher = setMatchers[j++]) { + matcher(unmatched, setMatched, context, xml); + } + if (seed) { + if (matchedCount > 0) { + while (i2--) { + if (!(unmatched[i2] || setMatched[i2])) { + setMatched[i2] = pop.call(results); + } + } + } + setMatched = condense(setMatched); + } + push2.apply(results, setMatched); + if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) { + jQuery2.uniqueSort(results); + } + } + if (outermost) { + dirruns = dirrunsUnique; + outermostContext = contextBackup; + } + return unmatched; + }; + return bySet ? markFunction(superMatcher) : superMatcher; + } + function compile(selector, match) { + var i2, setMatchers = [], elementMatchers = [], cached = compilerCache[selector + " "]; + if (!cached) { + if (!match) { + match = tokenize(selector); + } + i2 = match.length; + while (i2--) { + cached = matcherFromTokens(match[i2]); + if (cached[expando]) { + setMatchers.push(cached); + } else { + elementMatchers.push(cached); + } + } + cached = compilerCache( + selector, + matcherFromGroupMatchers(elementMatchers, setMatchers) + ); + cached.selector = selector; + } + return cached; + } + function select(selector, context, results, seed) { + var i2, tokens, token, type, find2, compiled = typeof selector === "function" && selector, match = !seed && tokenize(selector = compiled.selector || selector); + results = results || []; + if (match.length === 1) { + tokens = match[0] = match[0].slice(0); + if (tokens.length > 2 && (token = tokens[0]).type === "ID" && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) { + context = (Expr.find.ID( + token.matches[0].replace(runescape, funescape), + context + ) || [])[0]; + if (!context) { + return results; + } else if (compiled) { + context = context.parentNode; + } + selector = selector.slice(tokens.shift().value.length); + } + i2 = matchExpr.needsContext.test(selector) ? 0 : tokens.length; + while (i2--) { + token = tokens[i2]; + if (Expr.relative[type = token.type]) { + break; + } + if (find2 = Expr.find[type]) { + if (seed = find2( + token.matches[0].replace(runescape, funescape), + rsibling.test(tokens[0].type) && testContext(context.parentNode) || context + )) { + tokens.splice(i2, 1); + selector = seed.length && toSelector(tokens); + if (!selector) { + push2.apply(results, seed); + return results; + } + break; + } + } + } + } + (compiled || compile(selector, match))( + seed, + context, + !documentIsHTML, + results, + !context || rsibling.test(selector) && testContext(context.parentNode) || context + ); + return results; + } + support.sortStable = expando.split("").sort(sortOrder).join("") === expando; + setDocument(); + support.sortDetached = assert(function(el) { + return el.compareDocumentPosition(document3.createElement("fieldset")) & 1; + }); + jQuery2.find = find; + jQuery2.expr[":"] = jQuery2.expr.pseudos; + jQuery2.unique = jQuery2.uniqueSort; + find.compile = compile; + find.select = select; + find.setDocument = setDocument; + find.escape = jQuery2.escapeSelector; + find.getText = jQuery2.text; + find.isXML = jQuery2.isXMLDoc; + find.selectors = jQuery2.expr; + find.support = jQuery2.support; + find.uniqueSort = jQuery2.uniqueSort; + })(); + var dir = function(elem, dir2, until) { + var matched = [], truncate = until !== void 0; + while ((elem = elem[dir2]) && elem.nodeType !== 9) { + if (elem.nodeType === 1) { + if (truncate && jQuery2(elem).is(until)) { + break; + } + matched.push(elem); + } + } + return matched; + }; + var siblings = function(n, elem) { + var matched = []; + for (; n; n = n.nextSibling) { + if (n.nodeType === 1 && n !== elem) { + matched.push(n); + } + } + return matched; + }; + var rneedsContext = jQuery2.expr.match.needsContext; + var rsingleTag = /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i; + function winnow(elements, qualifier, not) { + if (isFunction(qualifier)) { + return jQuery2.grep(elements, function(elem, i) { + return !!qualifier.call(elem, i, elem) !== not; + }); + } + if (qualifier.nodeType) { + return jQuery2.grep(elements, function(elem) { + return elem === qualifier !== not; + }); + } + if (typeof qualifier !== "string") { + return jQuery2.grep(elements, function(elem) { + return indexOf.call(qualifier, elem) > -1 !== not; + }); + } + return jQuery2.filter(qualifier, elements, not); + } + jQuery2.filter = function(expr, elems, not) { + var elem = elems[0]; + if (not) { + expr = ":not(" + expr + ")"; + } + if (elems.length === 1 && elem.nodeType === 1) { + return jQuery2.find.matchesSelector(elem, expr) ? [elem] : []; + } + return jQuery2.find.matches(expr, jQuery2.grep(elems, function(elem2) { + return elem2.nodeType === 1; + })); + }; + jQuery2.fn.extend({ + find: function(selector) { + var i, ret, len = this.length, self = this; + if (typeof selector !== "string") { + return this.pushStack(jQuery2(selector).filter(function() { + for (i = 0; i < len; i++) { + if (jQuery2.contains(self[i], this)) { + return true; + } + } + })); + } + ret = this.pushStack([]); + for (i = 0; i < len; i++) { + jQuery2.find(selector, self[i], ret); + } + return len > 1 ? jQuery2.uniqueSort(ret) : ret; + }, + filter: function(selector) { + return this.pushStack(winnow(this, selector || [], false)); + }, + not: function(selector) { + return this.pushStack(winnow(this, selector || [], true)); + }, + is: function(selector) { + return !!winnow( + this, + // If this is a positional/relative selector, check membership in the returned set + // so $("p:first").is("p:last") won't return true for a doc with two "p". + typeof selector === "string" && rneedsContext.test(selector) ? jQuery2(selector) : selector || [], + false + ).length; + } + }); + var rootjQuery, rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, init = jQuery2.fn.init = function(selector, context, root) { + var match, elem; + if (!selector) { + return this; + } + root = root || rootjQuery; + if (typeof selector === "string") { + if (selector[0] === "<" && selector[selector.length - 1] === ">" && selector.length >= 3) { + match = [null, selector, null]; + } else { + match = rquickExpr.exec(selector); + } + if (match && (match[1] || !context)) { + if (match[1]) { + context = context instanceof jQuery2 ? context[0] : context; + jQuery2.merge(this, jQuery2.parseHTML( + match[1], + context && context.nodeType ? context.ownerDocument || context : document2, + true + )); + if (rsingleTag.test(match[1]) && jQuery2.isPlainObject(context)) { + for (match in context) { + if (isFunction(this[match])) { + this[match](context[match]); + } else { + this.attr(match, context[match]); + } + } + } + return this; + } else { + elem = document2.getElementById(match[2]); + if (elem) { + this[0] = elem; + this.length = 1; + } + return this; + } + } else if (!context || context.jquery) { + return (context || root).find(selector); + } else { + return this.constructor(context).find(selector); + } + } else if (selector.nodeType) { + this[0] = selector; + this.length = 1; + return this; + } else if (isFunction(selector)) { + return root.ready !== void 0 ? root.ready(selector) : ( + // Execute immediately if ready is not present + selector(jQuery2) + ); + } + return jQuery2.makeArray(selector, this); + }; + init.prototype = jQuery2.fn; + rootjQuery = jQuery2(document2); + var rparentsprev = /^(?:parents|prev(?:Until|All))/, guaranteedUnique = { + children: true, + contents: true, + next: true, + prev: true + }; + jQuery2.fn.extend({ + has: function(target) { + var targets = jQuery2(target, this), l = targets.length; + return this.filter(function() { + var i = 0; + for (; i < l; i++) { + if (jQuery2.contains(this, targets[i])) { + return true; + } + } + }); + }, + closest: function(selectors, context) { + var cur, i = 0, l = this.length, matched = [], targets = typeof selectors !== "string" && jQuery2(selectors); + if (!rneedsContext.test(selectors)) { + for (; i < l; i++) { + for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) { + if (cur.nodeType < 11 && (targets ? targets.index(cur) > -1 : ( + // Don't pass non-elements to jQuery#find + cur.nodeType === 1 && jQuery2.find.matchesSelector(cur, selectors) + ))) { + matched.push(cur); + break; + } + } + } + } + return this.pushStack(matched.length > 1 ? jQuery2.uniqueSort(matched) : matched); + }, + // Determine the position of an element within the set + index: function(elem) { + if (!elem) { + return this[0] && this[0].parentNode ? this.first().prevAll().length : -1; + } + if (typeof elem === "string") { + return indexOf.call(jQuery2(elem), this[0]); + } + return indexOf.call( + this, + // If it receives a jQuery object, the first element is used + elem.jquery ? elem[0] : elem + ); + }, + add: function(selector, context) { + return this.pushStack( + jQuery2.uniqueSort( + jQuery2.merge(this.get(), jQuery2(selector, context)) + ) + ); + }, + addBack: function(selector) { + return this.add( + selector == null ? this.prevObject : this.prevObject.filter(selector) + ); + } + }); + function sibling(cur, dir2) { + while ((cur = cur[dir2]) && cur.nodeType !== 1) { + } + return cur; + } + jQuery2.each({ + parent: function(elem) { + var parent = elem.parentNode; + return parent && parent.nodeType !== 11 ? parent : null; + }, + parents: function(elem) { + return dir(elem, "parentNode"); + }, + parentsUntil: function(elem, _i, until) { + return dir(elem, "parentNode", until); + }, + next: function(elem) { + return sibling(elem, "nextSibling"); + }, + prev: function(elem) { + return sibling(elem, "previousSibling"); + }, + nextAll: function(elem) { + return dir(elem, "nextSibling"); + }, + prevAll: function(elem) { + return dir(elem, "previousSibling"); + }, + nextUntil: function(elem, _i, until) { + return dir(elem, "nextSibling", until); + }, + prevUntil: function(elem, _i, until) { + return dir(elem, "previousSibling", until); + }, + siblings: function(elem) { + return siblings((elem.parentNode || {}).firstChild, elem); + }, + children: function(elem) { + return siblings(elem.firstChild); + }, + contents: function(elem) { + if (elem.contentDocument != null && // Support: IE 11+ + // elements with no `data` attribute has an object + // `contentDocument` with a `null` prototype. + getProto(elem.contentDocument)) { + return elem.contentDocument; + } + if (nodeName(elem, "template")) { + elem = elem.content || elem; + } + return jQuery2.merge([], elem.childNodes); + } + }, function(name, fn) { + jQuery2.fn[name] = function(until, selector) { + var matched = jQuery2.map(this, fn, until); + if (name.slice(-5) !== "Until") { + selector = until; + } + if (selector && typeof selector === "string") { + matched = jQuery2.filter(selector, matched); + } + if (this.length > 1) { + if (!guaranteedUnique[name]) { + jQuery2.uniqueSort(matched); + } + if (rparentsprev.test(name)) { + matched.reverse(); + } + } + return this.pushStack(matched); + }; + }); + var rnothtmlwhite = /[^\x20\t\r\n\f]+/g; + function createOptions(options) { + var object = {}; + jQuery2.each(options.match(rnothtmlwhite) || [], function(_, flag) { + object[flag] = true; + }); + return object; + } + jQuery2.Callbacks = function(options) { + options = typeof options === "string" ? createOptions(options) : jQuery2.extend({}, options); + var firing, memory, fired, locked, list = [], queue = [], firingIndex = -1, fire = function() { + locked = locked || options.once; + fired = firing = true; + for (; queue.length; firingIndex = -1) { + memory = queue.shift(); + while (++firingIndex < list.length) { + if (list[firingIndex].apply(memory[0], memory[1]) === false && options.stopOnFalse) { + firingIndex = list.length; + memory = false; + } + } + } + if (!options.memory) { + memory = false; + } + firing = false; + if (locked) { + if (memory) { + list = []; + } else { + list = ""; + } + } + }, self = { + // Add a callback or a collection of callbacks to the list + add: function() { + if (list) { + if (memory && !firing) { + firingIndex = list.length - 1; + queue.push(memory); + } + (function add(args) { + jQuery2.each(args, function(_, arg) { + if (isFunction(arg)) { + if (!options.unique || !self.has(arg)) { + list.push(arg); + } + } else if (arg && arg.length && toType(arg) !== "string") { + add(arg); + } + }); + })(arguments); + if (memory && !firing) { + fire(); + } + } + return this; + }, + // Remove a callback from the list + remove: function() { + jQuery2.each(arguments, function(_, arg) { + var index; + while ((index = jQuery2.inArray(arg, list, index)) > -1) { + list.splice(index, 1); + if (index <= firingIndex) { + firingIndex--; + } + } + }); + return this; + }, + // Check if a given callback is in the list. + // If no argument is given, return whether or not list has callbacks attached. + has: function(fn) { + return fn ? jQuery2.inArray(fn, list) > -1 : list.length > 0; + }, + // Remove all callbacks from the list + empty: function() { + if (list) { + list = []; + } + return this; + }, + // Disable .fire and .add + // Abort any current/pending executions + // Clear all callbacks and values + disable: function() { + locked = queue = []; + list = memory = ""; + return this; + }, + disabled: function() { + return !list; + }, + // Disable .fire + // Also disable .add unless we have memory (since it would have no effect) + // Abort any pending executions + lock: function() { + locked = queue = []; + if (!memory && !firing) { + list = memory = ""; + } + return this; + }, + locked: function() { + return !!locked; + }, + // Call all callbacks with the given context and arguments + fireWith: function(context, args) { + if (!locked) { + args = args || []; + args = [context, args.slice ? args.slice() : args]; + queue.push(args); + if (!firing) { + fire(); + } + } + return this; + }, + // Call all the callbacks with the given arguments + fire: function() { + self.fireWith(this, arguments); + return this; + }, + // To know if the callbacks have already been called at least once + fired: function() { + return !!fired; + } + }; + return self; + }; + function Identity(v) { + return v; + } + function Thrower(ex) { + throw ex; + } + function adoptValue(value, resolve, reject, noValue) { + var method; + try { + if (value && isFunction(method = value.promise)) { + method.call(value).done(resolve).fail(reject); + } else if (value && isFunction(method = value.then)) { + method.call(value, resolve, reject); + } else { + resolve.apply(void 0, [value].slice(noValue)); + } + } catch (value2) { + reject.apply(void 0, [value2]); + } + } + jQuery2.extend({ + Deferred: function(func) { + var tuples = [ + // action, add listener, callbacks, + // ... .then handlers, argument index, [final state] + [ + "notify", + "progress", + jQuery2.Callbacks("memory"), + jQuery2.Callbacks("memory"), + 2 + ], + [ + "resolve", + "done", + jQuery2.Callbacks("once memory"), + jQuery2.Callbacks("once memory"), + 0, + "resolved" + ], + [ + "reject", + "fail", + jQuery2.Callbacks("once memory"), + jQuery2.Callbacks("once memory"), + 1, + "rejected" + ] + ], state = "pending", promise = { + state: function() { + return state; + }, + always: function() { + deferred.done(arguments).fail(arguments); + return this; + }, + "catch": function(fn) { + return promise.then(null, fn); + }, + // Keep pipe for back-compat + pipe: function() { + var fns = arguments; + return jQuery2.Deferred(function(newDefer) { + jQuery2.each(tuples, function(_i, tuple) { + var fn = isFunction(fns[tuple[4]]) && fns[tuple[4]]; + deferred[tuple[1]](function() { + var returned = fn && fn.apply(this, arguments); + if (returned && isFunction(returned.promise)) { + returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject); + } else { + newDefer[tuple[0] + "With"]( + this, + fn ? [returned] : arguments + ); + } + }); + }); + fns = null; + }).promise(); + }, + then: function(onFulfilled, onRejected, onProgress) { + var maxDepth = 0; + function resolve(depth, deferred2, handler, special) { + return function() { + var that = this, args = arguments, mightThrow = function() { + var returned, then; + if (depth < maxDepth) { + return; + } + returned = handler.apply(that, args); + if (returned === deferred2.promise()) { + throw new TypeError("Thenable self-resolution"); + } + then = returned && // Support: Promises/A+ section 2.3.4 + // https://promisesaplus.com/#point-64 + // Only check objects and functions for thenability + (typeof returned === "object" || typeof returned === "function") && returned.then; + if (isFunction(then)) { + if (special) { + then.call( + returned, + resolve(maxDepth, deferred2, Identity, special), + resolve(maxDepth, deferred2, Thrower, special) + ); + } else { + maxDepth++; + then.call( + returned, + resolve(maxDepth, deferred2, Identity, special), + resolve(maxDepth, deferred2, Thrower, special), + resolve( + maxDepth, + deferred2, + Identity, + deferred2.notifyWith + ) + ); + } + } else { + if (handler !== Identity) { + that = void 0; + args = [returned]; + } + (special || deferred2.resolveWith)(that, args); + } + }, process = special ? mightThrow : function() { + try { + mightThrow(); + } catch (e) { + if (jQuery2.Deferred.exceptionHook) { + jQuery2.Deferred.exceptionHook( + e, + process.error + ); + } + if (depth + 1 >= maxDepth) { + if (handler !== Thrower) { + that = void 0; + args = [e]; + } + deferred2.rejectWith(that, args); + } + } + }; + if (depth) { + process(); + } else { + if (jQuery2.Deferred.getErrorHook) { + process.error = jQuery2.Deferred.getErrorHook(); + } else if (jQuery2.Deferred.getStackHook) { + process.error = jQuery2.Deferred.getStackHook(); + } + window2.setTimeout(process); + } + }; + } + return jQuery2.Deferred(function(newDefer) { + tuples[0][3].add( + resolve( + 0, + newDefer, + isFunction(onProgress) ? onProgress : Identity, + newDefer.notifyWith + ) + ); + tuples[1][3].add( + resolve( + 0, + newDefer, + isFunction(onFulfilled) ? onFulfilled : Identity + ) + ); + tuples[2][3].add( + resolve( + 0, + newDefer, + isFunction(onRejected) ? onRejected : Thrower + ) + ); + }).promise(); + }, + // Get a promise for this deferred + // If obj is provided, the promise aspect is added to the object + promise: function(obj) { + return obj != null ? jQuery2.extend(obj, promise) : promise; + } + }, deferred = {}; + jQuery2.each(tuples, function(i, tuple) { + var list = tuple[2], stateString = tuple[5]; + promise[tuple[1]] = list.add; + if (stateString) { + list.add( + function() { + state = stateString; + }, + // rejected_callbacks.disable + // fulfilled_callbacks.disable + tuples[3 - i][2].disable, + // rejected_handlers.disable + // fulfilled_handlers.disable + tuples[3 - i][3].disable, + // progress_callbacks.lock + tuples[0][2].lock, + // progress_handlers.lock + tuples[0][3].lock + ); + } + list.add(tuple[3].fire); + deferred[tuple[0]] = function() { + deferred[tuple[0] + "With"](this === deferred ? void 0 : this, arguments); + return this; + }; + deferred[tuple[0] + "With"] = list.fireWith; + }); + promise.promise(deferred); + if (func) { + func.call(deferred, deferred); + } + return deferred; + }, + // Deferred helper + when: function(singleValue) { + var remaining = arguments.length, i = remaining, resolveContexts = Array(i), resolveValues = slice.call(arguments), primary = jQuery2.Deferred(), updateFunc = function(i2) { + return function(value) { + resolveContexts[i2] = this; + resolveValues[i2] = arguments.length > 1 ? slice.call(arguments) : value; + if (!--remaining) { + primary.resolveWith(resolveContexts, resolveValues); + } + }; + }; + if (remaining <= 1) { + adoptValue( + singleValue, + primary.done(updateFunc(i)).resolve, + primary.reject, + !remaining + ); + if (primary.state() === "pending" || isFunction(resolveValues[i] && resolveValues[i].then)) { + return primary.then(); + } + } + while (i--) { + adoptValue(resolveValues[i], updateFunc(i), primary.reject); + } + return primary.promise(); + } + }); + var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; + jQuery2.Deferred.exceptionHook = function(error, asyncError) { + if (window2.console && window2.console.warn && error && rerrorNames.test(error.name)) { + window2.console.warn( + "jQuery.Deferred exception: " + error.message, + error.stack, + asyncError + ); + } + }; + jQuery2.readyException = function(error) { + window2.setTimeout(function() { + throw error; + }); + }; + var readyList = jQuery2.Deferred(); + jQuery2.fn.ready = function(fn) { + readyList.then(fn).catch(function(error) { + jQuery2.readyException(error); + }); + return this; + }; + jQuery2.extend({ + // Is the DOM ready to be used? Set to true once it occurs. + isReady: false, + // A counter to track how many items to wait for before + // the ready event fires. See trac-6781 + readyWait: 1, + // Handle when the DOM is ready + ready: function(wait) { + if (wait === true ? --jQuery2.readyWait : jQuery2.isReady) { + return; + } + jQuery2.isReady = true; + if (wait !== true && --jQuery2.readyWait > 0) { + return; + } + readyList.resolveWith(document2, [jQuery2]); + } + }); + jQuery2.ready.then = readyList.then; + function completed() { + document2.removeEventListener("DOMContentLoaded", completed); + window2.removeEventListener("load", completed); + jQuery2.ready(); + } + if (document2.readyState === "complete" || document2.readyState !== "loading" && !document2.documentElement.doScroll) { + window2.setTimeout(jQuery2.ready); + } else { + document2.addEventListener("DOMContentLoaded", completed); + window2.addEventListener("load", completed); + } + var access = function(elems, fn, key, value, chainable, emptyGet, raw) { + var i = 0, len = elems.length, bulk = key == null; + if (toType(key) === "object") { + chainable = true; + for (i in key) { + access(elems, fn, i, key[i], true, emptyGet, raw); + } + } else if (value !== void 0) { + chainable = true; + if (!isFunction(value)) { + raw = true; + } + if (bulk) { + if (raw) { + fn.call(elems, value); + fn = null; + } else { + bulk = fn; + fn = function(elem, _key, value2) { + return bulk.call(jQuery2(elem), value2); + }; + } + } + if (fn) { + for (; i < len; i++) { + fn( + elems[i], + key, + raw ? value : value.call(elems[i], i, fn(elems[i], key)) + ); + } + } + } + if (chainable) { + return elems; + } + if (bulk) { + return fn.call(elems); + } + return len ? fn(elems[0], key) : emptyGet; + }; + var rmsPrefix = /^-ms-/, rdashAlpha = /-([a-z])/g; + function fcamelCase(_all, letter) { + return letter.toUpperCase(); + } + function camelCase(string) { + return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase); + } + var acceptData = function(owner) { + return owner.nodeType === 1 || owner.nodeType === 9 || !+owner.nodeType; + }; + function Data() { + this.expando = jQuery2.expando + Data.uid++; + } + Data.uid = 1; + Data.prototype = { + cache: function(owner) { + var value = owner[this.expando]; + if (!value) { + value = {}; + if (acceptData(owner)) { + if (owner.nodeType) { + owner[this.expando] = value; + } else { + Object.defineProperty(owner, this.expando, { + value, + configurable: true + }); + } + } + } + return value; + }, + set: function(owner, data, value) { + var prop, cache = this.cache(owner); + if (typeof data === "string") { + cache[camelCase(data)] = value; + } else { + for (prop in data) { + cache[camelCase(prop)] = data[prop]; + } + } + return cache; + }, + get: function(owner, key) { + return key === void 0 ? this.cache(owner) : ( + // Always use camelCase key (gh-2257) + owner[this.expando] && owner[this.expando][camelCase(key)] + ); + }, + access: function(owner, key, value) { + if (key === void 0 || key && typeof key === "string" && value === void 0) { + return this.get(owner, key); + } + this.set(owner, key, value); + return value !== void 0 ? value : key; + }, + remove: function(owner, key) { + var i, cache = owner[this.expando]; + if (cache === void 0) { + return; + } + if (key !== void 0) { + if (Array.isArray(key)) { + key = key.map(camelCase); + } else { + key = camelCase(key); + key = key in cache ? [key] : key.match(rnothtmlwhite) || []; + } + i = key.length; + while (i--) { + delete cache[key[i]]; + } + } + if (key === void 0 || jQuery2.isEmptyObject(cache)) { + if (owner.nodeType) { + owner[this.expando] = void 0; + } else { + delete owner[this.expando]; + } + } + }, + hasData: function(owner) { + var cache = owner[this.expando]; + return cache !== void 0 && !jQuery2.isEmptyObject(cache); + } + }; + var dataPriv = new Data(); + var dataUser = new Data(); + var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, rmultiDash = /[A-Z]/g; + function getData(data) { + if (data === "true") { + return true; + } + if (data === "false") { + return false; + } + if (data === "null") { + return null; + } + if (data === +data + "") { + return +data; + } + if (rbrace.test(data)) { + return JSON.parse(data); + } + return data; + } + function dataAttr(elem, key, data) { + var name; + if (data === void 0 && elem.nodeType === 1) { + name = "data-" + key.replace(rmultiDash, "-$&").toLowerCase(); + data = elem.getAttribute(name); + if (typeof data === "string") { + try { + data = getData(data); + } catch (e) { + } + dataUser.set(elem, key, data); + } else { + data = void 0; + } + } + return data; + } + jQuery2.extend({ + hasData: function(elem) { + return dataUser.hasData(elem) || dataPriv.hasData(elem); + }, + data: function(elem, name, data) { + return dataUser.access(elem, name, data); + }, + removeData: function(elem, name) { + dataUser.remove(elem, name); + }, + // TODO: Now that all calls to _data and _removeData have been replaced + // with direct calls to dataPriv methods, these can be deprecated. + _data: function(elem, name, data) { + return dataPriv.access(elem, name, data); + }, + _removeData: function(elem, name) { + dataPriv.remove(elem, name); + } + }); + jQuery2.fn.extend({ + data: function(key, value) { + var i, name, data, elem = this[0], attrs = elem && elem.attributes; + if (key === void 0) { + if (this.length) { + data = dataUser.get(elem); + if (elem.nodeType === 1 && !dataPriv.get(elem, "hasDataAttrs")) { + i = attrs.length; + while (i--) { + if (attrs[i]) { + name = attrs[i].name; + if (name.indexOf("data-") === 0) { + name = camelCase(name.slice(5)); + dataAttr(elem, name, data[name]); + } + } + } + dataPriv.set(elem, "hasDataAttrs", true); + } + } + return data; + } + if (typeof key === "object") { + return this.each(function() { + dataUser.set(this, key); + }); + } + return access(this, function(value2) { + var data2; + if (elem && value2 === void 0) { + data2 = dataUser.get(elem, key); + if (data2 !== void 0) { + return data2; + } + data2 = dataAttr(elem, key); + if (data2 !== void 0) { + return data2; + } + return; + } + this.each(function() { + dataUser.set(this, key, value2); + }); + }, null, value, arguments.length > 1, null, true); + }, + removeData: function(key) { + return this.each(function() { + dataUser.remove(this, key); + }); + } + }); + jQuery2.extend({ + queue: function(elem, type, data) { + var queue; + if (elem) { + type = (type || "fx") + "queue"; + queue = dataPriv.get(elem, type); + if (data) { + if (!queue || Array.isArray(data)) { + queue = dataPriv.access(elem, type, jQuery2.makeArray(data)); + } else { + queue.push(data); + } + } + return queue || []; + } + }, + dequeue: function(elem, type) { + type = type || "fx"; + var queue = jQuery2.queue(elem, type), startLength = queue.length, fn = queue.shift(), hooks = jQuery2._queueHooks(elem, type), next = function() { + jQuery2.dequeue(elem, type); + }; + if (fn === "inprogress") { + fn = queue.shift(); + startLength--; + } + if (fn) { + if (type === "fx") { + queue.unshift("inprogress"); + } + delete hooks.stop; + fn.call(elem, next, hooks); + } + if (!startLength && hooks) { + hooks.empty.fire(); + } + }, + // Not public - generate a queueHooks object, or return the current one + _queueHooks: function(elem, type) { + var key = type + "queueHooks"; + return dataPriv.get(elem, key) || dataPriv.access(elem, key, { + empty: jQuery2.Callbacks("once memory").add(function() { + dataPriv.remove(elem, [type + "queue", key]); + }) + }); + } + }); + jQuery2.fn.extend({ + queue: function(type, data) { + var setter = 2; + if (typeof type !== "string") { + data = type; + type = "fx"; + setter--; + } + if (arguments.length < setter) { + return jQuery2.queue(this[0], type); + } + return data === void 0 ? this : this.each(function() { + var queue = jQuery2.queue(this, type, data); + jQuery2._queueHooks(this, type); + if (type === "fx" && queue[0] !== "inprogress") { + jQuery2.dequeue(this, type); + } + }); + }, + dequeue: function(type) { + return this.each(function() { + jQuery2.dequeue(this, type); + }); + }, + clearQueue: function(type) { + return this.queue(type || "fx", []); + }, + // Get a promise resolved when queues of a certain type + // are emptied (fx is the type by default) + promise: function(type, obj) { + var tmp, count = 1, defer = jQuery2.Deferred(), elements = this, i = this.length, resolve = function() { + if (!--count) { + defer.resolveWith(elements, [elements]); + } + }; + if (typeof type !== "string") { + obj = type; + type = void 0; + } + type = type || "fx"; + while (i--) { + tmp = dataPriv.get(elements[i], type + "queueHooks"); + if (tmp && tmp.empty) { + count++; + tmp.empty.add(resolve); + } + } + resolve(); + return defer.promise(obj); + } + }); + var pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source; + var rcssNum = new RegExp("^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i"); + var cssExpand = ["Top", "Right", "Bottom", "Left"]; + var documentElement = document2.documentElement; + var isAttached = function(elem) { + return jQuery2.contains(elem.ownerDocument, elem); + }, composed = { composed: true }; + if (documentElement.getRootNode) { + isAttached = function(elem) { + return jQuery2.contains(elem.ownerDocument, elem) || elem.getRootNode(composed) === elem.ownerDocument; + }; + } + var isHiddenWithinTree = function(elem, el) { + elem = el || elem; + return elem.style.display === "none" || elem.style.display === "" && // Otherwise, check computed style + // Support: Firefox <=43 - 45 + // Disconnected elements can have computed display: none, so first confirm that elem is + // in the document. + isAttached(elem) && jQuery2.css(elem, "display") === "none"; + }; + function adjustCSS(elem, prop, valueParts, tween) { + var adjusted, scale, maxIterations = 20, currentValue = tween ? function() { + return tween.cur(); + } : function() { + return jQuery2.css(elem, prop, ""); + }, initial = currentValue(), unit = valueParts && valueParts[3] || (jQuery2.cssNumber[prop] ? "" : "px"), initialInUnit = elem.nodeType && (jQuery2.cssNumber[prop] || unit !== "px" && +initial) && rcssNum.exec(jQuery2.css(elem, prop)); + if (initialInUnit && initialInUnit[3] !== unit) { + initial = initial / 2; + unit = unit || initialInUnit[3]; + initialInUnit = +initial || 1; + while (maxIterations--) { + jQuery2.style(elem, prop, initialInUnit + unit); + if ((1 - scale) * (1 - (scale = currentValue() / initial || 0.5)) <= 0) { + maxIterations = 0; + } + initialInUnit = initialInUnit / scale; + } + initialInUnit = initialInUnit * 2; + jQuery2.style(elem, prop, initialInUnit + unit); + valueParts = valueParts || []; + } + if (valueParts) { + initialInUnit = +initialInUnit || +initial || 0; + adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2]; + if (tween) { + tween.unit = unit; + tween.start = initialInUnit; + tween.end = adjusted; + } + } + return adjusted; + } + var defaultDisplayMap = {}; + function getDefaultDisplay(elem) { + var temp, doc = elem.ownerDocument, nodeName2 = elem.nodeName, display = defaultDisplayMap[nodeName2]; + if (display) { + return display; + } + temp = doc.body.appendChild(doc.createElement(nodeName2)); + display = jQuery2.css(temp, "display"); + temp.parentNode.removeChild(temp); + if (display === "none") { + display = "block"; + } + defaultDisplayMap[nodeName2] = display; + return display; + } + function showHide(elements, show) { + var display, elem, values = [], index = 0, length = elements.length; + for (; index < length; index++) { + elem = elements[index]; + if (!elem.style) { + continue; + } + display = elem.style.display; + if (show) { + if (display === "none") { + values[index] = dataPriv.get(elem, "display") || null; + if (!values[index]) { + elem.style.display = ""; + } + } + if (elem.style.display === "" && isHiddenWithinTree(elem)) { + values[index] = getDefaultDisplay(elem); + } + } else { + if (display !== "none") { + values[index] = "none"; + dataPriv.set(elem, "display", display); + } + } + } + for (index = 0; index < length; index++) { + if (values[index] != null) { + elements[index].style.display = values[index]; + } + } + return elements; + } + jQuery2.fn.extend({ + show: function() { + return showHide(this, true); + }, + hide: function() { + return showHide(this); + }, + toggle: function(state) { + if (typeof state === "boolean") { + return state ? this.show() : this.hide(); + } + return this.each(function() { + if (isHiddenWithinTree(this)) { + jQuery2(this).show(); + } else { + jQuery2(this).hide(); + } + }); + } + }); + var rcheckableType = /^(?:checkbox|radio)$/i; + var rtagName = /<([a-z][^\/\0>\x20\t\r\n\f]*)/i; + var rscriptType = /^$|^module$|\/(?:java|ecma)script/i; + (function() { + var fragment = document2.createDocumentFragment(), div = fragment.appendChild(document2.createElement("div")), input = document2.createElement("input"); + input.setAttribute("type", "radio"); + input.setAttribute("checked", "checked"); + input.setAttribute("name", "t"); + div.appendChild(input); + support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked; + div.innerHTML = ""; + support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue; + div.innerHTML = ""; + support.option = !!div.lastChild; + })(); + var wrapMap = { + // XHTML parsers do not magically insert elements in the + // same way that tag soup parsers do. So we cannot shorten + // this by omitting or other required elements. + thead: [1, "", "
"], + col: [2, "", "
"], + tr: [2, "", "
"], + td: [3, "", "
"], + _default: [0, "", ""] + }; + wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; + wrapMap.th = wrapMap.td; + if (!support.option) { + wrapMap.optgroup = wrapMap.option = [1, ""]; + } + function getAll(context, tag) { + var ret; + if (typeof context.getElementsByTagName !== "undefined") { + ret = context.getElementsByTagName(tag || "*"); + } else if (typeof context.querySelectorAll !== "undefined") { + ret = context.querySelectorAll(tag || "*"); + } else { + ret = []; + } + if (tag === void 0 || tag && nodeName(context, tag)) { + return jQuery2.merge([context], ret); + } + return ret; + } + function setGlobalEval(elems, refElements) { + var i = 0, l = elems.length; + for (; i < l; i++) { + dataPriv.set( + elems[i], + "globalEval", + !refElements || dataPriv.get(refElements[i], "globalEval") + ); + } + } + var rhtml = /<|&#?\w+;/; + function buildFragment(elems, context, scripts, selection, ignored) { + var elem, tmp, tag, wrap, attached, j, fragment = context.createDocumentFragment(), nodes = [], i = 0, l = elems.length; + for (; i < l; i++) { + elem = elems[i]; + if (elem || elem === 0) { + if (toType(elem) === "object") { + jQuery2.merge(nodes, elem.nodeType ? [elem] : elem); + } else if (!rhtml.test(elem)) { + nodes.push(context.createTextNode(elem)); + } else { + tmp = tmp || fragment.appendChild(context.createElement("div")); + tag = (rtagName.exec(elem) || ["", ""])[1].toLowerCase(); + wrap = wrapMap[tag] || wrapMap._default; + tmp.innerHTML = wrap[1] + jQuery2.htmlPrefilter(elem) + wrap[2]; + j = wrap[0]; + while (j--) { + tmp = tmp.lastChild; + } + jQuery2.merge(nodes, tmp.childNodes); + tmp = fragment.firstChild; + tmp.textContent = ""; + } + } + } + fragment.textContent = ""; + i = 0; + while (elem = nodes[i++]) { + if (selection && jQuery2.inArray(elem, selection) > -1) { + if (ignored) { + ignored.push(elem); + } + continue; + } + attached = isAttached(elem); + tmp = getAll(fragment.appendChild(elem), "script"); + if (attached) { + setGlobalEval(tmp); + } + if (scripts) { + j = 0; + while (elem = tmp[j++]) { + if (rscriptType.test(elem.type || "")) { + scripts.push(elem); + } + } + } + } + return fragment; + } + var rtypenamespace = /^([^.]*)(?:\.(.+)|)/; + function returnTrue() { + return true; + } + function returnFalse() { + return false; + } + function on(elem, types, selector, data, fn, one) { + var origFn, type; + if (typeof types === "object") { + if (typeof selector !== "string") { + data = data || selector; + selector = void 0; + } + for (type in types) { + on(elem, type, selector, data, types[type], one); + } + return elem; + } + if (data == null && fn == null) { + fn = selector; + data = selector = void 0; + } else if (fn == null) { + if (typeof selector === "string") { + fn = data; + data = void 0; + } else { + fn = data; + data = selector; + selector = void 0; + } + } + if (fn === false) { + fn = returnFalse; + } else if (!fn) { + return elem; + } + if (one === 1) { + origFn = fn; + fn = function(event) { + jQuery2().off(event); + return origFn.apply(this, arguments); + }; + fn.guid = origFn.guid || (origFn.guid = jQuery2.guid++); + } + return elem.each(function() { + jQuery2.event.add(this, types, fn, data, selector); + }); + } + jQuery2.event = { + global: {}, + add: function(elem, types, handler, data, selector) { + var handleObjIn, eventHandle, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.get(elem); + if (!acceptData(elem)) { + return; + } + if (handler.handler) { + handleObjIn = handler; + handler = handleObjIn.handler; + selector = handleObjIn.selector; + } + if (selector) { + jQuery2.find.matchesSelector(documentElement, selector); + } + if (!handler.guid) { + handler.guid = jQuery2.guid++; + } + if (!(events = elemData.events)) { + events = elemData.events = /* @__PURE__ */ Object.create(null); + } + if (!(eventHandle = elemData.handle)) { + eventHandle = elemData.handle = function(e) { + return typeof jQuery2 !== "undefined" && jQuery2.event.triggered !== e.type ? jQuery2.event.dispatch.apply(elem, arguments) : void 0; + }; + } + types = (types || "").match(rnothtmlwhite) || [""]; + t = types.length; + while (t--) { + tmp = rtypenamespace.exec(types[t]) || []; + type = origType = tmp[1]; + namespaces = (tmp[2] || "").split(".").sort(); + if (!type) { + continue; + } + special = jQuery2.event.special[type] || {}; + type = (selector ? special.delegateType : special.bindType) || type; + special = jQuery2.event.special[type] || {}; + handleObj = jQuery2.extend({ + type, + origType, + data, + handler, + guid: handler.guid, + selector, + needsContext: selector && jQuery2.expr.match.needsContext.test(selector), + namespace: namespaces.join(".") + }, handleObjIn); + if (!(handlers = events[type])) { + handlers = events[type] = []; + handlers.delegateCount = 0; + if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) { + if (elem.addEventListener) { + elem.addEventListener(type, eventHandle); + } + } + } + if (special.add) { + special.add.call(elem, handleObj); + if (!handleObj.handler.guid) { + handleObj.handler.guid = handler.guid; + } + } + if (selector) { + handlers.splice(handlers.delegateCount++, 0, handleObj); + } else { + handlers.push(handleObj); + } + jQuery2.event.global[type] = true; + } + }, + // Detach an event or set of events from an element + remove: function(elem, types, handler, selector, mappedTypes) { + var j, origCount, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.hasData(elem) && dataPriv.get(elem); + if (!elemData || !(events = elemData.events)) { + return; + } + types = (types || "").match(rnothtmlwhite) || [""]; + t = types.length; + while (t--) { + tmp = rtypenamespace.exec(types[t]) || []; + type = origType = tmp[1]; + namespaces = (tmp[2] || "").split(".").sort(); + if (!type) { + for (type in events) { + jQuery2.event.remove(elem, type + types[t], handler, selector, true); + } + continue; + } + special = jQuery2.event.special[type] || {}; + type = (selector ? special.delegateType : special.bindType) || type; + handlers = events[type] || []; + tmp = tmp[2] && new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)"); + origCount = j = handlers.length; + while (j--) { + handleObj = handlers[j]; + if ((mappedTypes || origType === handleObj.origType) && (!handler || handler.guid === handleObj.guid) && (!tmp || tmp.test(handleObj.namespace)) && (!selector || selector === handleObj.selector || selector === "**" && handleObj.selector)) { + handlers.splice(j, 1); + if (handleObj.selector) { + handlers.delegateCount--; + } + if (special.remove) { + special.remove.call(elem, handleObj); + } + } + } + if (origCount && !handlers.length) { + if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) { + jQuery2.removeEvent(elem, type, elemData.handle); + } + delete events[type]; + } + } + if (jQuery2.isEmptyObject(events)) { + dataPriv.remove(elem, "handle events"); + } + }, + dispatch: function(nativeEvent) { + var i, j, ret, matched, handleObj, handlerQueue, args = new Array(arguments.length), event = jQuery2.event.fix(nativeEvent), handlers = (dataPriv.get(this, "events") || /* @__PURE__ */ Object.create(null))[event.type] || [], special = jQuery2.event.special[event.type] || {}; + args[0] = event; + for (i = 1; i < arguments.length; i++) { + args[i] = arguments[i]; + } + event.delegateTarget = this; + if (special.preDispatch && special.preDispatch.call(this, event) === false) { + return; + } + handlerQueue = jQuery2.event.handlers.call(this, event, handlers); + i = 0; + while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) { + event.currentTarget = matched.elem; + j = 0; + while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) { + if (!event.rnamespace || handleObj.namespace === false || event.rnamespace.test(handleObj.namespace)) { + event.handleObj = handleObj; + event.data = handleObj.data; + ret = ((jQuery2.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args); + if (ret !== void 0) { + if ((event.result = ret) === false) { + event.preventDefault(); + event.stopPropagation(); + } + } + } + } + } + if (special.postDispatch) { + special.postDispatch.call(this, event); + } + return event.result; + }, + handlers: function(event, handlers) { + var i, handleObj, sel, matchedHandlers, matchedSelectors, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target; + if (delegateCount && // Support: IE <=9 + // Black-hole SVG instance trees (trac-13180) + cur.nodeType && // Support: Firefox <=42 + // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) + // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click + // Support: IE 11 only + // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) + !(event.type === "click" && event.button >= 1)) { + for (; cur !== this; cur = cur.parentNode || this) { + if (cur.nodeType === 1 && !(event.type === "click" && cur.disabled === true)) { + matchedHandlers = []; + matchedSelectors = {}; + for (i = 0; i < delegateCount; i++) { + handleObj = handlers[i]; + sel = handleObj.selector + " "; + if (matchedSelectors[sel] === void 0) { + matchedSelectors[sel] = handleObj.needsContext ? jQuery2(sel, this).index(cur) > -1 : jQuery2.find(sel, this, null, [cur]).length; + } + if (matchedSelectors[sel]) { + matchedHandlers.push(handleObj); + } + } + if (matchedHandlers.length) { + handlerQueue.push({ elem: cur, handlers: matchedHandlers }); + } + } + } + } + cur = this; + if (delegateCount < handlers.length) { + handlerQueue.push({ elem: cur, handlers: handlers.slice(delegateCount) }); + } + return handlerQueue; + }, + addProp: function(name, hook) { + Object.defineProperty(jQuery2.Event.prototype, name, { + enumerable: true, + configurable: true, + get: isFunction(hook) ? function() { + if (this.originalEvent) { + return hook(this.originalEvent); + } + } : function() { + if (this.originalEvent) { + return this.originalEvent[name]; + } + }, + set: function(value) { + Object.defineProperty(this, name, { + enumerable: true, + configurable: true, + writable: true, + value + }); + } + }); + }, + fix: function(originalEvent) { + return originalEvent[jQuery2.expando] ? originalEvent : new jQuery2.Event(originalEvent); + }, + special: { + load: { + // Prevent triggered image.load events from bubbling to window.load + noBubble: true + }, + click: { + // Utilize native event to ensure correct state for checkable inputs + setup: function(data) { + var el = this || data; + if (rcheckableType.test(el.type) && el.click && nodeName(el, "input")) { + leverageNative(el, "click", true); + } + return false; + }, + trigger: function(data) { + var el = this || data; + if (rcheckableType.test(el.type) && el.click && nodeName(el, "input")) { + leverageNative(el, "click"); + } + return true; + }, + // For cross-browser consistency, suppress native .click() on links + // Also prevent it if we're currently inside a leveraged native-event stack + _default: function(event) { + var target = event.target; + return rcheckableType.test(target.type) && target.click && nodeName(target, "input") && dataPriv.get(target, "click") || nodeName(target, "a"); + } + }, + beforeunload: { + postDispatch: function(event) { + if (event.result !== void 0 && event.originalEvent) { + event.originalEvent.returnValue = event.result; + } + } + } + } + }; + function leverageNative(el, type, isSetup) { + if (!isSetup) { + if (dataPriv.get(el, type) === void 0) { + jQuery2.event.add(el, type, returnTrue); + } + return; + } + dataPriv.set(el, type, false); + jQuery2.event.add(el, type, { + namespace: false, + handler: function(event) { + var result, saved = dataPriv.get(this, type); + if (event.isTrigger & 1 && this[type]) { + if (!saved) { + saved = slice.call(arguments); + dataPriv.set(this, type, saved); + this[type](); + result = dataPriv.get(this, type); + dataPriv.set(this, type, false); + if (saved !== result) { + event.stopImmediatePropagation(); + event.preventDefault(); + return result; + } + } else if ((jQuery2.event.special[type] || {}).delegateType) { + event.stopPropagation(); + } + } else if (saved) { + dataPriv.set(this, type, jQuery2.event.trigger( + saved[0], + saved.slice(1), + this + )); + event.stopPropagation(); + event.isImmediatePropagationStopped = returnTrue; + } + } + }); + } + jQuery2.removeEvent = function(elem, type, handle) { + if (elem.removeEventListener) { + elem.removeEventListener(type, handle); + } + }; + jQuery2.Event = function(src, props) { + if (!(this instanceof jQuery2.Event)) { + return new jQuery2.Event(src, props); + } + if (src && src.type) { + this.originalEvent = src; + this.type = src.type; + this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === void 0 && // Support: Android <=2.3 only + src.returnValue === false ? returnTrue : returnFalse; + this.target = src.target && src.target.nodeType === 3 ? src.target.parentNode : src.target; + this.currentTarget = src.currentTarget; + this.relatedTarget = src.relatedTarget; + } else { + this.type = src; + } + if (props) { + jQuery2.extend(this, props); + } + this.timeStamp = src && src.timeStamp || Date.now(); + this[jQuery2.expando] = true; + }; + jQuery2.Event.prototype = { + constructor: jQuery2.Event, + isDefaultPrevented: returnFalse, + isPropagationStopped: returnFalse, + isImmediatePropagationStopped: returnFalse, + isSimulated: false, + preventDefault: function() { + var e = this.originalEvent; + this.isDefaultPrevented = returnTrue; + if (e && !this.isSimulated) { + e.preventDefault(); + } + }, + stopPropagation: function() { + var e = this.originalEvent; + this.isPropagationStopped = returnTrue; + if (e && !this.isSimulated) { + e.stopPropagation(); + } + }, + stopImmediatePropagation: function() { + var e = this.originalEvent; + this.isImmediatePropagationStopped = returnTrue; + if (e && !this.isSimulated) { + e.stopImmediatePropagation(); + } + this.stopPropagation(); + } + }; + jQuery2.each({ + altKey: true, + bubbles: true, + cancelable: true, + changedTouches: true, + ctrlKey: true, + detail: true, + eventPhase: true, + metaKey: true, + pageX: true, + pageY: true, + shiftKey: true, + view: true, + "char": true, + code: true, + charCode: true, + key: true, + keyCode: true, + button: true, + buttons: true, + clientX: true, + clientY: true, + offsetX: true, + offsetY: true, + pointerId: true, + pointerType: true, + screenX: true, + screenY: true, + targetTouches: true, + toElement: true, + touches: true, + which: true + }, jQuery2.event.addProp); + jQuery2.each({ focus: "focusin", blur: "focusout" }, function(type, delegateType) { + function focusMappedHandler(nativeEvent) { + if (document2.documentMode) { + var handle = dataPriv.get(this, "handle"), event = jQuery2.event.fix(nativeEvent); + event.type = nativeEvent.type === "focusin" ? "focus" : "blur"; + event.isSimulated = true; + handle(nativeEvent); + if (event.target === event.currentTarget) { + handle(event); + } + } else { + jQuery2.event.simulate( + delegateType, + nativeEvent.target, + jQuery2.event.fix(nativeEvent) + ); + } + } + jQuery2.event.special[type] = { + // Utilize native event if possible so blur/focus sequence is correct + setup: function() { + var attaches; + leverageNative(this, type, true); + if (document2.documentMode) { + attaches = dataPriv.get(this, delegateType); + if (!attaches) { + this.addEventListener(delegateType, focusMappedHandler); + } + dataPriv.set(this, delegateType, (attaches || 0) + 1); + } else { + return false; + } + }, + trigger: function() { + leverageNative(this, type); + return true; + }, + teardown: function() { + var attaches; + if (document2.documentMode) { + attaches = dataPriv.get(this, delegateType) - 1; + if (!attaches) { + this.removeEventListener(delegateType, focusMappedHandler); + dataPriv.remove(this, delegateType); + } else { + dataPriv.set(this, delegateType, attaches); + } + } else { + return false; + } + }, + // Suppress native focus or blur if we're currently inside + // a leveraged native-event stack + _default: function(event) { + return dataPriv.get(event.target, type); + }, + delegateType + }; + jQuery2.event.special[delegateType] = { + setup: function() { + var doc = this.ownerDocument || this.document || this, dataHolder = document2.documentMode ? this : doc, attaches = dataPriv.get(dataHolder, delegateType); + if (!attaches) { + if (document2.documentMode) { + this.addEventListener(delegateType, focusMappedHandler); + } else { + doc.addEventListener(type, focusMappedHandler, true); + } + } + dataPriv.set(dataHolder, delegateType, (attaches || 0) + 1); + }, + teardown: function() { + var doc = this.ownerDocument || this.document || this, dataHolder = document2.documentMode ? this : doc, attaches = dataPriv.get(dataHolder, delegateType) - 1; + if (!attaches) { + if (document2.documentMode) { + this.removeEventListener(delegateType, focusMappedHandler); + } else { + doc.removeEventListener(type, focusMappedHandler, true); + } + dataPriv.remove(dataHolder, delegateType); + } else { + dataPriv.set(dataHolder, delegateType, attaches); + } + } + }; + }); + jQuery2.each({ + mouseenter: "mouseover", + mouseleave: "mouseout", + pointerenter: "pointerover", + pointerleave: "pointerout" + }, function(orig, fix) { + jQuery2.event.special[orig] = { + delegateType: fix, + bindType: fix, + handle: function(event) { + var ret, target = this, related = event.relatedTarget, handleObj = event.handleObj; + if (!related || related !== target && !jQuery2.contains(target, related)) { + event.type = handleObj.origType; + ret = handleObj.handler.apply(this, arguments); + event.type = fix; + } + return ret; + } + }; + }); + jQuery2.fn.extend({ + on: function(types, selector, data, fn) { + return on(this, types, selector, data, fn); + }, + one: function(types, selector, data, fn) { + return on(this, types, selector, data, fn, 1); + }, + off: function(types, selector, fn) { + var handleObj, type; + if (types && types.preventDefault && types.handleObj) { + handleObj = types.handleObj; + jQuery2(types.delegateTarget).off( + handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, + handleObj.selector, + handleObj.handler + ); + return this; + } + if (typeof types === "object") { + for (type in types) { + this.off(type, selector, types[type]); + } + return this; + } + if (selector === false || typeof selector === "function") { + fn = selector; + selector = void 0; + } + if (fn === false) { + fn = returnFalse; + } + return this.each(function() { + jQuery2.event.remove(this, types, fn, selector); + }); + } + }); + var rnoInnerhtml = /\s*$/g; + function manipulationTarget(elem, content) { + if (nodeName(elem, "table") && nodeName(content.nodeType !== 11 ? content : content.firstChild, "tr")) { + return jQuery2(elem).children("tbody")[0] || elem; + } + return elem; + } + function disableScript(elem) { + elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type; + return elem; + } + function restoreScript(elem) { + if ((elem.type || "").slice(0, 5) === "true/") { + elem.type = elem.type.slice(5); + } else { + elem.removeAttribute("type"); + } + return elem; + } + function cloneCopyEvent(src, dest) { + var i, l, type, pdataOld, udataOld, udataCur, events; + if (dest.nodeType !== 1) { + return; + } + if (dataPriv.hasData(src)) { + pdataOld = dataPriv.get(src); + events = pdataOld.events; + if (events) { + dataPriv.remove(dest, "handle events"); + for (type in events) { + for (i = 0, l = events[type].length; i < l; i++) { + jQuery2.event.add(dest, type, events[type][i]); + } + } + } + } + if (dataUser.hasData(src)) { + udataOld = dataUser.access(src); + udataCur = jQuery2.extend({}, udataOld); + dataUser.set(dest, udataCur); + } + } + function fixInput(src, dest) { + var nodeName2 = dest.nodeName.toLowerCase(); + if (nodeName2 === "input" && rcheckableType.test(src.type)) { + dest.checked = src.checked; + } else if (nodeName2 === "input" || nodeName2 === "textarea") { + dest.defaultValue = src.defaultValue; + } + } + function domManip(collection, args, callback, ignored) { + args = flat(args); + var fragment, first, scripts, hasScripts, node, doc, i = 0, l = collection.length, iNoClone = l - 1, value = args[0], valueIsFunction = isFunction(value); + if (valueIsFunction || l > 1 && typeof value === "string" && !support.checkClone && rchecked.test(value)) { + return collection.each(function(index) { + var self = collection.eq(index); + if (valueIsFunction) { + args[0] = value.call(this, index, self.html()); + } + domManip(self, args, callback, ignored); + }); + } + if (l) { + fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored); + first = fragment.firstChild; + if (fragment.childNodes.length === 1) { + fragment = first; + } + if (first || ignored) { + scripts = jQuery2.map(getAll(fragment, "script"), disableScript); + hasScripts = scripts.length; + for (; i < l; i++) { + node = fragment; + if (i !== iNoClone) { + node = jQuery2.clone(node, true, true); + if (hasScripts) { + jQuery2.merge(scripts, getAll(node, "script")); + } + } + callback.call(collection[i], node, i); + } + if (hasScripts) { + doc = scripts[scripts.length - 1].ownerDocument; + jQuery2.map(scripts, restoreScript); + for (i = 0; i < hasScripts; i++) { + node = scripts[i]; + if (rscriptType.test(node.type || "") && !dataPriv.access(node, "globalEval") && jQuery2.contains(doc, node)) { + if (node.src && (node.type || "").toLowerCase() !== "module") { + if (jQuery2._evalUrl && !node.noModule) { + jQuery2._evalUrl(node.src, { + nonce: node.nonce || node.getAttribute("nonce") + }, doc); + } + } else { + DOMEval(node.textContent.replace(rcleanScript, ""), node, doc); + } + } + } + } + } + } + return collection; + } + function remove(elem, selector, keepData) { + var node, nodes = selector ? jQuery2.filter(selector, elem) : elem, i = 0; + for (; (node = nodes[i]) != null; i++) { + if (!keepData && node.nodeType === 1) { + jQuery2.cleanData(getAll(node)); + } + if (node.parentNode) { + if (keepData && isAttached(node)) { + setGlobalEval(getAll(node, "script")); + } + node.parentNode.removeChild(node); + } + } + return elem; + } + jQuery2.extend({ + htmlPrefilter: function(html) { + return html; + }, + clone: function(elem, dataAndEvents, deepDataAndEvents) { + var i, l, srcElements, destElements, clone = elem.cloneNode(true), inPage = isAttached(elem); + if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery2.isXMLDoc(elem)) { + destElements = getAll(clone); + srcElements = getAll(elem); + for (i = 0, l = srcElements.length; i < l; i++) { + fixInput(srcElements[i], destElements[i]); + } + } + if (dataAndEvents) { + if (deepDataAndEvents) { + srcElements = srcElements || getAll(elem); + destElements = destElements || getAll(clone); + for (i = 0, l = srcElements.length; i < l; i++) { + cloneCopyEvent(srcElements[i], destElements[i]); + } + } else { + cloneCopyEvent(elem, clone); + } + } + destElements = getAll(clone, "script"); + if (destElements.length > 0) { + setGlobalEval(destElements, !inPage && getAll(elem, "script")); + } + return clone; + }, + cleanData: function(elems) { + var data, elem, type, special = jQuery2.event.special, i = 0; + for (; (elem = elems[i]) !== void 0; i++) { + if (acceptData(elem)) { + if (data = elem[dataPriv.expando]) { + if (data.events) { + for (type in data.events) { + if (special[type]) { + jQuery2.event.remove(elem, type); + } else { + jQuery2.removeEvent(elem, type, data.handle); + } + } + } + elem[dataPriv.expando] = void 0; + } + if (elem[dataUser.expando]) { + elem[dataUser.expando] = void 0; + } + } + } + } + }); + jQuery2.fn.extend({ + detach: function(selector) { + return remove(this, selector, true); + }, + remove: function(selector) { + return remove(this, selector); + }, + text: function(value) { + return access(this, function(value2) { + return value2 === void 0 ? jQuery2.text(this) : this.empty().each(function() { + if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) { + this.textContent = value2; + } + }); + }, null, value, arguments.length); + }, + append: function() { + return domManip(this, arguments, function(elem) { + if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) { + var target = manipulationTarget(this, elem); + target.appendChild(elem); + } + }); + }, + prepend: function() { + return domManip(this, arguments, function(elem) { + if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) { + var target = manipulationTarget(this, elem); + target.insertBefore(elem, target.firstChild); + } + }); + }, + before: function() { + return domManip(this, arguments, function(elem) { + if (this.parentNode) { + this.parentNode.insertBefore(elem, this); + } + }); + }, + after: function() { + return domManip(this, arguments, function(elem) { + if (this.parentNode) { + this.parentNode.insertBefore(elem, this.nextSibling); + } + }); + }, + empty: function() { + var elem, i = 0; + for (; (elem = this[i]) != null; i++) { + if (elem.nodeType === 1) { + jQuery2.cleanData(getAll(elem, false)); + elem.textContent = ""; + } + } + return this; + }, + clone: function(dataAndEvents, deepDataAndEvents) { + dataAndEvents = dataAndEvents == null ? false : dataAndEvents; + deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; + return this.map(function() { + return jQuery2.clone(this, dataAndEvents, deepDataAndEvents); + }); + }, + html: function(value) { + return access(this, function(value2) { + var elem = this[0] || {}, i = 0, l = this.length; + if (value2 === void 0 && elem.nodeType === 1) { + return elem.innerHTML; + } + if (typeof value2 === "string" && !rnoInnerhtml.test(value2) && !wrapMap[(rtagName.exec(value2) || ["", ""])[1].toLowerCase()]) { + value2 = jQuery2.htmlPrefilter(value2); + try { + for (; i < l; i++) { + elem = this[i] || {}; + if (elem.nodeType === 1) { + jQuery2.cleanData(getAll(elem, false)); + elem.innerHTML = value2; + } + } + elem = 0; + } catch (e) { + } + } + if (elem) { + this.empty().append(value2); + } + }, null, value, arguments.length); + }, + replaceWith: function() { + var ignored = []; + return domManip(this, arguments, function(elem) { + var parent = this.parentNode; + if (jQuery2.inArray(this, ignored) < 0) { + jQuery2.cleanData(getAll(this)); + if (parent) { + parent.replaceChild(elem, this); + } + } + }, ignored); + } + }); + jQuery2.each({ + appendTo: "append", + prependTo: "prepend", + insertBefore: "before", + insertAfter: "after", + replaceAll: "replaceWith" + }, function(name, original) { + jQuery2.fn[name] = function(selector) { + var elems, ret = [], insert = jQuery2(selector), last = insert.length - 1, i = 0; + for (; i <= last; i++) { + elems = i === last ? this : this.clone(true); + jQuery2(insert[i])[original](elems); + push.apply(ret, elems.get()); + } + return this.pushStack(ret); + }; + }); + var rnumnonpx = new RegExp("^(" + pnum + ")(?!px)[a-z%]+$", "i"); + var rcustomProp = /^--/; + var getStyles = function(elem) { + var view = elem.ownerDocument.defaultView; + if (!view || !view.opener) { + view = window2; + } + return view.getComputedStyle(elem); + }; + var swap = function(elem, options, callback) { + var ret, name, old = {}; + for (name in options) { + old[name] = elem.style[name]; + elem.style[name] = options[name]; + } + ret = callback.call(elem); + for (name in options) { + elem.style[name] = old[name]; + } + return ret; + }; + var rboxStyle = new RegExp(cssExpand.join("|"), "i"); + (function() { + function computeStyleTests() { + if (!div) { + return; + } + container.style.cssText = "position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0"; + div.style.cssText = "position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%"; + documentElement.appendChild(container).appendChild(div); + var divStyle = window2.getComputedStyle(div); + pixelPositionVal = divStyle.top !== "1%"; + reliableMarginLeftVal = roundPixelMeasures(divStyle.marginLeft) === 12; + div.style.right = "60%"; + pixelBoxStylesVal = roundPixelMeasures(divStyle.right) === 36; + boxSizingReliableVal = roundPixelMeasures(divStyle.width) === 36; + div.style.position = "absolute"; + scrollboxSizeVal = roundPixelMeasures(div.offsetWidth / 3) === 12; + documentElement.removeChild(container); + div = null; + } + function roundPixelMeasures(measure) { + return Math.round(parseFloat(measure)); + } + var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, reliableTrDimensionsVal, reliableMarginLeftVal, container = document2.createElement("div"), div = document2.createElement("div"); + if (!div.style) { + return; + } + div.style.backgroundClip = "content-box"; + div.cloneNode(true).style.backgroundClip = ""; + support.clearCloneStyle = div.style.backgroundClip === "content-box"; + jQuery2.extend(support, { + boxSizingReliable: function() { + computeStyleTests(); + return boxSizingReliableVal; + }, + pixelBoxStyles: function() { + computeStyleTests(); + return pixelBoxStylesVal; + }, + pixelPosition: function() { + computeStyleTests(); + return pixelPositionVal; + }, + reliableMarginLeft: function() { + computeStyleTests(); + return reliableMarginLeftVal; + }, + scrollboxSize: function() { + computeStyleTests(); + return scrollboxSizeVal; + }, + // Support: IE 9 - 11+, Edge 15 - 18+ + // IE/Edge misreport `getComputedStyle` of table rows with width/height + // set in CSS while `offset*` properties report correct values. + // Behavior in IE 9 is more subtle than in newer versions & it passes + // some versions of this test; make sure not to make it pass there! + // + // Support: Firefox 70+ + // Only Firefox includes border widths + // in computed dimensions. (gh-4529) + reliableTrDimensions: function() { + var table, tr, trChild, trStyle; + if (reliableTrDimensionsVal == null) { + table = document2.createElement("table"); + tr = document2.createElement("tr"); + trChild = document2.createElement("div"); + table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate"; + tr.style.cssText = "border:1px solid"; + tr.style.height = "1px"; + trChild.style.height = "9px"; + trChild.style.display = "block"; + documentElement.appendChild(table).appendChild(tr).appendChild(trChild); + trStyle = window2.getComputedStyle(tr); + reliableTrDimensionsVal = parseInt(trStyle.height, 10) + parseInt(trStyle.borderTopWidth, 10) + parseInt(trStyle.borderBottomWidth, 10) === tr.offsetHeight; + documentElement.removeChild(table); + } + return reliableTrDimensionsVal; + } + }); + })(); + function curCSS(elem, name, computed) { + var width, minWidth, maxWidth, ret, isCustomProp = rcustomProp.test(name), style = elem.style; + computed = computed || getStyles(elem); + if (computed) { + ret = computed.getPropertyValue(name) || computed[name]; + if (isCustomProp && ret) { + ret = ret.replace(rtrimCSS, "$1") || void 0; + } + if (ret === "" && !isAttached(elem)) { + ret = jQuery2.style(elem, name); + } + if (!support.pixelBoxStyles() && rnumnonpx.test(ret) && rboxStyle.test(name)) { + width = style.width; + minWidth = style.minWidth; + maxWidth = style.maxWidth; + style.minWidth = style.maxWidth = style.width = ret; + ret = computed.width; + style.width = width; + style.minWidth = minWidth; + style.maxWidth = maxWidth; + } + } + return ret !== void 0 ? ( + // Support: IE <=9 - 11 only + // IE returns zIndex value as an integer. + ret + "" + ) : ret; + } + function addGetHookIf(conditionFn, hookFn) { + return { + get: function() { + if (conditionFn()) { + delete this.get; + return; + } + return (this.get = hookFn).apply(this, arguments); + } + }; + } + var cssPrefixes = ["Webkit", "Moz", "ms"], emptyStyle = document2.createElement("div").style, vendorProps = {}; + function vendorPropName(name) { + var capName = name[0].toUpperCase() + name.slice(1), i = cssPrefixes.length; + while (i--) { + name = cssPrefixes[i] + capName; + if (name in emptyStyle) { + return name; + } + } + } + function finalPropName(name) { + var final = jQuery2.cssProps[name] || vendorProps[name]; + if (final) { + return final; + } + if (name in emptyStyle) { + return name; + } + return vendorProps[name] = vendorPropName(name) || name; + } + var rdisplayswap = /^(none|table(?!-c[ea]).+)/, cssShow = { position: "absolute", visibility: "hidden", display: "block" }, cssNormalTransform = { + letterSpacing: "0", + fontWeight: "400" + }; + function setPositiveNumber(_elem, value, subtract) { + var matches = rcssNum.exec(value); + return matches ? ( + // Guard against undefined "subtract", e.g., when used as in cssHooks + Math.max(0, matches[2] - (subtract || 0)) + (matches[3] || "px") + ) : value; + } + function boxModelAdjustment(elem, dimension, box, isBorderBox, styles, computedVal) { + var i = dimension === "width" ? 1 : 0, extra = 0, delta = 0, marginDelta = 0; + if (box === (isBorderBox ? "border" : "content")) { + return 0; + } + for (; i < 4; i += 2) { + if (box === "margin") { + marginDelta += jQuery2.css(elem, box + cssExpand[i], true, styles); + } + if (!isBorderBox) { + delta += jQuery2.css(elem, "padding" + cssExpand[i], true, styles); + if (box !== "padding") { + delta += jQuery2.css(elem, "border" + cssExpand[i] + "Width", true, styles); + } else { + extra += jQuery2.css(elem, "border" + cssExpand[i] + "Width", true, styles); + } + } else { + if (box === "content") { + delta -= jQuery2.css(elem, "padding" + cssExpand[i], true, styles); + } + if (box !== "margin") { + delta -= jQuery2.css(elem, "border" + cssExpand[i] + "Width", true, styles); + } + } + } + if (!isBorderBox && computedVal >= 0) { + delta += Math.max(0, Math.ceil( + elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)] - computedVal - delta - extra - 0.5 + // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter + // Use an explicit zero to avoid NaN (gh-3964) + )) || 0; + } + return delta + marginDelta; + } + function getWidthOrHeight(elem, dimension, extra) { + var styles = getStyles(elem), boxSizingNeeded = !support.boxSizingReliable() || extra, isBorderBox = boxSizingNeeded && jQuery2.css(elem, "boxSizing", false, styles) === "border-box", valueIsBorderBox = isBorderBox, val = curCSS(elem, dimension, styles), offsetProp = "offset" + dimension[0].toUpperCase() + dimension.slice(1); + if (rnumnonpx.test(val)) { + if (!extra) { + return val; + } + val = "auto"; + } + if ((!support.boxSizingReliable() && isBorderBox || // Support: IE 10 - 11+, Edge 15 - 18+ + // IE/Edge misreport `getComputedStyle` of table rows with width/height + // set in CSS while `offset*` properties report correct values. + // Interestingly, in some cases IE 9 doesn't suffer from this issue. + !support.reliableTrDimensions() && nodeName(elem, "tr") || // Fall back to offsetWidth/offsetHeight when value is "auto" + // This happens for inline elements with no explicit setting (gh-3571) + val === "auto" || // Support: Android <=4.1 - 4.3 only + // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) + !parseFloat(val) && jQuery2.css(elem, "display", false, styles) === "inline") && // Make sure the element is visible & connected + elem.getClientRects().length) { + isBorderBox = jQuery2.css(elem, "boxSizing", false, styles) === "border-box"; + valueIsBorderBox = offsetProp in elem; + if (valueIsBorderBox) { + val = elem[offsetProp]; + } + } + val = parseFloat(val) || 0; + return val + boxModelAdjustment( + elem, + dimension, + extra || (isBorderBox ? "border" : "content"), + valueIsBorderBox, + styles, + // Provide the current computed size to request scroll gutter calculation (gh-3589) + val + ) + "px"; + } + jQuery2.extend({ + // Add in style property hooks for overriding the default + // behavior of getting and setting a style property + cssHooks: { + opacity: { + get: function(elem, computed) { + if (computed) { + var ret = curCSS(elem, "opacity"); + return ret === "" ? "1" : ret; + } + } + } + }, + // Don't automatically add "px" to these possibly-unitless properties + cssNumber: { + animationIterationCount: true, + aspectRatio: true, + borderImageSlice: true, + columnCount: true, + flexGrow: true, + flexShrink: true, + fontWeight: true, + gridArea: true, + gridColumn: true, + gridColumnEnd: true, + gridColumnStart: true, + gridRow: true, + gridRowEnd: true, + gridRowStart: true, + lineHeight: true, + opacity: true, + order: true, + orphans: true, + scale: true, + widows: true, + zIndex: true, + zoom: true, + // SVG-related + fillOpacity: true, + floodOpacity: true, + stopOpacity: true, + strokeMiterlimit: true, + strokeOpacity: true + }, + // Add in properties whose names you wish to fix before + // setting or getting the value + cssProps: {}, + // Get and set the style property on a DOM Node + style: function(elem, name, value, extra) { + if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) { + return; + } + var ret, type, hooks, origName = camelCase(name), isCustomProp = rcustomProp.test(name), style = elem.style; + if (!isCustomProp) { + name = finalPropName(origName); + } + hooks = jQuery2.cssHooks[name] || jQuery2.cssHooks[origName]; + if (value !== void 0) { + type = typeof value; + if (type === "string" && (ret = rcssNum.exec(value)) && ret[1]) { + value = adjustCSS(elem, name, ret); + type = "number"; + } + if (value == null || value !== value) { + return; + } + if (type === "number" && !isCustomProp) { + value += ret && ret[3] || (jQuery2.cssNumber[origName] ? "" : "px"); + } + if (!support.clearCloneStyle && value === "" && name.indexOf("background") === 0) { + style[name] = "inherit"; + } + if (!hooks || !("set" in hooks) || (value = hooks.set(elem, value, extra)) !== void 0) { + if (isCustomProp) { + style.setProperty(name, value); + } else { + style[name] = value; + } + } + } else { + if (hooks && "get" in hooks && (ret = hooks.get(elem, false, extra)) !== void 0) { + return ret; + } + return style[name]; + } + }, + css: function(elem, name, extra, styles) { + var val, num, hooks, origName = camelCase(name), isCustomProp = rcustomProp.test(name); + if (!isCustomProp) { + name = finalPropName(origName); + } + hooks = jQuery2.cssHooks[name] || jQuery2.cssHooks[origName]; + if (hooks && "get" in hooks) { + val = hooks.get(elem, true, extra); + } + if (val === void 0) { + val = curCSS(elem, name, styles); + } + if (val === "normal" && name in cssNormalTransform) { + val = cssNormalTransform[name]; + } + if (extra === "" || extra) { + num = parseFloat(val); + return extra === true || isFinite(num) ? num || 0 : val; + } + return val; + } + }); + jQuery2.each(["height", "width"], function(_i, dimension) { + jQuery2.cssHooks[dimension] = { + get: function(elem, computed, extra) { + if (computed) { + return rdisplayswap.test(jQuery2.css(elem, "display")) && // Support: Safari 8+ + // Table columns in Safari have non-zero offsetWidth & zero + // getBoundingClientRect().width unless display is changed. + // Support: IE <=11 only + // Running getBoundingClientRect on a disconnected node + // in IE throws an error. + (!elem.getClientRects().length || !elem.getBoundingClientRect().width) ? swap(elem, cssShow, function() { + return getWidthOrHeight(elem, dimension, extra); + }) : getWidthOrHeight(elem, dimension, extra); + } + }, + set: function(elem, value, extra) { + var matches, styles = getStyles(elem), scrollboxSizeBuggy = !support.scrollboxSize() && styles.position === "absolute", boxSizingNeeded = scrollboxSizeBuggy || extra, isBorderBox = boxSizingNeeded && jQuery2.css(elem, "boxSizing", false, styles) === "border-box", subtract = extra ? boxModelAdjustment( + elem, + dimension, + extra, + isBorderBox, + styles + ) : 0; + if (isBorderBox && scrollboxSizeBuggy) { + subtract -= Math.ceil( + elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)] - parseFloat(styles[dimension]) - boxModelAdjustment(elem, dimension, "border", false, styles) - 0.5 + ); + } + if (subtract && (matches = rcssNum.exec(value)) && (matches[3] || "px") !== "px") { + elem.style[dimension] = value; + value = jQuery2.css(elem, dimension); + } + return setPositiveNumber(elem, value, subtract); + } + }; + }); + jQuery2.cssHooks.marginLeft = addGetHookIf( + support.reliableMarginLeft, + function(elem, computed) { + if (computed) { + return (parseFloat(curCSS(elem, "marginLeft")) || elem.getBoundingClientRect().left - swap(elem, { marginLeft: 0 }, function() { + return elem.getBoundingClientRect().left; + })) + "px"; + } + } + ); + jQuery2.each({ + margin: "", + padding: "", + border: "Width" + }, function(prefix, suffix) { + jQuery2.cssHooks[prefix + suffix] = { + expand: function(value) { + var i = 0, expanded = {}, parts = typeof value === "string" ? value.split(" ") : [value]; + for (; i < 4; i++) { + expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0]; + } + return expanded; + } + }; + if (prefix !== "margin") { + jQuery2.cssHooks[prefix + suffix].set = setPositiveNumber; + } + }); + jQuery2.fn.extend({ + css: function(name, value) { + return access(this, function(elem, name2, value2) { + var styles, len, map = {}, i = 0; + if (Array.isArray(name2)) { + styles = getStyles(elem); + len = name2.length; + for (; i < len; i++) { + map[name2[i]] = jQuery2.css(elem, name2[i], false, styles); + } + return map; + } + return value2 !== void 0 ? jQuery2.style(elem, name2, value2) : jQuery2.css(elem, name2); + }, name, value, arguments.length > 1); + } + }); + function Tween(elem, options, prop, end, easing) { + return new Tween.prototype.init(elem, options, prop, end, easing); + } + jQuery2.Tween = Tween; + Tween.prototype = { + constructor: Tween, + init: function(elem, options, prop, end, easing, unit) { + this.elem = elem; + this.prop = prop; + this.easing = easing || jQuery2.easing._default; + this.options = options; + this.start = this.now = this.cur(); + this.end = end; + this.unit = unit || (jQuery2.cssNumber[prop] ? "" : "px"); + }, + cur: function() { + var hooks = Tween.propHooks[this.prop]; + return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this); + }, + run: function(percent) { + var eased, hooks = Tween.propHooks[this.prop]; + if (this.options.duration) { + this.pos = eased = jQuery2.easing[this.easing]( + percent, + this.options.duration * percent, + 0, + 1, + this.options.duration + ); + } else { + this.pos = eased = percent; + } + this.now = (this.end - this.start) * eased + this.start; + if (this.options.step) { + this.options.step.call(this.elem, this.now, this); + } + if (hooks && hooks.set) { + hooks.set(this); + } else { + Tween.propHooks._default.set(this); + } + return this; + } + }; + Tween.prototype.init.prototype = Tween.prototype; + Tween.propHooks = { + _default: { + get: function(tween) { + var result; + if (tween.elem.nodeType !== 1 || tween.elem[tween.prop] != null && tween.elem.style[tween.prop] == null) { + return tween.elem[tween.prop]; + } + result = jQuery2.css(tween.elem, tween.prop, ""); + return !result || result === "auto" ? 0 : result; + }, + set: function(tween) { + if (jQuery2.fx.step[tween.prop]) { + jQuery2.fx.step[tween.prop](tween); + } else if (tween.elem.nodeType === 1 && (jQuery2.cssHooks[tween.prop] || tween.elem.style[finalPropName(tween.prop)] != null)) { + jQuery2.style(tween.elem, tween.prop, tween.now + tween.unit); + } else { + tween.elem[tween.prop] = tween.now; + } + } + } + }; + Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { + set: function(tween) { + if (tween.elem.nodeType && tween.elem.parentNode) { + tween.elem[tween.prop] = tween.now; + } + } + }; + jQuery2.easing = { + linear: function(p) { + return p; + }, + swing: function(p) { + return 0.5 - Math.cos(p * Math.PI) / 2; + }, + _default: "swing" + }; + jQuery2.fx = Tween.prototype.init; + jQuery2.fx.step = {}; + var fxNow, inProgress, rfxtypes = /^(?:toggle|show|hide)$/, rrun = /queueHooks$/; + function schedule() { + if (inProgress) { + if (document2.hidden === false && window2.requestAnimationFrame) { + window2.requestAnimationFrame(schedule); + } else { + window2.setTimeout(schedule, jQuery2.fx.interval); + } + jQuery2.fx.tick(); + } + } + function createFxNow() { + window2.setTimeout(function() { + fxNow = void 0; + }); + return fxNow = Date.now(); + } + function genFx(type, includeWidth) { + var which, i = 0, attrs = { height: type }; + includeWidth = includeWidth ? 1 : 0; + for (; i < 4; i += 2 - includeWidth) { + which = cssExpand[i]; + attrs["margin" + which] = attrs["padding" + which] = type; + } + if (includeWidth) { + attrs.opacity = attrs.width = type; + } + return attrs; + } + function createTween(value, prop, animation) { + var tween, collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners["*"]), index = 0, length = collection.length; + for (; index < length; index++) { + if (tween = collection[index].call(animation, prop, value)) { + return tween; + } + } + } + function defaultPrefilter(elem, props, opts) { + var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, isBox = "width" in props || "height" in props, anim = this, orig = {}, style = elem.style, hidden = elem.nodeType && isHiddenWithinTree(elem), dataShow = dataPriv.get(elem, "fxshow"); + if (!opts.queue) { + hooks = jQuery2._queueHooks(elem, "fx"); + if (hooks.unqueued == null) { + hooks.unqueued = 0; + oldfire = hooks.empty.fire; + hooks.empty.fire = function() { + if (!hooks.unqueued) { + oldfire(); + } + }; + } + hooks.unqueued++; + anim.always(function() { + anim.always(function() { + hooks.unqueued--; + if (!jQuery2.queue(elem, "fx").length) { + hooks.empty.fire(); + } + }); + }); + } + for (prop in props) { + value = props[prop]; + if (rfxtypes.test(value)) { + delete props[prop]; + toggle = toggle || value === "toggle"; + if (value === (hidden ? "hide" : "show")) { + if (value === "show" && dataShow && dataShow[prop] !== void 0) { + hidden = true; + } else { + continue; + } + } + orig[prop] = dataShow && dataShow[prop] || jQuery2.style(elem, prop); + } + } + propTween = !jQuery2.isEmptyObject(props); + if (!propTween && jQuery2.isEmptyObject(orig)) { + return; + } + if (isBox && elem.nodeType === 1) { + opts.overflow = [style.overflow, style.overflowX, style.overflowY]; + restoreDisplay = dataShow && dataShow.display; + if (restoreDisplay == null) { + restoreDisplay = dataPriv.get(elem, "display"); + } + display = jQuery2.css(elem, "display"); + if (display === "none") { + if (restoreDisplay) { + display = restoreDisplay; + } else { + showHide([elem], true); + restoreDisplay = elem.style.display || restoreDisplay; + display = jQuery2.css(elem, "display"); + showHide([elem]); + } + } + if (display === "inline" || display === "inline-block" && restoreDisplay != null) { + if (jQuery2.css(elem, "float") === "none") { + if (!propTween) { + anim.done(function() { + style.display = restoreDisplay; + }); + if (restoreDisplay == null) { + display = style.display; + restoreDisplay = display === "none" ? "" : display; + } + } + style.display = "inline-block"; + } + } + } + if (opts.overflow) { + style.overflow = "hidden"; + anim.always(function() { + style.overflow = opts.overflow[0]; + style.overflowX = opts.overflow[1]; + style.overflowY = opts.overflow[2]; + }); + } + propTween = false; + for (prop in orig) { + if (!propTween) { + if (dataShow) { + if ("hidden" in dataShow) { + hidden = dataShow.hidden; + } + } else { + dataShow = dataPriv.access(elem, "fxshow", { display: restoreDisplay }); + } + if (toggle) { + dataShow.hidden = !hidden; + } + if (hidden) { + showHide([elem], true); + } + anim.done(function() { + if (!hidden) { + showHide([elem]); + } + dataPriv.remove(elem, "fxshow"); + for (prop in orig) { + jQuery2.style(elem, prop, orig[prop]); + } + }); + } + propTween = createTween(hidden ? dataShow[prop] : 0, prop, anim); + if (!(prop in dataShow)) { + dataShow[prop] = propTween.start; + if (hidden) { + propTween.end = propTween.start; + propTween.start = 0; + } + } + } + } + function propFilter(props, specialEasing) { + var index, name, easing, value, hooks; + for (index in props) { + name = camelCase(index); + easing = specialEasing[name]; + value = props[index]; + if (Array.isArray(value)) { + easing = value[1]; + value = props[index] = value[0]; + } + if (index !== name) { + props[name] = value; + delete props[index]; + } + hooks = jQuery2.cssHooks[name]; + if (hooks && "expand" in hooks) { + value = hooks.expand(value); + delete props[name]; + for (index in value) { + if (!(index in props)) { + props[index] = value[index]; + specialEasing[index] = easing; + } + } + } else { + specialEasing[name] = easing; + } + } + } + function Animation(elem, properties, options) { + var result, stopped, index = 0, length = Animation.prefilters.length, deferred = jQuery2.Deferred().always(function() { + delete tick.elem; + }), tick = function() { + if (stopped) { + return false; + } + var currentTime = fxNow || createFxNow(), remaining = Math.max(0, animation.startTime + animation.duration - currentTime), temp = remaining / animation.duration || 0, percent = 1 - temp, index2 = 0, length2 = animation.tweens.length; + for (; index2 < length2; index2++) { + animation.tweens[index2].run(percent); + } + deferred.notifyWith(elem, [animation, percent, remaining]); + if (percent < 1 && length2) { + return remaining; + } + if (!length2) { + deferred.notifyWith(elem, [animation, 1, 0]); + } + deferred.resolveWith(elem, [animation]); + return false; + }, animation = deferred.promise({ + elem, + props: jQuery2.extend({}, properties), + opts: jQuery2.extend(true, { + specialEasing: {}, + easing: jQuery2.easing._default + }, options), + originalProperties: properties, + originalOptions: options, + startTime: fxNow || createFxNow(), + duration: options.duration, + tweens: [], + createTween: function(prop, end) { + var tween = jQuery2.Tween( + elem, + animation.opts, + prop, + end, + animation.opts.specialEasing[prop] || animation.opts.easing + ); + animation.tweens.push(tween); + return tween; + }, + stop: function(gotoEnd) { + var index2 = 0, length2 = gotoEnd ? animation.tweens.length : 0; + if (stopped) { + return this; + } + stopped = true; + for (; index2 < length2; index2++) { + animation.tweens[index2].run(1); + } + if (gotoEnd) { + deferred.notifyWith(elem, [animation, 1, 0]); + deferred.resolveWith(elem, [animation, gotoEnd]); + } else { + deferred.rejectWith(elem, [animation, gotoEnd]); + } + return this; + } + }), props = animation.props; + propFilter(props, animation.opts.specialEasing); + for (; index < length; index++) { + result = Animation.prefilters[index].call(animation, elem, props, animation.opts); + if (result) { + if (isFunction(result.stop)) { + jQuery2._queueHooks(animation.elem, animation.opts.queue).stop = result.stop.bind(result); + } + return result; + } + } + jQuery2.map(props, createTween, animation); + if (isFunction(animation.opts.start)) { + animation.opts.start.call(elem, animation); + } + animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always); + jQuery2.fx.timer( + jQuery2.extend(tick, { + elem, + anim: animation, + queue: animation.opts.queue + }) + ); + return animation; + } + jQuery2.Animation = jQuery2.extend(Animation, { + tweeners: { + "*": [function(prop, value) { + var tween = this.createTween(prop, value); + adjustCSS(tween.elem, prop, rcssNum.exec(value), tween); + return tween; + }] + }, + tweener: function(props, callback) { + if (isFunction(props)) { + callback = props; + props = ["*"]; + } else { + props = props.match(rnothtmlwhite); + } + var prop, index = 0, length = props.length; + for (; index < length; index++) { + prop = props[index]; + Animation.tweeners[prop] = Animation.tweeners[prop] || []; + Animation.tweeners[prop].unshift(callback); + } + }, + prefilters: [defaultPrefilter], + prefilter: function(callback, prepend) { + if (prepend) { + Animation.prefilters.unshift(callback); + } else { + Animation.prefilters.push(callback); + } + } + }); + jQuery2.speed = function(speed, easing, fn) { + var opt = speed && typeof speed === "object" ? jQuery2.extend({}, speed) : { + complete: fn || !fn && easing || isFunction(speed) && speed, + duration: speed, + easing: fn && easing || easing && !isFunction(easing) && easing + }; + if (jQuery2.fx.off) { + opt.duration = 0; + } else { + if (typeof opt.duration !== "number") { + if (opt.duration in jQuery2.fx.speeds) { + opt.duration = jQuery2.fx.speeds[opt.duration]; + } else { + opt.duration = jQuery2.fx.speeds._default; + } + } + } + if (opt.queue == null || opt.queue === true) { + opt.queue = "fx"; + } + opt.old = opt.complete; + opt.complete = function() { + if (isFunction(opt.old)) { + opt.old.call(this); + } + if (opt.queue) { + jQuery2.dequeue(this, opt.queue); + } + }; + return opt; + }; + jQuery2.fn.extend({ + fadeTo: function(speed, to, easing, callback) { + return this.filter(isHiddenWithinTree).css("opacity", 0).show().end().animate({ opacity: to }, speed, easing, callback); + }, + animate: function(prop, speed, easing, callback) { + var empty = jQuery2.isEmptyObject(prop), optall = jQuery2.speed(speed, easing, callback), doAnimation = function() { + var anim = Animation(this, jQuery2.extend({}, prop), optall); + if (empty || dataPriv.get(this, "finish")) { + anim.stop(true); + } + }; + doAnimation.finish = doAnimation; + return empty || optall.queue === false ? this.each(doAnimation) : this.queue(optall.queue, doAnimation); + }, + stop: function(type, clearQueue, gotoEnd) { + var stopQueue = function(hooks) { + var stop = hooks.stop; + delete hooks.stop; + stop(gotoEnd); + }; + if (typeof type !== "string") { + gotoEnd = clearQueue; + clearQueue = type; + type = void 0; + } + if (clearQueue) { + this.queue(type || "fx", []); + } + return this.each(function() { + var dequeue = true, index = type != null && type + "queueHooks", timers = jQuery2.timers, data = dataPriv.get(this); + if (index) { + if (data[index] && data[index].stop) { + stopQueue(data[index]); + } + } else { + for (index in data) { + if (data[index] && data[index].stop && rrun.test(index)) { + stopQueue(data[index]); + } + } + } + for (index = timers.length; index--; ) { + if (timers[index].elem === this && (type == null || timers[index].queue === type)) { + timers[index].anim.stop(gotoEnd); + dequeue = false; + timers.splice(index, 1); + } + } + if (dequeue || !gotoEnd) { + jQuery2.dequeue(this, type); + } + }); + }, + finish: function(type) { + if (type !== false) { + type = type || "fx"; + } + return this.each(function() { + var index, data = dataPriv.get(this), queue = data[type + "queue"], hooks = data[type + "queueHooks"], timers = jQuery2.timers, length = queue ? queue.length : 0; + data.finish = true; + jQuery2.queue(this, type, []); + if (hooks && hooks.stop) { + hooks.stop.call(this, true); + } + for (index = timers.length; index--; ) { + if (timers[index].elem === this && timers[index].queue === type) { + timers[index].anim.stop(true); + timers.splice(index, 1); + } + } + for (index = 0; index < length; index++) { + if (queue[index] && queue[index].finish) { + queue[index].finish.call(this); + } + } + delete data.finish; + }); + } + }); + jQuery2.each(["toggle", "show", "hide"], function(_i, name) { + var cssFn = jQuery2.fn[name]; + jQuery2.fn[name] = function(speed, easing, callback) { + return speed == null || typeof speed === "boolean" ? cssFn.apply(this, arguments) : this.animate(genFx(name, true), speed, easing, callback); + }; + }); + jQuery2.each({ + slideDown: genFx("show"), + slideUp: genFx("hide"), + slideToggle: genFx("toggle"), + fadeIn: { opacity: "show" }, + fadeOut: { opacity: "hide" }, + fadeToggle: { opacity: "toggle" } + }, function(name, props) { + jQuery2.fn[name] = function(speed, easing, callback) { + return this.animate(props, speed, easing, callback); + }; + }); + jQuery2.timers = []; + jQuery2.fx.tick = function() { + var timer, i = 0, timers = jQuery2.timers; + fxNow = Date.now(); + for (; i < timers.length; i++) { + timer = timers[i]; + if (!timer() && timers[i] === timer) { + timers.splice(i--, 1); + } + } + if (!timers.length) { + jQuery2.fx.stop(); + } + fxNow = void 0; + }; + jQuery2.fx.timer = function(timer) { + jQuery2.timers.push(timer); + jQuery2.fx.start(); + }; + jQuery2.fx.interval = 13; + jQuery2.fx.start = function() { + if (inProgress) { + return; + } + inProgress = true; + schedule(); + }; + jQuery2.fx.stop = function() { + inProgress = null; + }; + jQuery2.fx.speeds = { + slow: 600, + fast: 200, + // Default speed + _default: 400 + }; + jQuery2.fn.delay = function(time, type) { + time = jQuery2.fx ? jQuery2.fx.speeds[time] || time : time; + type = type || "fx"; + return this.queue(type, function(next, hooks) { + var timeout = window2.setTimeout(next, time); + hooks.stop = function() { + window2.clearTimeout(timeout); + }; + }); + }; + (function() { + var input = document2.createElement("input"), select = document2.createElement("select"), opt = select.appendChild(document2.createElement("option")); + input.type = "checkbox"; + support.checkOn = input.value !== ""; + support.optSelected = opt.selected; + input = document2.createElement("input"); + input.value = "t"; + input.type = "radio"; + support.radioValue = input.value === "t"; + })(); + var boolHook, attrHandle = jQuery2.expr.attrHandle; + jQuery2.fn.extend({ + attr: function(name, value) { + return access(this, jQuery2.attr, name, value, arguments.length > 1); + }, + removeAttr: function(name) { + return this.each(function() { + jQuery2.removeAttr(this, name); + }); + } + }); + jQuery2.extend({ + attr: function(elem, name, value) { + var ret, hooks, nType = elem.nodeType; + if (nType === 3 || nType === 8 || nType === 2) { + return; + } + if (typeof elem.getAttribute === "undefined") { + return jQuery2.prop(elem, name, value); + } + if (nType !== 1 || !jQuery2.isXMLDoc(elem)) { + hooks = jQuery2.attrHooks[name.toLowerCase()] || (jQuery2.expr.match.bool.test(name) ? boolHook : void 0); + } + if (value !== void 0) { + if (value === null) { + jQuery2.removeAttr(elem, name); + return; + } + if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== void 0) { + return ret; + } + elem.setAttribute(name, value + ""); + return value; + } + if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) { + return ret; + } + ret = jQuery2.find.attr(elem, name); + return ret == null ? void 0 : ret; + }, + attrHooks: { + type: { + set: function(elem, value) { + if (!support.radioValue && value === "radio" && nodeName(elem, "input")) { + var val = elem.value; + elem.setAttribute("type", value); + if (val) { + elem.value = val; + } + return value; + } + } + } + }, + removeAttr: function(elem, value) { + var name, i = 0, attrNames = value && value.match(rnothtmlwhite); + if (attrNames && elem.nodeType === 1) { + while (name = attrNames[i++]) { + elem.removeAttribute(name); + } + } + } + }); + boolHook = { + set: function(elem, value, name) { + if (value === false) { + jQuery2.removeAttr(elem, name); + } else { + elem.setAttribute(name, name); + } + return name; + } + }; + jQuery2.each(jQuery2.expr.match.bool.source.match(/\w+/g), function(_i, name) { + var getter = attrHandle[name] || jQuery2.find.attr; + attrHandle[name] = function(elem, name2, isXML) { + var ret, handle, lowercaseName = name2.toLowerCase(); + if (!isXML) { + handle = attrHandle[lowercaseName]; + attrHandle[lowercaseName] = ret; + ret = getter(elem, name2, isXML) != null ? lowercaseName : null; + attrHandle[lowercaseName] = handle; + } + return ret; + }; + }); + var rfocusable = /^(?:input|select|textarea|button)$/i, rclickable = /^(?:a|area)$/i; + jQuery2.fn.extend({ + prop: function(name, value) { + return access(this, jQuery2.prop, name, value, arguments.length > 1); + }, + removeProp: function(name) { + return this.each(function() { + delete this[jQuery2.propFix[name] || name]; + }); + } + }); + jQuery2.extend({ + prop: function(elem, name, value) { + var ret, hooks, nType = elem.nodeType; + if (nType === 3 || nType === 8 || nType === 2) { + return; + } + if (nType !== 1 || !jQuery2.isXMLDoc(elem)) { + name = jQuery2.propFix[name] || name; + hooks = jQuery2.propHooks[name]; + } + if (value !== void 0) { + if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== void 0) { + return ret; + } + return elem[name] = value; + } + if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) { + return ret; + } + return elem[name]; + }, + propHooks: { + tabIndex: { + get: function(elem) { + var tabindex = jQuery2.find.attr(elem, "tabindex"); + if (tabindex) { + return parseInt(tabindex, 10); + } + if (rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href) { + return 0; + } + return -1; + } + } + }, + propFix: { + "for": "htmlFor", + "class": "className" + } + }); + if (!support.optSelected) { + jQuery2.propHooks.selected = { + get: function(elem) { + var parent = elem.parentNode; + if (parent && parent.parentNode) { + parent.parentNode.selectedIndex; + } + return null; + }, + set: function(elem) { + var parent = elem.parentNode; + if (parent) { + parent.selectedIndex; + if (parent.parentNode) { + parent.parentNode.selectedIndex; + } + } + } + }; + } + jQuery2.each([ + "tabIndex", + "readOnly", + "maxLength", + "cellSpacing", + "cellPadding", + "rowSpan", + "colSpan", + "useMap", + "frameBorder", + "contentEditable" + ], function() { + jQuery2.propFix[this.toLowerCase()] = this; + }); + function stripAndCollapse(value) { + var tokens = value.match(rnothtmlwhite) || []; + return tokens.join(" "); + } + function getClass(elem) { + return elem.getAttribute && elem.getAttribute("class") || ""; + } + function classesToArray(value) { + if (Array.isArray(value)) { + return value; + } + if (typeof value === "string") { + return value.match(rnothtmlwhite) || []; + } + return []; + } + jQuery2.fn.extend({ + addClass: function(value) { + var classNames, cur, curValue, className, i, finalValue; + if (isFunction(value)) { + return this.each(function(j) { + jQuery2(this).addClass(value.call(this, j, getClass(this))); + }); + } + classNames = classesToArray(value); + if (classNames.length) { + return this.each(function() { + curValue = getClass(this); + cur = this.nodeType === 1 && " " + stripAndCollapse(curValue) + " "; + if (cur) { + for (i = 0; i < classNames.length; i++) { + className = classNames[i]; + if (cur.indexOf(" " + className + " ") < 0) { + cur += className + " "; + } + } + finalValue = stripAndCollapse(cur); + if (curValue !== finalValue) { + this.setAttribute("class", finalValue); + } + } + }); + } + return this; + }, + removeClass: function(value) { + var classNames, cur, curValue, className, i, finalValue; + if (isFunction(value)) { + return this.each(function(j) { + jQuery2(this).removeClass(value.call(this, j, getClass(this))); + }); + } + if (!arguments.length) { + return this.attr("class", ""); + } + classNames = classesToArray(value); + if (classNames.length) { + return this.each(function() { + curValue = getClass(this); + cur = this.nodeType === 1 && " " + stripAndCollapse(curValue) + " "; + if (cur) { + for (i = 0; i < classNames.length; i++) { + className = classNames[i]; + while (cur.indexOf(" " + className + " ") > -1) { + cur = cur.replace(" " + className + " ", " "); + } + } + finalValue = stripAndCollapse(cur); + if (curValue !== finalValue) { + this.setAttribute("class", finalValue); + } + } + }); + } + return this; + }, + toggleClass: function(value, stateVal) { + var classNames, className, i, self, type = typeof value, isValidValue = type === "string" || Array.isArray(value); + if (isFunction(value)) { + return this.each(function(i2) { + jQuery2(this).toggleClass( + value.call(this, i2, getClass(this), stateVal), + stateVal + ); + }); + } + if (typeof stateVal === "boolean" && isValidValue) { + return stateVal ? this.addClass(value) : this.removeClass(value); + } + classNames = classesToArray(value); + return this.each(function() { + if (isValidValue) { + self = jQuery2(this); + for (i = 0; i < classNames.length; i++) { + className = classNames[i]; + if (self.hasClass(className)) { + self.removeClass(className); + } else { + self.addClass(className); + } + } + } else if (value === void 0 || type === "boolean") { + className = getClass(this); + if (className) { + dataPriv.set(this, "__className__", className); + } + if (this.setAttribute) { + this.setAttribute( + "class", + className || value === false ? "" : dataPriv.get(this, "__className__") || "" + ); + } + } + }); + }, + hasClass: function(selector) { + var className, elem, i = 0; + className = " " + selector + " "; + while (elem = this[i++]) { + if (elem.nodeType === 1 && (" " + stripAndCollapse(getClass(elem)) + " ").indexOf(className) > -1) { + return true; + } + } + return false; + } + }); + var rreturn = /\r/g; + jQuery2.fn.extend({ + val: function(value) { + var hooks, ret, valueIsFunction, elem = this[0]; + if (!arguments.length) { + if (elem) { + hooks = jQuery2.valHooks[elem.type] || jQuery2.valHooks[elem.nodeName.toLowerCase()]; + if (hooks && "get" in hooks && (ret = hooks.get(elem, "value")) !== void 0) { + return ret; + } + ret = elem.value; + if (typeof ret === "string") { + return ret.replace(rreturn, ""); + } + return ret == null ? "" : ret; + } + return; + } + valueIsFunction = isFunction(value); + return this.each(function(i) { + var val; + if (this.nodeType !== 1) { + return; + } + if (valueIsFunction) { + val = value.call(this, i, jQuery2(this).val()); + } else { + val = value; + } + if (val == null) { + val = ""; + } else if (typeof val === "number") { + val += ""; + } else if (Array.isArray(val)) { + val = jQuery2.map(val, function(value2) { + return value2 == null ? "" : value2 + ""; + }); + } + hooks = jQuery2.valHooks[this.type] || jQuery2.valHooks[this.nodeName.toLowerCase()]; + if (!hooks || !("set" in hooks) || hooks.set(this, val, "value") === void 0) { + this.value = val; + } + }); + } + }); + jQuery2.extend({ + valHooks: { + option: { + get: function(elem) { + var val = jQuery2.find.attr(elem, "value"); + return val != null ? val : ( + // Support: IE <=10 - 11 only + // option.text throws exceptions (trac-14686, trac-14858) + // Strip and collapse whitespace + // https://html.spec.whatwg.org/#strip-and-collapse-whitespace + stripAndCollapse(jQuery2.text(elem)) + ); + } + }, + select: { + get: function(elem) { + var value, option, i, options = elem.options, index = elem.selectedIndex, one = elem.type === "select-one", values = one ? null : [], max = one ? index + 1 : options.length; + if (index < 0) { + i = max; + } else { + i = one ? index : 0; + } + for (; i < max; i++) { + option = options[i]; + if ((option.selected || i === index) && // Don't return options that are disabled or in a disabled optgroup + !option.disabled && (!option.parentNode.disabled || !nodeName(option.parentNode, "optgroup"))) { + value = jQuery2(option).val(); + if (one) { + return value; + } + values.push(value); + } + } + return values; + }, + set: function(elem, value) { + var optionSet, option, options = elem.options, values = jQuery2.makeArray(value), i = options.length; + while (i--) { + option = options[i]; + if (option.selected = jQuery2.inArray(jQuery2.valHooks.option.get(option), values) > -1) { + optionSet = true; + } + } + if (!optionSet) { + elem.selectedIndex = -1; + } + return values; + } + } + } + }); + jQuery2.each(["radio", "checkbox"], function() { + jQuery2.valHooks[this] = { + set: function(elem, value) { + if (Array.isArray(value)) { + return elem.checked = jQuery2.inArray(jQuery2(elem).val(), value) > -1; + } + } + }; + if (!support.checkOn) { + jQuery2.valHooks[this].get = function(elem) { + return elem.getAttribute("value") === null ? "on" : elem.value; + }; + } + }); + var location2 = window2.location; + var nonce = { guid: Date.now() }; + var rquery = /\?/; + jQuery2.parseXML = function(data) { + var xml, parserErrorElem; + if (!data || typeof data !== "string") { + return null; + } + try { + xml = new window2.DOMParser().parseFromString(data, "text/xml"); + } catch (e) { + } + parserErrorElem = xml && xml.getElementsByTagName("parsererror")[0]; + if (!xml || parserErrorElem) { + jQuery2.error("Invalid XML: " + (parserErrorElem ? jQuery2.map(parserErrorElem.childNodes, function(el) { + return el.textContent; + }).join("\n") : data)); + } + return xml; + }; + var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, stopPropagationCallback = function(e) { + e.stopPropagation(); + }; + jQuery2.extend(jQuery2.event, { + trigger: function(event, data, elem, onlyHandlers) { + var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, eventPath = [elem || document2], type = hasOwn.call(event, "type") ? event.type : event, namespaces = hasOwn.call(event, "namespace") ? event.namespace.split(".") : []; + cur = lastElement = tmp = elem = elem || document2; + if (elem.nodeType === 3 || elem.nodeType === 8) { + return; + } + if (rfocusMorph.test(type + jQuery2.event.triggered)) { + return; + } + if (type.indexOf(".") > -1) { + namespaces = type.split("."); + type = namespaces.shift(); + namespaces.sort(); + } + ontype = type.indexOf(":") < 0 && "on" + type; + event = event[jQuery2.expando] ? event : new jQuery2.Event(type, typeof event === "object" && event); + event.isTrigger = onlyHandlers ? 2 : 3; + event.namespace = namespaces.join("."); + event.rnamespace = event.namespace ? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null; + event.result = void 0; + if (!event.target) { + event.target = elem; + } + data = data == null ? [event] : jQuery2.makeArray(data, [event]); + special = jQuery2.event.special[type] || {}; + if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) { + return; + } + if (!onlyHandlers && !special.noBubble && !isWindow(elem)) { + bubbleType = special.delegateType || type; + if (!rfocusMorph.test(bubbleType + type)) { + cur = cur.parentNode; + } + for (; cur; cur = cur.parentNode) { + eventPath.push(cur); + tmp = cur; + } + if (tmp === (elem.ownerDocument || document2)) { + eventPath.push(tmp.defaultView || tmp.parentWindow || window2); + } + } + i = 0; + while ((cur = eventPath[i++]) && !event.isPropagationStopped()) { + lastElement = cur; + event.type = i > 1 ? bubbleType : special.bindType || type; + handle = (dataPriv.get(cur, "events") || /* @__PURE__ */ Object.create(null))[event.type] && dataPriv.get(cur, "handle"); + if (handle) { + handle.apply(cur, data); + } + handle = ontype && cur[ontype]; + if (handle && handle.apply && acceptData(cur)) { + event.result = handle.apply(cur, data); + if (event.result === false) { + event.preventDefault(); + } + } + } + event.type = type; + if (!onlyHandlers && !event.isDefaultPrevented()) { + if ((!special._default || special._default.apply(eventPath.pop(), data) === false) && acceptData(elem)) { + if (ontype && isFunction(elem[type]) && !isWindow(elem)) { + tmp = elem[ontype]; + if (tmp) { + elem[ontype] = null; + } + jQuery2.event.triggered = type; + if (event.isPropagationStopped()) { + lastElement.addEventListener(type, stopPropagationCallback); + } + elem[type](); + if (event.isPropagationStopped()) { + lastElement.removeEventListener(type, stopPropagationCallback); + } + jQuery2.event.triggered = void 0; + if (tmp) { + elem[ontype] = tmp; + } + } + } + } + return event.result; + }, + // Piggyback on a donor event to simulate a different one + // Used only for `focus(in | out)` events + simulate: function(type, elem, event) { + var e = jQuery2.extend( + new jQuery2.Event(), + event, + { + type, + isSimulated: true + } + ); + jQuery2.event.trigger(e, null, elem); + } + }); + jQuery2.fn.extend({ + trigger: function(type, data) { + return this.each(function() { + jQuery2.event.trigger(type, data, this); + }); + }, + triggerHandler: function(type, data) { + var elem = this[0]; + if (elem) { + return jQuery2.event.trigger(type, data, elem, true); + } + } + }); + var rbracket = /\[\]$/, rCRLF = /\r?\n/g, rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, rsubmittable = /^(?:input|select|textarea|keygen)/i; + function buildParams(prefix, obj, traditional, add) { + var name; + if (Array.isArray(obj)) { + jQuery2.each(obj, function(i, v) { + if (traditional || rbracket.test(prefix)) { + add(prefix, v); + } else { + buildParams( + prefix + "[" + (typeof v === "object" && v != null ? i : "") + "]", + v, + traditional, + add + ); + } + }); + } else if (!traditional && toType(obj) === "object") { + for (name in obj) { + buildParams(prefix + "[" + name + "]", obj[name], traditional, add); + } + } else { + add(prefix, obj); + } + } + jQuery2.param = function(a, traditional) { + var prefix, s = [], add = function(key, valueOrFunction) { + var value = isFunction(valueOrFunction) ? valueOrFunction() : valueOrFunction; + s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value == null ? "" : value); + }; + if (a == null) { + return ""; + } + if (Array.isArray(a) || a.jquery && !jQuery2.isPlainObject(a)) { + jQuery2.each(a, function() { + add(this.name, this.value); + }); + } else { + for (prefix in a) { + buildParams(prefix, a[prefix], traditional, add); + } + } + return s.join("&"); + }; + jQuery2.fn.extend({ + serialize: function() { + return jQuery2.param(this.serializeArray()); + }, + serializeArray: function() { + return this.map(function() { + var elements = jQuery2.prop(this, "elements"); + return elements ? jQuery2.makeArray(elements) : this; + }).filter(function() { + var type = this.type; + return this.name && !jQuery2(this).is(":disabled") && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (this.checked || !rcheckableType.test(type)); + }).map(function(_i, elem) { + var val = jQuery2(this).val(); + if (val == null) { + return null; + } + if (Array.isArray(val)) { + return jQuery2.map(val, function(val2) { + return { name: elem.name, value: val2.replace(rCRLF, "\r\n") }; + }); + } + return { name: elem.name, value: val.replace(rCRLF, "\r\n") }; + }).get(); + } + }); + var r20 = /%20/g, rhash = /#.*$/, rantiCache = /([?&])_=[^&]*/, rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, rnoContent = /^(?:GET|HEAD)$/, rprotocol = /^\/\//, prefilters = {}, transports = {}, allTypes = "*/".concat("*"), originAnchor = document2.createElement("a"); + originAnchor.href = location2.href; + function addToPrefiltersOrTransports(structure) { + return function(dataTypeExpression, func) { + if (typeof dataTypeExpression !== "string") { + func = dataTypeExpression; + dataTypeExpression = "*"; + } + var dataType, i = 0, dataTypes = dataTypeExpression.toLowerCase().match(rnothtmlwhite) || []; + if (isFunction(func)) { + while (dataType = dataTypes[i++]) { + if (dataType[0] === "+") { + dataType = dataType.slice(1) || "*"; + (structure[dataType] = structure[dataType] || []).unshift(func); + } else { + (structure[dataType] = structure[dataType] || []).push(func); + } + } + } + }; + } + function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) { + var inspected = {}, seekingTransport = structure === transports; + function inspect(dataType) { + var selected; + inspected[dataType] = true; + jQuery2.each(structure[dataType] || [], function(_, prefilterOrFactory) { + var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR); + if (typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[dataTypeOrTransport]) { + options.dataTypes.unshift(dataTypeOrTransport); + inspect(dataTypeOrTransport); + return false; + } else if (seekingTransport) { + return !(selected = dataTypeOrTransport); + } + }); + return selected; + } + return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*"); + } + function ajaxExtend(target, src) { + var key, deep, flatOptions = jQuery2.ajaxSettings.flatOptions || {}; + for (key in src) { + if (src[key] !== void 0) { + (flatOptions[key] ? target : deep || (deep = {}))[key] = src[key]; + } + } + if (deep) { + jQuery2.extend(true, target, deep); + } + return target; + } + function ajaxHandleResponses(s, jqXHR, responses) { + var ct, type, finalDataType, firstDataType, contents = s.contents, dataTypes = s.dataTypes; + while (dataTypes[0] === "*") { + dataTypes.shift(); + if (ct === void 0) { + ct = s.mimeType || jqXHR.getResponseHeader("Content-Type"); + } + } + if (ct) { + for (type in contents) { + if (contents[type] && contents[type].test(ct)) { + dataTypes.unshift(type); + break; + } + } + } + if (dataTypes[0] in responses) { + finalDataType = dataTypes[0]; + } else { + for (type in responses) { + if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) { + finalDataType = type; + break; + } + if (!firstDataType) { + firstDataType = type; + } + } + finalDataType = finalDataType || firstDataType; + } + if (finalDataType) { + if (finalDataType !== dataTypes[0]) { + dataTypes.unshift(finalDataType); + } + return responses[finalDataType]; + } + } + function ajaxConvert(s, response, jqXHR, isSuccess) { + var conv2, current, conv, tmp, prev, converters = {}, dataTypes = s.dataTypes.slice(); + if (dataTypes[1]) { + for (conv in s.converters) { + converters[conv.toLowerCase()] = s.converters[conv]; + } + } + current = dataTypes.shift(); + while (current) { + if (s.responseFields[current]) { + jqXHR[s.responseFields[current]] = response; + } + if (!prev && isSuccess && s.dataFilter) { + response = s.dataFilter(response, s.dataType); + } + prev = current; + current = dataTypes.shift(); + if (current) { + if (current === "*") { + current = prev; + } else if (prev !== "*" && prev !== current) { + conv = converters[prev + " " + current] || converters["* " + current]; + if (!conv) { + for (conv2 in converters) { + tmp = conv2.split(" "); + if (tmp[1] === current) { + conv = converters[prev + " " + tmp[0]] || converters["* " + tmp[0]]; + if (conv) { + if (conv === true) { + conv = converters[conv2]; + } else if (converters[conv2] !== true) { + current = tmp[0]; + dataTypes.unshift(tmp[1]); + } + break; + } + } + } + } + if (conv !== true) { + if (conv && s.throws) { + response = conv(response); + } else { + try { + response = conv(response); + } catch (e) { + return { + state: "parsererror", + error: conv ? e : "No conversion from " + prev + " to " + current + }; + } + } + } + } + } + } + return { state: "success", data: response }; + } + jQuery2.extend({ + // Counter for holding the number of active queries + active: 0, + // Last-Modified header cache for next request + lastModified: {}, + etag: {}, + ajaxSettings: { + url: location2.href, + type: "GET", + isLocal: rlocalProtocol.test(location2.protocol), + global: true, + processData: true, + async: true, + contentType: "application/x-www-form-urlencoded; charset=UTF-8", + /* + timeout: 0, + data: null, + dataType: null, + username: null, + password: null, + cache: null, + throws: false, + traditional: false, + headers: {}, + */ + accepts: { + "*": allTypes, + text: "text/plain", + html: "text/html", + xml: "application/xml, text/xml", + json: "application/json, text/javascript" + }, + contents: { + xml: /\bxml\b/, + html: /\bhtml/, + json: /\bjson\b/ + }, + responseFields: { + xml: "responseXML", + text: "responseText", + json: "responseJSON" + }, + // Data converters + // Keys separate source (or catchall "*") and destination types with a single space + converters: { + // Convert anything to text + "* text": String, + // Text to html (true = no transformation) + "text html": true, + // Evaluate text as a json expression + "text json": JSON.parse, + // Parse text as xml + "text xml": jQuery2.parseXML + }, + // For options that shouldn't be deep extended: + // you can add your own custom options here if + // and when you create one that shouldn't be + // deep extended (see ajaxExtend) + flatOptions: { + url: true, + context: true + } + }, + // Creates a full fledged settings object into target + // with both ajaxSettings and settings fields. + // If target is omitted, writes into ajaxSettings. + ajaxSetup: function(target, settings) { + return settings ? ( + // Building a settings object + ajaxExtend(ajaxExtend(target, jQuery2.ajaxSettings), settings) + ) : ( + // Extending ajaxSettings + ajaxExtend(jQuery2.ajaxSettings, target) + ); + }, + ajaxPrefilter: addToPrefiltersOrTransports(prefilters), + ajaxTransport: addToPrefiltersOrTransports(transports), + // Main method + ajax: function(url, options) { + if (typeof url === "object") { + options = url; + url = void 0; + } + options = options || {}; + var transport, cacheURL, responseHeadersString, responseHeaders, timeoutTimer, urlAnchor, completed2, fireGlobals, i, uncached, s = jQuery2.ajaxSetup({}, options), callbackContext = s.context || s, globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ? jQuery2(callbackContext) : jQuery2.event, deferred = jQuery2.Deferred(), completeDeferred = jQuery2.Callbacks("once memory"), statusCode = s.statusCode || {}, requestHeaders = {}, requestHeadersNames = {}, strAbort = "canceled", jqXHR = { + readyState: 0, + // Builds headers hashtable if needed + getResponseHeader: function(key) { + var match; + if (completed2) { + if (!responseHeaders) { + responseHeaders = {}; + while (match = rheaders.exec(responseHeadersString)) { + responseHeaders[match[1].toLowerCase() + " "] = (responseHeaders[match[1].toLowerCase() + " "] || []).concat(match[2]); + } + } + match = responseHeaders[key.toLowerCase() + " "]; + } + return match == null ? null : match.join(", "); + }, + // Raw string + getAllResponseHeaders: function() { + return completed2 ? responseHeadersString : null; + }, + // Caches the header + setRequestHeader: function(name, value) { + if (completed2 == null) { + name = requestHeadersNames[name.toLowerCase()] = requestHeadersNames[name.toLowerCase()] || name; + requestHeaders[name] = value; + } + return this; + }, + // Overrides response content-type header + overrideMimeType: function(type) { + if (completed2 == null) { + s.mimeType = type; + } + return this; + }, + // Status-dependent callbacks + statusCode: function(map) { + var code; + if (map) { + if (completed2) { + jqXHR.always(map[jqXHR.status]); + } else { + for (code in map) { + statusCode[code] = [statusCode[code], map[code]]; + } + } + } + return this; + }, + // Cancel the request + abort: function(statusText) { + var finalText = statusText || strAbort; + if (transport) { + transport.abort(finalText); + } + done(0, finalText); + return this; + } + }; + deferred.promise(jqXHR); + s.url = ((url || s.url || location2.href) + "").replace(rprotocol, location2.protocol + "//"); + s.type = options.method || options.type || s.method || s.type; + s.dataTypes = (s.dataType || "*").toLowerCase().match(rnothtmlwhite) || [""]; + if (s.crossDomain == null) { + urlAnchor = document2.createElement("a"); + try { + urlAnchor.href = s.url; + urlAnchor.href = urlAnchor.href; + s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== urlAnchor.protocol + "//" + urlAnchor.host; + } catch (e) { + s.crossDomain = true; + } + } + if (s.data && s.processData && typeof s.data !== "string") { + s.data = jQuery2.param(s.data, s.traditional); + } + inspectPrefiltersOrTransports(prefilters, s, options, jqXHR); + if (completed2) { + return jqXHR; + } + fireGlobals = jQuery2.event && s.global; + if (fireGlobals && jQuery2.active++ === 0) { + jQuery2.event.trigger("ajaxStart"); + } + s.type = s.type.toUpperCase(); + s.hasContent = !rnoContent.test(s.type); + cacheURL = s.url.replace(rhash, ""); + if (!s.hasContent) { + uncached = s.url.slice(cacheURL.length); + if (s.data && (s.processData || typeof s.data === "string")) { + cacheURL += (rquery.test(cacheURL) ? "&" : "?") + s.data; + delete s.data; + } + if (s.cache === false) { + cacheURL = cacheURL.replace(rantiCache, "$1"); + uncached = (rquery.test(cacheURL) ? "&" : "?") + "_=" + nonce.guid++ + uncached; + } + s.url = cacheURL + uncached; + } else if (s.data && s.processData && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0) { + s.data = s.data.replace(r20, "+"); + } + if (s.ifModified) { + if (jQuery2.lastModified[cacheURL]) { + jqXHR.setRequestHeader("If-Modified-Since", jQuery2.lastModified[cacheURL]); + } + if (jQuery2.etag[cacheURL]) { + jqXHR.setRequestHeader("If-None-Match", jQuery2.etag[cacheURL]); + } + } + if (s.data && s.hasContent && s.contentType !== false || options.contentType) { + jqXHR.setRequestHeader("Content-Type", s.contentType); + } + jqXHR.setRequestHeader( + "Accept", + s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== "*" ? ", " + allTypes + "; q=0.01" : "") : s.accepts["*"] + ); + for (i in s.headers) { + jqXHR.setRequestHeader(i, s.headers[i]); + } + if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || completed2)) { + return jqXHR.abort(); + } + strAbort = "abort"; + completeDeferred.add(s.complete); + jqXHR.done(s.success); + jqXHR.fail(s.error); + transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR); + if (!transport) { + done(-1, "No Transport"); + } else { + jqXHR.readyState = 1; + if (fireGlobals) { + globalEventContext.trigger("ajaxSend", [jqXHR, s]); + } + if (completed2) { + return jqXHR; + } + if (s.async && s.timeout > 0) { + timeoutTimer = window2.setTimeout(function() { + jqXHR.abort("timeout"); + }, s.timeout); + } + try { + completed2 = false; + transport.send(requestHeaders, done); + } catch (e) { + if (completed2) { + throw e; + } + done(-1, e); + } + } + function done(status, nativeStatusText, responses, headers) { + var isSuccess, success, error, response, modified, statusText = nativeStatusText; + if (completed2) { + return; + } + completed2 = true; + if (timeoutTimer) { + window2.clearTimeout(timeoutTimer); + } + transport = void 0; + responseHeadersString = headers || ""; + jqXHR.readyState = status > 0 ? 4 : 0; + isSuccess = status >= 200 && status < 300 || status === 304; + if (responses) { + response = ajaxHandleResponses(s, jqXHR, responses); + } + if (!isSuccess && jQuery2.inArray("script", s.dataTypes) > -1 && jQuery2.inArray("json", s.dataTypes) < 0) { + s.converters["text script"] = function() { + }; + } + response = ajaxConvert(s, response, jqXHR, isSuccess); + if (isSuccess) { + if (s.ifModified) { + modified = jqXHR.getResponseHeader("Last-Modified"); + if (modified) { + jQuery2.lastModified[cacheURL] = modified; + } + modified = jqXHR.getResponseHeader("etag"); + if (modified) { + jQuery2.etag[cacheURL] = modified; + } + } + if (status === 204 || s.type === "HEAD") { + statusText = "nocontent"; + } else if (status === 304) { + statusText = "notmodified"; + } else { + statusText = response.state; + success = response.data; + error = response.error; + isSuccess = !error; + } + } else { + error = statusText; + if (status || !statusText) { + statusText = "error"; + if (status < 0) { + status = 0; + } + } + } + jqXHR.status = status; + jqXHR.statusText = (nativeStatusText || statusText) + ""; + if (isSuccess) { + deferred.resolveWith(callbackContext, [success, statusText, jqXHR]); + } else { + deferred.rejectWith(callbackContext, [jqXHR, statusText, error]); + } + jqXHR.statusCode(statusCode); + statusCode = void 0; + if (fireGlobals) { + globalEventContext.trigger( + isSuccess ? "ajaxSuccess" : "ajaxError", + [jqXHR, s, isSuccess ? success : error] + ); + } + completeDeferred.fireWith(callbackContext, [jqXHR, statusText]); + if (fireGlobals) { + globalEventContext.trigger("ajaxComplete", [jqXHR, s]); + if (!--jQuery2.active) { + jQuery2.event.trigger("ajaxStop"); + } + } + } + return jqXHR; + }, + getJSON: function(url, data, callback) { + return jQuery2.get(url, data, callback, "json"); + }, + getScript: function(url, callback) { + return jQuery2.get(url, void 0, callback, "script"); + } + }); + jQuery2.each(["get", "post"], function(_i, method) { + jQuery2[method] = function(url, data, callback, type) { + if (isFunction(data)) { + type = type || callback; + callback = data; + data = void 0; + } + return jQuery2.ajax(jQuery2.extend({ + url, + type: method, + dataType: type, + data, + success: callback + }, jQuery2.isPlainObject(url) && url)); + }; + }); + jQuery2.ajaxPrefilter(function(s) { + var i; + for (i in s.headers) { + if (i.toLowerCase() === "content-type") { + s.contentType = s.headers[i] || ""; + } + } + }); + jQuery2._evalUrl = function(url, options, doc) { + return jQuery2.ajax({ + url, + // Make this explicit, since user can override this through ajaxSetup (trac-11264) + type: "GET", + dataType: "script", + cache: true, + async: false, + global: false, + // Only evaluate the response if it is successful (gh-4126) + // dataFilter is not invoked for failure responses, so using it instead + // of the default converter is kludgy but it works. + converters: { + "text script": function() { + } + }, + dataFilter: function(response) { + jQuery2.globalEval(response, options, doc); + } + }); + }; + jQuery2.fn.extend({ + wrapAll: function(html) { + var wrap; + if (this[0]) { + if (isFunction(html)) { + html = html.call(this[0]); + } + wrap = jQuery2(html, this[0].ownerDocument).eq(0).clone(true); + if (this[0].parentNode) { + wrap.insertBefore(this[0]); + } + wrap.map(function() { + var elem = this; + while (elem.firstElementChild) { + elem = elem.firstElementChild; + } + return elem; + }).append(this); + } + return this; + }, + wrapInner: function(html) { + if (isFunction(html)) { + return this.each(function(i) { + jQuery2(this).wrapInner(html.call(this, i)); + }); + } + return this.each(function() { + var self = jQuery2(this), contents = self.contents(); + if (contents.length) { + contents.wrapAll(html); + } else { + self.append(html); + } + }); + }, + wrap: function(html) { + var htmlIsFunction = isFunction(html); + return this.each(function(i) { + jQuery2(this).wrapAll(htmlIsFunction ? html.call(this, i) : html); + }); + }, + unwrap: function(selector) { + this.parent(selector).not("body").each(function() { + jQuery2(this).replaceWith(this.childNodes); + }); + return this; + } + }); + jQuery2.expr.pseudos.hidden = function(elem) { + return !jQuery2.expr.pseudos.visible(elem); + }; + jQuery2.expr.pseudos.visible = function(elem) { + return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length); + }; + jQuery2.ajaxSettings.xhr = function() { + try { + return new window2.XMLHttpRequest(); + } catch (e) { + } + }; + var xhrSuccessStatus = { + // File protocol always yields status code 0, assume 200 + 0: 200, + // Support: IE <=9 only + // trac-1450: sometimes IE returns 1223 when it should be 204 + 1223: 204 + }, xhrSupported = jQuery2.ajaxSettings.xhr(); + support.cors = !!xhrSupported && "withCredentials" in xhrSupported; + support.ajax = xhrSupported = !!xhrSupported; + jQuery2.ajaxTransport(function(options) { + var callback, errorCallback; + if (support.cors || xhrSupported && !options.crossDomain) { + return { + send: function(headers, complete) { + var i, xhr = options.xhr(); + xhr.open( + options.type, + options.url, + options.async, + options.username, + options.password + ); + if (options.xhrFields) { + for (i in options.xhrFields) { + xhr[i] = options.xhrFields[i]; + } + } + if (options.mimeType && xhr.overrideMimeType) { + xhr.overrideMimeType(options.mimeType); + } + if (!options.crossDomain && !headers["X-Requested-With"]) { + headers["X-Requested-With"] = "XMLHttpRequest"; + } + for (i in headers) { + xhr.setRequestHeader(i, headers[i]); + } + callback = function(type) { + return function() { + if (callback) { + callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = xhr.onreadystatechange = null; + if (type === "abort") { + xhr.abort(); + } else if (type === "error") { + if (typeof xhr.status !== "number") { + complete(0, "error"); + } else { + complete( + // File: protocol always yields status 0; see trac-8605, trac-14207 + xhr.status, + xhr.statusText + ); + } + } else { + complete( + xhrSuccessStatus[xhr.status] || xhr.status, + xhr.statusText, + // Support: IE <=9 only + // IE9 has no XHR2 but throws on binary (trac-11426) + // For XHR2 non-text, let the caller handle it (gh-2498) + (xhr.responseType || "text") !== "text" || typeof xhr.responseText !== "string" ? { binary: xhr.response } : { text: xhr.responseText }, + xhr.getAllResponseHeaders() + ); + } + } + }; + }; + xhr.onload = callback(); + errorCallback = xhr.onerror = xhr.ontimeout = callback("error"); + if (xhr.onabort !== void 0) { + xhr.onabort = errorCallback; + } else { + xhr.onreadystatechange = function() { + if (xhr.readyState === 4) { + window2.setTimeout(function() { + if (callback) { + errorCallback(); + } + }); + } + }; + } + callback = callback("abort"); + try { + xhr.send(options.hasContent && options.data || null); + } catch (e) { + if (callback) { + throw e; + } + } + }, + abort: function() { + if (callback) { + callback(); + } + } + }; + } + }); + jQuery2.ajaxPrefilter(function(s) { + if (s.crossDomain) { + s.contents.script = false; + } + }); + jQuery2.ajaxSetup({ + accepts: { + script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript" + }, + contents: { + script: /\b(?:java|ecma)script\b/ + }, + converters: { + "text script": function(text) { + jQuery2.globalEval(text); + return text; + } + } + }); + jQuery2.ajaxPrefilter("script", function(s) { + if (s.cache === void 0) { + s.cache = false; + } + if (s.crossDomain) { + s.type = "GET"; + } + }); + jQuery2.ajaxTransport("script", function(s) { + if (s.crossDomain || s.scriptAttrs) { + var script, callback; + return { + send: function(_, complete) { + script = jQuery2("